Mathematica

260.170 VO Einführung in das funktionale und
symbolische Programmieren mit Mathematica
F. Mittendorfer
E-mail: [email protected]
Überblick
1.
Einleitung
1.0. Computer Algebra Systems (CAS)
1.1. Programmier - Paradigmen
Prozedural (FORTRAN, C)
Regelbasierend & Rekursiv (PROLOG, LISP)
Funktional (APL, J, FP)
Objekt-orientiert (Java, C++)
1.2. Einleitung: Mathematica
2.
Struktur von Mathematica
2.1. Datentypen / Expressions
2.2. Pattern Matching (Mustererkennung)
2.3 Manipulation von Expressions / Rules (Regeln)
2.4 Performance: Auswertungsschritte
3.
Funktionale Methoden
3.1.
3.2.
3.3.
3.4.
4.
Konzepte
Einfache Funktionen in Mathematica
Fortgeschrittene Funktionen & Pure functions
Zelluläre Automaten
Objekt-orientiertes Programmieren in Mathematica
4.1. Konzepte
4.2. OOP in Mathematica
4.3. Encapsulation: Packages und Context
5. Listen-Operationen
6. Graphik in Mathematica
7. Symbolische Operationen mit Mathematica
8. Differentialgleichungen
Literatur
• Stephen Wolfram
: The Mathematica Book, 5th Edition
(V7: Documentation Center direkt von
Mathematica aus aufrufbar!)
• Michael Trott
: The Mathematica Guidebook for
Programming,Springer,2005
• Roman E. Maeder
: Programming in Mathematica,
AddisonWesley, 1997.
• Skript: http://cmp.univie.ac.at -> Teaching ->Mathematica
Einleitung
General Purpose Computer Algebra Systems: (CAS)
Software für ‚symbolische„ Mathematik:
- Beliebige Rechengenauigkeit
- Lineares Algebra Subsystem (Matrix-Berechnungen)
- Graphisches Interface für die Darstellung der Daten
- Programmiersprache für die Implementation von neuen Algorithmen
- Symbolische Operationen (Vereinfachung von Ausdrücken, Differentieren,
Integration)
Symbolic Algebra Systems (CAS)
•
•
•
•
•
(a + b)2

a2 + 2ab + b2
x (2 - ax)2 
-2a(2 - ax) ( or –4a + 2a2x )
 dx (x - 1) 3 
(x - 1) 4/4
(x2 - y2)/(x - y)

