MAPLE – Grundlagen 2 - tci.uni-hannover.de · 10 Juli 2013 Integration von Funktionen • Integration einer Funktion in einer Variablen – Grundform: bestimmtes Integral: int(f(x),

Juli 2013

MAPLE – Grundlagen 2

MAPLE-Grundlagen 2Ivo Havlík, TCI 1

Ivo Havlík

Leibniz Universität Hannover

Institut für Technische Chemie

Callinstr. 5

30167 Hannover

Germany

Juli 20132

Maple-Grundlagen 1 - Rekapitulation

• Elementare Rechenoperationen– evalf()

• Umformen von Ausdrücken– subs(), simplify(), expand(), factor(), assume()

• Gleichungen, Gleichungssysteme– solve(), fsolve(), lhs(), rhs(), assign()

• Elementare Funktionen– sum(), mul(), limit(), Pi, sqrt(), sin(), ...

Ivo Havlík, TCI MAPLE-Grundlagen 2

Juli 20133

Maple-Grundlagen 1 - Rekapitulation

• Funktionen und Ausdrücke– apply(), unapply()

• Einfache Graphische Darstellung– plot()

• Differenzieren von Funktionen– diff(), D(), Diff()

• Integration von Funktionen– int(), Int(), value()


Juli 20134

Maple-Grundlagen 2 - Inhalt

• Differenzieren, Integration

• Einbindung von Packages: with()

• Matrizen– Definition, Operationen, Eigenvalues, Rang

• Programmieren– Grundlagen der Programmierungskonstrukte


Juli 20135

Differenzieren von Funktionen


• gewöhnliche Ableitung (1 unabhängige Variable), Ableitung als Ausdruck (expr):– diff(expr,x), höhere Ableitung: diff(expr, x$n)– Ergebnis ist ein Ausdruck

>diff(x^2+ln(x), x); -> oder: >expr:=x^2+ln(x); diff(expr,x);

– höhere Ableitungen: durch Verkettung oder direkt >diff(x^2+ln(x), x);diff(%,x); >diff(x^2+ln(x), x$2); -> >diff(x^2+ln(x), x, x);

Juli 20136

Differenzieren von Funktionen• gewöhnliche Ableitung (1 unabhängige Variable),

Ableitung als Funktion:– Funktion einer Variablen, f:=x -> g(x)– Ableitung mit D(f), Ergebnis ist eine Funktion

>f:=x -> x^2+ln(x); D(f); ->

– D(f)(3) : erste Ableitung im Punkt x=3 beachte: D(f)(x) = diff(f(x),x): Ergebnis ist ein Ausdruck

(in die aus D(f) resultierende Funktion wird "x" eingesetzt)– 5-te Ableitung: >(D@@5)(f) ->

alternativ: D[1$5](f) - 5-te Ableitung der Funktion f


Juli 20137

Differenzieren von Funktionen• partielle Ableitung (2 unabhängige Variablen)

diff(f(x1,x2,...),xi) für Ausdrücke, Ergebnis: ein Ausdruck

>f:=1/(x-y): diff(f,x); -> diff(f,y); ->

D[i](f) für Funktionen, Ergebnis: eine Funktion

>f := (x,y) -> 1/(x-y):

D[1](f); -> D[2](f); ->

D[1](f)(u,w); -> ist ein Ausdruck (u,w eingesetzt)

• Höhere partielle Ableitungen: analogisch den gewöhnlichen


Juli 20138

Differenzieren von Funktionen

• inerte Form: Diff()– bei Großschreibung Diff(f(x),x) wird die Ableitung

nur symbolisch dargestellt und nicht ausgewertet– Sinn: für Darstellungs- und Druckzwecke in der

Worksheet

>expr:=x^2+ln(x): Diff(expr,x) = diff(expr,x);

– ähnlich bei der Integration: int() und Int()


Juli 20139

Integration von Funktionen• Maple integriert Funktionen in einer Variablen

(y:=f(x))– eine der Zentralanwendungen von Maple

• Maple durchführt– symbolische Berechnung der Stammfunktion zu

einer Funktion (unbestimmtes Integral)– symbolisch-numerische Berechnung des bestimmten

Integrals– numerische Integration einer Funktion– numerische Approximation eines bestimmten

Integrals mit Methoden wie Trapez, Simpson etc.


Juli 201310

Integration von Funktionen

• Integration einer Funktion in einer Variablen– Grundform: bestimmtes Integral: int(f(x), x=a..b)– wenn keine Integrationsgrenzen angegeben sind,

wird die Stammfunktion berechnet (unbestimmtes Integral): int(f(x), x)

– inerte Form Int(f(x), x=a..b): nur symbolische Darstellung, spätere Auswertung mit value() möglich

– als Integrationsgrenzen sind auch -∞ und ∞ zugelassen (uneigentliche Integrale)

– Mehrfach- und Linienintegrale: nach Zerlegung in einfache Integrale wird int() verwendet (Maplebesitzt für solche Integrale kein explizites Befehl)


Juli 201311


• bestimmtes, unbestimmtes Integral– bestimmtes Integral: int(f(x),x=a..b)

>f:=sin(x)*x: int(f,x=0..Pi); -> π– oder über die inerte Form und Auswertung:

>Int(f,x=0..Pi); value(%); -> π– unbestimmtes Integral/Stammfunktion: int(f(x),x)

>f:=sin(x)*x: int(f,x); -> sin(x) - cos(x)*x– oder über die inerte Form und spätere Auswertung

>Int(f,x); value(%); -> sin(x) - cos(x)*x

• Numerische Integration einer Funktion– über die inerte Form (ohne Stammfunktion)

>Int(f,x=0..Pi); evalf(%); -> 3.141592654


Juli 201312


• Numerische Integration– über die inerte Form (ohne Zwischenberechnung der

Stammfuktion) >Int(f,x=a..b);evalf(%); >Int((sin(x)*x),x=0..Pi); evalf(%); -> 3.141592654

– oder über das Befehl ApproximateInt() unter Verwendung von Integrationsmethoden wie Trapez, Simpson etc. in package Student with(Student[Calculus1]): f := x -> piecewise(x<1.5,x^2,x<3,x+0.75,6.75-x); ApproximateInt(f(x),x=-2..6,method=simpson,output=plot,

partition=100);


Juli 201313

Pakete einbinden mit with()• Pakete (packages) sind Sammlungen von Prozeduren

zum Lösen von einem bestimmten Problemkreis, wie z.B.– Spezielle Grafiktypen (plots, plottools)– Kurvenanpassung (CurveFitting)– Lösung von partiellen DGL (PDETools)– Statistik (Statistics)

• Sinn: Arbeitsspeicher sparen• Liste aller Pakete: >?index,package• Liste der Prozeduren im Paket: >?package_name;• In Maple 13 sind etwa 130 Pakete enthalten


Juli 201314

Pakete einbinden mit with()

• Verwendung: with(package_name)– >with(LinearAlgebra);– Danach stehen die in diesem Paket enthaltenen

Prozeduren zur Verfügung– Nach >with(package_name); wird die Liste

sämtlicher Prozeduren ausgegeben– Falls das entsprechende Paket nicht eingebunden ist,

sind die Prozeduren nicht definiert und die Aktion wird nicht ausgeführt (nur Echo):>M := RandomMatrix(5); -> M := RandomMatrix(5)

– In welchem Paket die Prozedur enthalten ist, erfährt man in der Hilfe


Juli 201315

Pakete einbinden mit with()

• >restart; entfernt sämtliche Pakete• Selektives Entfernen eines Pakets aus dem

Arbeitsspeicher: >unwith(package_name);– Danach sind die Paket-Prozeduren wieder

undefiniert• Übersicht der aktuell eingebundenen Pakete:

– >packages();


Juli 201316

Vektoren, Matrizen, Eigenwerte

• Prozeduren für Vektor- und Matrixoperationen sind im Paket LinearAlgebra enthalten

• Vektoren– Definition, Kurzschreibweise– Addition, Subtraktion, Skalarprodukt, Kreuzprodukt,

Winkel zwischen zwei Vektoren, Betrag eines Vektors• Matrizen

– Definition, Kurzschreibweise– Matrix-Grundtypen, Addition, Subtraktion,

Multiplikation, Skalarprodukt, Transposition, Inversion– Rang, Determinanten– Eigenwerte, Eigenvektoren, charakteristisches Polynom


Juli 201317


• Skalar: Größen, deren Werte reelle Zahlen sind– Masse, Temperatur, Arbeit …

• Vektor: Größe mit einer Maßzahl und einer Richtung– Kraft, Geschwindigkeit, Feldstärke …

• Maßzahl: Vektorlänge (Vektorbetrag)• Richtung: Multiplikationskoeffizienten der

Einheitsvektoren der einzelnen Dimensionen


Juli 201318


• Vektoroperationen in Maple– Definition:

Spaltenvektor: >a:=Vector([3,4,5]); a:=<3,4,5>; Zeilenvektor: >a:=Vector[row]([1,2,3]); a:=<3|4|5>;

– Betrag: Pythagoras: B = sqrt(a12+a2

2+a32) = |a|

>Norm(a,2);– Winkel zwischen zwei Vektoren (Ergebnis in radian):

>VectorAngle(a,b);– Addition, Multiplikation:

>a+b; 4*a;


Juli 201319


• Vektoroperationen in Maple– Skalarprodukt zweier Vektoren ergibt einen Skalar:

a•b = abs(a)*abs(b)*cos(φ) >DotProduct(a,b); >Norm(a,2)*Norm(b,2)*cos(VectorAngle(a,b));

– Vektorprodukt (Kreuzprodukt): c = a x b ergibt ein Vektor c, der auf die beiden Vektoren a und b

senkrecht steht >c := CrossProduct(a,b);


Juli 201320

Vektoren, Matrizen, Eigenwerte• Matrix-Grundtypen und Begriffsdefinition

– Matrix-Definition: ein System von m x n Elementen (Zahlen, Funktionen, …), angeordnet in m Zeilen und n Spalten (m Zeilen der Länge n)

– Transponierte Matrix AT: Vertauschen der Zeilen und Spalten– Nullmatrix: sämtliche Elemente gleich Null– Quadratische Matrix: m = n– Diagonalmatrix: quadratische Matrix, alle Elemente außerhalb

der Hauptdiagonale sind gleich Null– Einheitsmatrix: Diagonalmatrix, alle Elemente in der

Hauptdiagonale sind gleich Eins: >Matrix(n,n,shape=identity);– Symmetrische Matrix: A = AT; linke, rechte Dreiecksmatrix


Juli 201321


• Operationen mit Matrizen: – passende Dimensionen sind Voraussetzung– Addition, Subtraktion:

Kommutativgesetz, Assoziativgesetz– Skalar-Multiplikation– Matrix-Multiplikation: Kommutativgesetz gilt nicht !

C = AB; A: m x n; B: n x p; C: m x p AB ≠ BA

– Rang einer Matrix: die größte Anzahl der linear unabhängigen Spaltenvektoren, ist gleich der größten Anzahl der unabhängigen Zeilenvektoren Rang einer Matrix (m x n) = höchstens min(m,n)


Juli 201322


• Matrix-Operationen in Maple– Definition

>A := Matrix([ [-1,1,0], [0,2,1], [1,2,4] ]); >A := < <-1|1|0>,<0|2|1>,<1|2|4> >; >A := < <-1,0,1> | <1,2,2> | <0,1,4> >;

– Transponieren, Invertieren, Multiplikation, Rang >Transpose(A); >MatrixInverse(A); >3*A; >A.B; B.A; >Rank(A);


Juli 201323

Vektoren, Matrizen, Eigenwerte• Determinante

– eine Zahl, die eindeutig einer quadratischen Matrix zugeordnet werden kann

– Definition für eine 2x2 Matrix:

det A = ad – bc– Für eine 3x3 Matrix: Sarus-Regel– Für eine n x n Matrix: Leibniz-Formel– Nützlichkeit

ist das lineare Gleichungssystem eindeutig lösbar ? Ist die Matrix invertierbar ? Ja, wenn det(A) ≠ 0

Berechnung: >Determinant(A);


Juli 201324


• Eigenvektor: ein Vektor, dessen Richtung durch eine Abbildung nicht verändert wird

• Eigenwert: Streckungsfaktor vom Eigenvektor– Anwendung der Eigenwerte: in der Lösung der

linearen Gleichungssysteme bzw. DGL-Systeme• Spezielles Eigenwertproblem

– Gleichung (A – λE)*x = 0 (A: Matrix, E: Einheitsmatrix nxn, x: Vektor)

– Lösbar wenn det(A – λE) = 0


Juli 201325


• det(A – λE) heißt „charakteristisches Polynom“– λ ist die unabhängige Variable– det(A – λE) = 0: charakteristische Gleichung der A

• Seine Nullstellen sind die Eigenwerte– Berechnung in Maple

>A := Matrix([ [3,1,1], [1,3,-1], [0,0,4]]); >with(LinearAlgebra): >Eigenvectors(A); >Eigenvalues(A); chp:=CharacteristicPolynomial(A, lambda); solve(chp=0,lambda);

– Die Funktion Eigenvectors() berechnet alles


Juli 201326

Vektoren, Matrizen, Eigenwerte• What is it good for ?

– Matrizen sind das Grundwerkzeug der linearen Algebra Verwendung in allen Bereichen der Naturwissenschaften,

Informatik etc. (optimieren, sortieren, modellieren, …)– Lösung von linearen Gleichungssystemen führt immer

zu Operationen mit Matrizen– Rang der Matrix: ist das Gleichungssystem lösbar ?

Rank(A) = Anzahl der Variablen -> existiert genau 1 Lösung– Einfaches Beispiel

Ax = b -> x ist der Lösungsvektor x = A-1 . b (Inversionsmatrix)

– Liefert das gleiche Ergebnis wie die Funktion solve()


Juli 201327

Programmstrukturen in MAPLE

• Programmstrukturen in MAPLE sind– als Ergänzung zu den eingebauten Befehlen gedacht– syntaktisch an C, Delphi etc. angelehnt– alle Berechnungen in MAPLE sind eigentlich einfache

Programme, z.B. f:=x^2 + x + 1/x; df:=unapply(diff(f,x),x); a:=df(3);

• Programmierumgebung der Wahl: MATLAB– verbindet leistungsfähige Befehle mit kompletter

Programmierausstattung, MAPLE-Einbindung


Juli 201328


• MAPLE-Help: Introductory Programming Guide• Elemente der Programmierung: Anlehnung an C

– wichtigste Datenstrukturen Sequenzen, Mengen, Listen Tabellen Felder (Arrays)

– Programmflusssteuerung (flow control) Verzweigungen: if-elif-else Schleifen: for, while, break, next

– Unterprogramme (procedures)– Eingabe/Ausgabe (I/O)

Bildschirm, Tastatur, Datei


Juli 201329


• Datenstrukturen– primitive Datentypen

integer, rational, float, string, function, boolean– komplexe Datentypen

Sequenzen, Sets, Lists, Arrays, Tables Sets: ungeordnet, Lists: geordnet Arrays: Felder >sq:=3,5,2; st:={7,9,6}; ls:=[1,4,3]; lss:=[sq]; lsc:=[j,f,m,a]; Array: Indizes sind Ganzzahlen >A:=Array([[1,2,3],[4,5,6]]); A[2][3]; -> 6


Juli 201330


• Programmflusssteuerung (Flow Control)– Für den Fall, wenn die Befehle im Programm nicht

strikt nacheinander ausgeführt werden sollen, oder um Wiederholungen zu vermeiden/vereinfachen

– Auswahl und bedingte Ausführung Verzweigungen: if-elif-else-fi (oder -else-end if)

– Wiederholung (allgemeine Befehle) Befehle for und while

– Wiederholung (spezielle Befehle) Befehle seq(), add(), mul()


Juli 201331

Programmstrukturen in MAPLE• Verzweigungen: if-elif-else-fi (oder -else-end if)

– >j:=2;– >if j<0 then

print("j<0"); elif j>0 then

print("j>0"); else

print("j=0"); fi;

– kann auf 1 Zeile (evtl. mit Shift/Enter) oder in mehreren Zeilen geschrieben werden, die aber in einem Anweisungsblock stehen müssen. If..fi; ist 1 Befehl


Juli 201332

Programmstrukturen in MAPLE• Schleifen: while-do-end do, for-do-end do

– while: logische Bedingung für die Ausführung >sm := 0: i := 0:

while sm <= 100do

sm := sm + i; i := i + 1;end do:sm;

– for: Iterationsanzahl vor der Schleife festgesetzt >sm := 0:

for i from 1 to 10 by 2do sm := sm + i; end do: Semikolon: Zeilenausgabesm;


Juli 201333

Programmstrukturen in MAPLE• Unterprogramme (Prozeduren, procedures)

– Schreibweise: eine Zeile oder ein Anweisungsblock– Prozeduren ohne explizite Parameterliste

Anzahl der Parameter durch den Aufruf gegeben– Prozeduren mit expliziter Parameterliste

Anzahl der Parameter fest– lokale und globale Variablen:

local x; in der Prozedur bedeutet, die Variable (und der Wert) existiert nach dem Ende der Prozedur nicht mehr

soll schon ein x als globale Variable existieren, ist sie in der Prozedur unerreichbar (vom lokalen x "zugedeckt")

– Prozeduren sind Objekte, bleiben bis Restartdefiniert


Juli 201334

Programmstrukturen in MAPLE– Prozeduren ohne explizite Parameterliste

>maxim := proc () local max, i, N; # Maximum berechnenmax := _passed[1]; N := _npassed;for i from 2 to N do

if _passed[i] > max then max := _passed[i]; end ifend do;max;end proc:>maxim(8,2,6);

Zurückgegeben wird der Wert der letzten Anweisung, oder der Wert in return expr;

_npassed, _passed: vordefinierte Standardvariablen: Anzahl der Parameter und die Parameterliste


Juli 201335

Programmstrukturen in MAPLE– Prozeduren mit expliziter Parameterliste

a: Liste der zu summierenden Zahlen b: Multiplikator für die Summe >addList := proc(a::list,b::integer)::integer;local x, i, sum, N;

x := b; sum := 0; N := nops(a);for i from 1 to N do sum := sum + a[i]; end do;sum := sum*x; return sum;end proc;

>SL := addList([1,3,5,7,9],2); return sum; : Befehl hier überflüssig

– Vorteile (expliziter Typ, ...), Nachteile (feste Anzahl der Parameter, ...)


Juli 201336


• Eingabe/Ausgabe (I/O)– readdata, writedata: Worksheet oder Datei– print() - 2D-Ausgabe, lprint(): linear– C-Funktionen mit Formatierung: lineare Ausgabe

printf, fopen/fclose, fscanf/fprintf, readline/writeline etc.

>MD:=readdata("D:/Temp/mdata.dat",float,2); >writedata(terminal, MD, float); >writedata("d:/temp/abc.dat", MD, float); >fd:=fopen("d:/temp/abc.dat", APPEND); >fprintf(fd, "x= %d, y=%g\n", x,y); >fclose(fd);


Juli 201337

Programmieren in MAPLE

• Beispiel: Berechnung einer Nullstelle– Newton-Verfahren– Funktion: f(x) = (x-2)2 - 3– Prozedur ohne explizite Parameterliste– Prozedur-Aufruf mit Parametern– Funktion und Anfangspunkt werden übergeben– Anfangspunkt wird in der Prozedur extrahiert

Extraktion von Operanden aus einem Ausdruck: op() xn := op(2,_passed[2]);


Juli 201338

Programmieren in MAPLE

• Nullstellenberechnung >Newton := proc() local f,xa,xn; f:=_passed[1]:

xn:=op(2,_passed[2]): xa:=xn+1: while abs(xa-xn) > 10e-6 do

xa := xn:xn := xa - f(xa)/D(f)(xa):

end do:printf("Lösung: %a\n",xn);

end: >Newton(f, x=1.0); -> Lösung lautet 0.267949192

>Newton(f, x=4.0); -> Lösung lautet 3.732050808 >fsolve(f(x)=0, x); -> 0.2679491924, 3.732050808


MAPLE – Grundlagen 2 - tci.uni-hannover.de · 10 Juli 2013 Integration von Funktionen • Integration einer Funktion in einer Variablen – Grundform: bestimmtes Integral: int(f(x),

Documents