x+y
Gewöhnliche Differentialgleichungen ?
Beispiele
•
•
•
•
•
•
•
•
•
LISP*
(programming language)
Axiom*
(IBM)
Derive
(TI)
GNU-calc
(in emacs-LISP)
Jacal (GNU Copyleft)
Maple
Mathematica
Maxima* (former Macsyma, LISP based)
Reduce (LISP based)
*: freeware/GNU licence…
• Special Purpose Computer Algebra Systems:
-Algebra und number theory (PARI-GP*)
-Tensor analysis
-Differential equations
Entwicklung von Computeralgebrasystemen
•
1844
Ada Byron, Countess of Lovelace: „...suggesting the use of
computers for symbolic rather than numerical computation“
•
1. Generation
1960 – 1970
•
•
SNOBOL, LISP
Computer Sprachen mit Ausrichtung auf
symbolische Operationen
2. Generation Matlab, Macsyma(MIT,1968)
1970 – 1980
Plattform für numerische Berechnungen:
Matrix Manipulationen, Daten+ Funktions
plots, Numerische Analysis
3rd Generation Maple , Mathematica, ...
1980 –
Verstärkte symbolische
Einsatzmöglichkeit
• Stärken von Mathematica
–
–
–
–
–
Pattern matching (Mustererkennung)
Symbolische Operationen (Integration etc.)
Polynomiale Probleme
Numerische Auswertungen
Gute Entwicklungsmöglichkeit für Programme
• Schwächen von Mathematica
–
–
–
–
Partielle Differentialgleichungen höherer Ordnung
Integral-Gleichungen
Geschwindigkeitsabhängige numerische Anwendungen:
Ray Tracing etc.
1.2 Programmier -Paradigmen
• 1.2.0. Sprachelemente in Mathematica
Mathematica unterstützt unterschiedliche Programmieransätze!
Prozedural
Funktional
Objektorientiert
Logisch/Regelbasierend
1.2.1. Imperativ/Prozedural (FORTRAN,C)
– program state (Maschinenzustand): wird duch
eine Reihe von Befehlen verändert
• Maschinensprache : Speicher / Befehle
• Höhere Programmiersprachen:
–
–
–
–
Variablenzuweisung
Looping (Schleifen)
Conditional branching (IF)
unconditional branching (GOTO)
• Struktural
-Häufige Verwendung von Schleifen (WHILE,FOR),
kein GOTO
-Jede Teilstruktur hat genau einen Eintritts- und
Austrittspunkt
• Prozedural
- top-down Ansatz: Programm wird in kleinere
Einheiten unterteilt (procedures, subroutines)
- Programmteile können besser weiterverwendet
werden
• Relevanz für Mathematica:
– Implementiert, aber teilweise sehr ineffizient!
1.2.2.
Objekt-orientiertes Programmieren (OOP):
C++,Java,...
- Objekte & Methoden als Basis
- Abstraktion: Objekte können miteinander kommunizieren
ohne zu internen Aufbau zu kennen
- Kapselung (information hiding): interne Details der
Objekte nicht nach aussen sichtbar
- Polymorphismus: Gleiches Interface für
verschiedenartige Objekte
- Vererbung: Eigenschaften können an verwandte Objekte
weitergegeben werden
(-> Klassen)
• Relevanz für Mathematica:
– Wichtige Konzepte (Packages), aber OOP nicht zu 100%
implementiert.
1.2.3.
Funktionales Programmieren (LISP,F#,Scala,..)
• Programm besteht ausschließlich aus Funktionsaufrufen!
– f(g(h(x)))
• Funktion statt Variablenzuweisungen
– Funktion: Null oder mehr Parameter, ein einziger Return Value
– “first class values”: Funktionen auch als Input/Return Werte
• Dadurch keine vordefinierte Reihenfolge in Programmausführung
• ermöglicht:
map (mapping von Funktionen auf Listen)
Rekursive Funktionen
…
• Vorteile:
– Keine Nebeneffekte !
• Funktionsaufruf führt nur zur Berechnung des Ergebnisses
– Werttreue
• Variablen können in jedem Schritt durch ihre Werte ersetzt
werden
– Implizites Allozieren des Speichers
• Nachteile:
Geschwindigkeit (?)
Ressourcenbedarf
• Relevanz für Mathematica:
– Programmierstil ergibt sich direkt für Mathematica, in der Praxis
aber of Mischform (zb. Variablen) für bessere Lesbarkeit
1.2.3.1. Funktionales Programmieren - LISP
- Eine der ältesten Programmiersprachen (1958), noch immer in
Verwendung (Finanz,AI)
- LISt Processing: Wesentliche Datenstrukturen: (Linked) Lists
(data+link)
- Daten verwenden ‚prefix„ Notation:
(list 1 2 “bla”)
(+ 1 2 3 4)
- Auch Funktionen als Listen:
/* z.B. : f(x)=x+1*/
(lambda (arg) (+ arg 1))
- Dynamisches data typing (häufig bei interpretierten Sprachen)
1.2.4. Logisches (Regel basierendes)
Programmieren (PROLOG)
Definition von Eigenschaften der Lösung an Stelle von
konkreten Rechenoperationen:
- Facts (Fakten): head + parameter: car(blue)
- Rules (Regeln): light (on) :- switch(on)
- Datenbank von Fakten und Regeln.
- Fakten + Regeln = Ergebnis
- Auswertung durch eine Abfrage der Datenbank
- Wenn noch keine zutreffenden Fakten gefunden werden
werden neue durch die Regeln produziert
• Relevanz für Mathematica:
– Die Datenstruktur von Mma erlaubt eine direkte Umsetzung von
diesem Konzept: Pattern matching (Mustererkennung)!
Rulebase Programming: Beispiel
Family Tree:
Rules:
sisterof( X, Y ) :- parents( X, M, F ),
female( X ),
parents( Y, M, F ).
Facts:
parents( Bart, Marge, Homer ).
parents( Lisa, Marge, Homer ).
parents( Maggy, Marge, Homer ).
female( Lisa ).
loves( Homer, Beer ).
loves( Lisa, Music ).
--------------------------------------------------------? sisterof(Lisa,X)
? sisterof(Lisa,Bart)
Rule based Programming: Examples 2
• Count Elements in List
elems([],0).
elems([H|T], X) :- elems(T, Y), X is Y + 1.
Query: elems(Liste,a)
/*Fact */
/*Rule */
• Symbolic operations: Differentiation
d(x,x,1) :- !.
/* dx/dx = 1 */
d(C,x,0) :- atomic(C)
/* dC/dx = 0 */
d(u+v,x,a+b) :- d(u,x,a) , d(v,x,b)
/* d(u+v)/dx = du/dx+dv/dx */
d(u*v,x,b*u+a*v) :- d(u,x,a),d(v,x,b)
...
Query: d(c*u+v,x,res)