# Lektion 1
# Grundkonzepte  der Computeralgebra
#  2017  Friedrich U. Mathiak, 
# mathiak@mechanik-info.de
# 
> restart:
# Die Computeralgebra beschftigt sich hauptschlich mit dem symbolischen Rechnen, wobei die Symbole mathematische Objekte darstellen. Das knnen Zahlen, Mengen, Folgen, Funktionen, Matrizen, Integrale, Gleichungen oder  auch geometrische Gebilde sein. Alle diese Objekte knnen durch  Computeralgebrasysteme (CAS) verarbeitet werden. Zur besseren Behandlung werden Objekte mit einem Namen versehen. Dabei muss in Maple zwischen Gro- und Kleinschreibung unterschieden werden. Einige Namen sind fest vergeben, beispielsweise  D, I, gamma. Fr weitere Informationen siehe ininame und inifcns.  Weitere Konventionen zur Namensgebung knnen der online-Hilfe entnommen werden, siehe name . Der Maple-Befehl zur Aktivierung der Hilfe-Seite  fr den plot-Befehl lautet beispielsweise
> help(plot);
# oder alternativ und krzer
> ?plot;
# Weitere Hinweise erhlt der Nutzer mittels der Befehle
# info(name)                                            Beschreibt  in Kurzform die Funktion
# usage(name)       oder   ??name            Beschreibt  die Anwendung der Funktion
# example(name)   oder   ???name          Zeigt Beispiele der Funktion
# related(name)                                        Gibt Hinweise auf verwandte Themengebiete
> info(diff);
> usage(cos);
> ??cos;
> example(plots[animate]);
> ???plots[animate];
> example(plot);
> related(help);
# Zur Benennung einer Zahl, einer Gleichung  und eines algebraischen Ausdrucks mit den (willkrlichen)  Namen  x1, gl  bzw.  xh2  benutzen wir die  Zuordnungsanweisung ( := , assignment statement) 
> x1:=5.27;     gl:=1/(1+z)^2=4;    xh2:=x^2;
# Den Namen bezeichnet man als Variable und das mit diesem Namen versehene Objekt als den Wert der Variablen. Ein Aufruf des Variablennamen gibt uns den aktuellen Wert der Variablen an. Diese Ausdrucksanweisung schlieen  wir mit einem Semikolon (;) ab , weil wir eine Ausgabe erhalten mchten. Soll dagegen die Ausgabe unterdrckt werden, muss ein Doppelpunkt (:)  gesetzt werden.
> x1;
> x1+5;
> gl;
> xh2;
# Im letzten Ausdruck ist  x  selbst eine Variable, der wir jedoch bisher keinen Wert zugewiesen haben. Beim Aufruf dieser Variablen finden wir
> x;
#  Wir weisen  der Variablen  x  den Wert 3  zu und rufen sie anschlieend wieder auf
> x:=3;      x;
# Auch beim Aufruf der Variablen  xh2  erhalten wir jetzt einen bestimmten Zahlenwert, denn Maple setzt den aktuellen Wert von  x  ein
> xh2;
# Man kann einer Variablen ihren Wert wieder entziehen, indem man ihr als neuen Wert ihren Namen zuweist. Der Name wird dabei zwischen Apostrophen eingeschlossen. Zuweisung und Entzug des Wertes einer Variablen werden als assign  bzw. unassign bezeichnet. 
> x:='x';
# Jetzt fungiert  x  wieder als Variable ohne zugewiesenen Wert, und auch der Ausdruck xh2  besitzt keinen bestimmten Zahlenwert mehr:
> x;      xh2;
# Eine Variante des obigen Vorgehens ist:
> x:=3;     xh2:=x^2;
> x:=2;     xh2;
# Achtung: Diesmal behlt der Ausdruck xh2 seinen Wert und wird nicht auf x2 = 22 = 4 aktualisiert. Der Grund ist darin zu suchen, dass xh2 nicht als das Quadrat  einer Unbekannten x, sondern als Quadrat des damaligen Wertes 3 der Variablen x, also als die Konstante 9 definiert worden ist. Das ist nicht so bei folgendem Vorgehen:
> x:='x':    xh2:=x^2;     x:=3;     xh2;     x:=2;   xh2;
# Durch Zusammenfassung von Objekten zu Sequenzen (sequences),  Listen (lists), Mengen (sets), Feldern (Arrays), Tafeln (tables) und Zeichenketten (strings) werden neue Objekte geschaffen, die wieder mit Namen belegt werden knnen. 
# Eine Sequenz ist eine geordnete Aufzhlung von Objekten, die durch Kommata getrennt werden. Die Reihenfolge der Objekte bleibt dabei erhalten.
> seq1:=5.4, 5/4, q, z^3, 5.4, 3*a+5*b;
# Der Maple-interne Datentyp kann mit dem Befehl whattype bestimmt werden:
> whattype(seq1);
# Auf das j-te Element der Sequenz knnen wir zugreifen, wenn wir an den Namen der Sequenz den Index  j in eckigen Klammern hinzufgen:
> seq1[2];
# Das Anfgen und Voranstellen eines Elementes e an eine bestehende Sequenz geschieht wie folgt
> seq2:=seq1,e; seq3:=e,seq1;
# Eine Sequenz lsst sich  mittels des Befehls seq  generieren. Beispiele dazu sind 
> seq(i,i=1..5); seq(2*n-1,n=1..5);
> seq(seq(5*n+m,m=0..2),n=1..3);
> seq(i,i=1..4,0.2);
# Die leere Sequenz wird mit NULL bezeichnet.
# Wird eine Sequenz  in eckige Klammern eingeschlossen, dann erhlt man eine Liste ( list ). Die Reihenfolge der Objekte bleibt, wie bei einer Sequenz, auch hier erhalten.
> liste1:=[seq1];
# Der Maple-interne Datentyp ist
> whattype(liste1);
# Die Anzahl der in einer Liste zusammengefassten Objekte liefert uns der Befehl nops (number of operands) , und die Auswahl eines Elements erfolgt ber den Befehl  op  oder wieder mit einem Index:
> nops(liste1);     op(2,liste1);    liste1[2];
# Das geht brigens bei einer Sequenz nicht, wie der folgende Befehl zeigt:
> op(2,seq2);
# In diesem Fall ist zunchst eine Sequenz durch  das Setzen von eckigen Klammern in eine Liste umzuwandeln
> l:=op(2,[seq2]);whattype([seq2]);
# Die Erweiterung einer  Liste um ein Element geschieht wie folgt: 
> liste2:=[op(liste1),ELNACH];liste2:=[ELVOR,op(liste1)];
# Um die Reihenfolge der Elemente einer Liste umzudrehen, ist wie folgt vorzugehen: 
> [seq(liste1[-i], i=1..nops(liste1))];
# Der Befehl  op  wandelt eine Liste in eine Sequenz:
> seq3:=op(liste1);whattype(seq3);
> x:='x':
# Weitere Beispiele sind:
> polynome:=[x^2+2*x+3,2*x^2-1];
> Mitglieder:=[Berta, Olli, Mausi, alfons, peter];
> Mitglieder[2];
# Die leere Liste wird durch folgenden  Befehl erzeugt
> L:=[];
# Die Ausgabe des letzen Elementes einer Liste erfolgt mit dem Befehl 
> liste1[nops(liste1)];
# Wollen wir  aus einer Liste ein Element lschen, so muss mit dem Befehl  subsop  das Element explizit auf NULL gesetzt werden.
> liste1;
> liste1:=subsop(2=NULL,liste1);
# Soll der alte Wert eines Listenelementes durch einen neuen Wert ersetzt werden, dann geht das wie folgt:
> liste1:=subsop(2=y,liste1);
# Auswahl von Elementen aus einer Liste: hier Liste der Elemente 2 bis 4
> liste1[2..4]; 
# Liste des vorletzten und letzten Elements.
> liste1[-2..-1];
# Ob ein Element in einer Liste enthalten ist, kann mit dem Befehl member geprft werden
> member(y,liste1);
> member(z,liste1);
# Es kann auch die Position eines Elementes in einer Liste festgestellt werden. Dazu wird ein 
# drittes Argument in den Befehl member eingefhrt  (hier p)
> member(Mausi,Mitglieder,'p');
> p;
# Listen knnen mit dem Befehl  sort   sortieren werden. Wenn ein Ordnungskriterium vorhanden ist, knnen beispielsweise mit  sort  Zahlen nach aufsteigender Gre und Symbole und Zeichenketten nach lexikographischer Ordnung sortiert werden. 
> liste2:= [0,6,2,2.1,-4.8];
> sort(liste2);sort(liste2,`>`);sort(Mitglieder);
# Bei der lexikographischen Sortierung unterscheidet Maple offensichtlich nach Gro- und Kleinschreibung.
# Hinweis: Das Package ListTools bietet erweiterte Mglichkeiten im Umgang  mit Listen
> with(ListTools):
# Dazu einige Beispiele
> liste3:=[1,1,4,-6,7,7,17];
> FindMaximalElement(liste3);FindMinimalElement(liste3);
> Rotate(liste3,2); MakeUnique(liste3);
# Die Elemente der Listen knnen beliebige Objekte sein, also auch wieder Listen. Man spricht in diesem Fall von einer Liste von Listen (listlist), wenn die inneren Listen die gleiche Anzahl von Elementen besitzen:
> liste4:=[[7,5],[3,4]];  type(liste4,listlist);
> liste5:=[liste1,liste3];type(liste5,listlist);
# Der Zugriff auf die Listenelemente erfolgt  mit
> liste4[2];liste4[2,2];liste4[2][2];
# Schlieen wir die Sequenz in geschweifte Klammern ein, so erhalten wir die Menge (set) der in der Sequenz aufgezhlten Objekte. Die Reihenfolge der Objekte bleibt nicht erhalten
> menge1:={seq1};
# Der Maple-interne Datentyp ist
> whattype(menge1);
# Die leere Menge erzeugt der Befehl:
>  {};
> menge2:=menge1 union {el};
# Die Anzahl der Elemente einer Menge wird ermittelt mit 
> nops(menge2);
# Es lassen sich einzelne Elemente in der aktuellen Speicherreihenfolge identifizieren
> op(3,menge2);
> a:='a':b:='b':c:='c':
# Fr Mengen gelten in Maple dieselben Rechenregeln wie in der Mathematik.
> {a,b,c} union {c,d,e};     #Vereinigung
;
> {a,b,c} intersect {c,d,e}; #Durchschnitt
;
> {a,b,c} minus {c,d,e};     #Differenz
;
> {c,d,e} minus {a,b,c};     #Differenz
;
# Ob ein Objekt in einer Menge enthalten ist, kann mit dem Befehl member geprft werden
> menge2;
> member(3*a+5*b,menge2);
> member(7,menge2);
# Wir prfen die Gleichheit zweier Mengen mit dem Befehl evalb (evaluate as a Boolean expression) 
> menge1;menge2;
> evalb(menge1=menge2);
# Das folgende Kommando erzeugt eine Liste von Mengen
> [seq({seq(m^n,n=1..3)},m = -1..2)];
# Das folgende Kommando erzeugt eine Liste von Listen, wenn wir die geschweiften Klammern (engl. braces) durch eckige Klammern (engl. brackets) ersetzen:
> [seq([seq(m^n,n=1..3)],m=-1..2)];
# Die Anordnung mathematischer Objekte in einem rechteckigen Schema erfolgt mit dem Befehl Array. Mit solchen Objekten kann gerechnet werden. Der Befehl
> A:=Array(-1..2,2..4); ArrayDims(A); ArrayNumDims(A);
# erzeugt ein rechteckiges Feld mit 4 Zeilen und 3 Spalten. Die Indizierung der Elemente erfolgt nach Fortran-Konvention, wobei zuerst der Zeilen- und dann der Spaltenindex genannt wird.
> A:=Array(-1..2,2..4,[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]);
> A[-1,2]; A(1,1);
> B:= Array(5..9,[5,6,7,8,9]);
> B[-1];
> B[5]; B(1);
# Spezielle Formen der Arrays sind  Matrizen . Ihre Indizierung beginnt mit dem Wert 1. 
> A:=Matrix(3);
> M1 := Matrix(1 .. 2, 1 .. 3, 2);
> NULL;M2 := Matrix([[1, 2, 3], [4, 5, 6]]);
> M2[1,2];M2(1,2);
> M3:=Matrix(M1+M2);NULL;
> B:=Matrix(3,2,[1,2,3,4,5,6]);
> C:=Matrix(4,3,B,fill=f);
# Sonderformen von Matrizen sind die Einheitsmatrix, die symmetrische Matrix und die obere bzw. untere Linkssdreiecksmatrix sowie die Diagonalmatrix:
> E:=Matrix(3,shape=identity);
> S:=Matrix(3,{(1,2)=2,(1,3)=3},fill=1,shape=symmetric);
> OR:= Matrix(3,3,fill=1,shape=triangular);
> UL:= Matrix(3,[[1],[2, 2],[3, 3, 3]],shape=triangular[lower]);
> DM:=Matrix(3,3,symbol=dm,shape=diagonal);
# Einspaltige Matrizen werden in Maple als  Vektoren  bezeichnet. 
> v1:=Vector(3);v2:=Vector(3,1);
> co := {1=1,2=2,3=3};
> v3:=Vector(3,co);
> Matrix(4,v3,shape=diagonal,fill=f);
# Eine Matrix mit einer Spalte besitzt in Maple nicht automatisch den Typ Vector
> v4:=Matrix(3,1,1);
> type(v4,Vector);
# Die einspaltige Matrix v4 muss zuerst mit dem Befehl convert in einen Vektor umgewandelt werden
> v4:=convert(v3,Vector);type(v4,Vector);whattype(v4);
# Soll explizit ein Zeilenvektor erzeugt werden, dann geht das mit
> v5:=Vector[row]([1, 2, 3]);whattype(v5);
# Das Spalten- und Zeilenvektoren bei algebraischen Operationen unterschieden werden, sehen wir an folgenden Beispielen
> v1-v2;
> v4-v5;
# Der Vektor v5 wird in einen Spaltenvektor umgewandelt, erst dann kann die Differenz gebildet werden.
> v5:=convert(v5,Vector[column]);v4-v5;
# Mit der folgenden Konstruktionsvorschrift kann bei einem Einheitsvektor an bestimmter Stelle der Wert 1 gesetzt werden
> Vector(4,shape=unit[3]);
# Um mit Matrizen und Vektoren im Sinne der linearen Algebra zu rechnen, ist das Paket LinearAlgebra zu laden
> with(LinearAlgebra):
# Eine Tabelle  ist eine Erweiterung des Array-Konzepts.  Die Erzeugung einer Tabelle erfolgt mit dem Befehl table .  Im Gegensatz zu Arrays, bei denen die Indizes Ganzzahlen sein mssen, knnen die Indizes von Tabellen jeden Wert annehmen. Das ermglicht dem Anwender, in Datenstrukturen mit natrlichen Namen zu arbeiten. 
> Stahl_Daten:=table([Dichte=[7.85,g/cm^3],Elastizittsmodul=[210000,N/mm^2],Temperaturdehnzahl=[12.*10^(-6),K^(-1)]]);
> Stahl_Daten[Dichte];Stahl_Daten[Elastizittsmodul];
> op(Stahl_Daten);op(op(Stahl_Daten));
# Der Befehl  indices liefert eine Sequenz der Indizes, allerdings in einer willkrlichen Anordnung, die vom Benutzer nicht beeinflusst werden kann.
> indices(Stahl_Daten);
# Der Befehl entries liefert eine Sequenz der Eintrge, ebenfalls in einer willkrlichen Anordnung. Allerdings korrespondieren die  Sequenzen  der beiden Befehle indices und entries
> NULL;entries(Stahl_Daten);
> NULL;indices(Stahl_Daten, 'nolist');
# In diesem Beispiel ist jeder Index ein Name und jeder Eintrag eine Liste. Um einen neuen Eintrag (hier die Streckgrenze) in der Tabelle Stahl_Daten vorzunehmen, gehen wir wie folgt vor:
> Stahl_Daten[Streckgrenze]:=[240,N/mm^2];
> op(Stahl_Daten);
# Eine leere Tabelle wird durch den folgenden Befehl erzeugt
> T:=table();op(T);
# Zeichenketten strings werden zwischen Anfhrungszeichen (engl. double quote characters) gestellt und knnen einem Namen zugeordnet werden
> text1:=" dieser text";text2:=" gefllt mir";
# Zeichenketten knnen mit dem Befehl  cat  verbunden werden
> cat(text1,text2);cat(text2,text1);
> text3:=" dieser text"" gefllt mir nicht";type(text3,string);
# Durch Einfgung eines Leerzeichens (blank) zwischen beiden Zeichenketten wird das Anfhrungszeichen nicht geschrieben.
> "dieser text" " gefllt mir";
# Soll das Anfhrunszeichen im Text erscheinen, dann ist wie folgt vorzugehen:
> "dieser text\" gefllt mir";
# Verarbeitung von Zahlen in Maple
# Wir beginnen mit den ganzen Zahlen (integer). 
> i1:=-38;     i2:=837689;
# Die maximale Lnge einer Ganzzahl ist systemabhngig und kann mit dem Befehl 
> kernelopts(maxdigits);
# erkundet werden. Bei der Division ganzer Zahlen entstehen rationale Zahlen, beispielsweise in Form des Bruches
> r:=i1/i2;
# Wir kontrollieren das Ergebnis und stellen fest, dass wir exakt gerechnet haben
> r*i2;i1/r;
# Addieren wir 1/4 dazu, so bringt Maple das Ergebnis sofort auf den Hauptnenner
> r + 1/4;
# Die Umwandlung von Ganzzahlen und Brchen in Dezimalzahlen geschieht mittels des Befehls evalf  (evaluate using floating-point arithmetic). Standardmig werden dazu 10 Stellen (Digits) verwendet.
> evalf(i1);
# Hinter der Ganzahl i1 = -38 erscheint jetzt ein Punkt.
> evalf(r), evalf(1/33), evalf(1/34);
# Die Anzahl der Stellen kann gendert werden
> Digits:=20:evalf(r);Digits:=10:
# Wir kontrollieren die Ergebnisse und stellen fest, dass beim Rechnen mit Gleitpunktzahlen nicht der exakte Wert 1 ermittelt wird.
> 33*evalf(1/33), 34*evalf(1/34);
# Die Eingabe von Gleitkommazahlen kann in verschiedenen Formaten vorgenommen werden. Fr die  Zahlen a = 2010  bzw. b = 1/50  kann beispielsweise gewhlt werden
> a1:=2010.0;  a2:=2010.; a3:=.201*10^4;  a4:=2.01e3; a5:=2.01E3;
> b1:=0.02;   b2:=.02;   b3:=2.0*10^(-2); b4:=.2e-1;  b5:=.2E-1;
# Irrationale Zahlen ergeben sich als Lsungen algebraischer oder transzendenter Gleichungen: 
#  x2  - 2  =  0, 	    x = sqrt(2);, 
# sin(x)      =  0, 	  x = , 
# ln(x) - 1  =  0,   x = e. 
# Dazu einige Beispiele irrationaler Zahlen und ihre Nherungen durch Dezimalzahlen:
> sqrt(2), Pi, exp(1);
> sqrt2_fl:=evalf(sqrt(2));  Pi_fl:=evalf(Pi);  e_fl:=evalf(exp(1));
# Wir berprfen deren Genauigkeit:
> [(sqrt(2))^2-2,sqrt2_fl^2-2],[sin(Pi),sin(Pi_fl)],[ln(exp(1))-1,ln(e_fl)-1];
# Komplexe Zahlen.
# In Maple bezeichnet  I   mit I2 = -1 die imaginre Einheit, die wie folgt erzeugt werden kann
> I,sqrt(-1),(-1)^(1/2);
# Unter einer komplexen Zahl a versteht man das geordnete Zahlenpaar (, ) von reellen Zahlen. 
> a1:=Complex(alpha1,beta1) assuming alpha1::real,beta1::real;
> a2:=Complex(alpha2,beta2) assuming alpha2::real,beta2::real;
# Die explizite Zerlegung  einer komplexen Zahl  a  in Real- und Imaginrteil erfolgt mit dem Befehl evalc 
> evalc(a1);evalc(a2);
# Komplexe Zahlen knnen auch in folgender Form eingegeben werden
> a1:=alpha1+I*beta1;a2:=alpha2+I*beta2;
# Um Real- und Imaginrteil einer komplexen Zahl a1 auszugeben, stehen die Kommandos  Re  und  Im  zur Verfgung 
> Re(a1)  assuming alpha1::real,beta1::real;
> Im(a1)  assuming alpha1::real,beta1::real;
# 1.)  Zwei komplexe Zahlen a und b sind dann gleich, wenn Re (a) = Re (b) und Im (a) = Im (b) gilt, also  1 = 2  und  1 = 2.
# 2.)  Die Summe zweier kompexer Zahlen a1  und  a2 ist definiert durch
> apb:=a1+a2;
# oder explizit
> apb:=evalc(a1+a2);
# 3.) Das Produkt zweier komplexer Zahlen a1  und  a2  ist erklrt durch
> a:=evalc(a1*a2);
> evalc(a^2); 
> evalc(sqrt(a));
# 4.) Der Quotient zweier komplexer Zahlen  a1  und  a2  ist definiert durch
> evalc(a1/a2);
# Mit 
> a:=evalc(Complex(alpha,0));b:=evalc(Complex(0,beta));
# sind die reellen Zahlen und die rein imaginren Zahlen  in der Menge der komplexen Zahlen enthalten. Insbesondere wird
> ie:=evalc(Complex(0,1));
# als imaginre Einheit bezeichnet, fr die gilt
> ie^2;
# Mit dem  Befehl  interface(imaginaryunit = val)  kann die in Maple verwendete Bezeichnung fr die komplexe Einheit I umbenannt werden:
> interface(imaginaryunit = i);
# Beispiele:
> a1:=Complex(-1,5); a2:=Complex(3 ,-4);
> a3:=Complex( 1,3) ;a4:=Complex(10, 7);
> a5:=Complex( 0,5) ;
> z1:=evalc(a1^2*a2/a3+a4/a5);
> z2:=(a1+a2)^2;
# Die zu a1 = 1 + i 1  konjugiert komplexe Zahl  a2 = 1 - i 1  (der Imaginrteil ndert sein Vorzeichen) erhalten wir mit dem Befehl conjugate
> a1:=Complex(alpha1,beta1);a2:=Complex(alpha2,beta2);
> evalc(conjugate(a1));
# Es gelten die folgenden Rechenregeln
> evalc(conjugate(conjugate(a1)));
> evalc(conjugate(a1+a2));evalc(conjugate(a1-a2));
> evalc(a1*conjugate(a1));
> evalc(1/2*(a1+conjugate(a1)));     #Realteil von a1
;
> evalc(1/(2*i)*(a1-conjugate(a1))); #Imaginrteil von a1
;
# Der absolute Betrag |a| der komplexen Zahl  a  ist definiert durch
> abs(a1);
# Die  m-te Wurzel aus a ist definiert durch  z = a^(1/m); . Es wird also eine komplexe Zahl z gesucht, fr die gilt: z^m = a;.  Beispiel:  iff((8*i)^(1/3), z^3 = Typesetting[delayDotProduct](8*i . Mit, dem, true)*Befehl);
> simplify(evalc((8*i)^(1/3)));
# liefert uns Maple nur den Hauptwert. Es existieren allerdings wegen m = 3 noch zwei weitere Lsungen, die wir erhalten, wenn wir unsere Anfrage wie folgt formulieren:
> gl:=z^3=8*i;loe:=solve(gl,z);
# Wir machen die Probe:
> evalc(loe[1]^3);evalc(loe[2]^3);evalc(loe[3]^3);
# Fr m = 2 (Quadratwurzel, sqrt) erhalten wir beispielsweise mit  z1  die beiden Lsungen
> z1;
> solve(z^2=z1,z);
# Den Hauptwert liefert uns Maple in nummerischer Form mit 
> evalf(evalc(sqrt(z1)));
# Mit dem Befehl restart veranlassen wir Maple, den internen Speicher zu lschen und auf den Ausgangszustand zurckzusetzen.
> restart:
# Maple bietet die Mglichkeit, symbolische und nummerische Berechnungen unter Verwendung von Einheiten durchzufhren, und es knnen eigene Einheiten definiert werden. Einige Operationen mit Einheiten werden durch Context-Mens untersttzt. Der  Befehl Units[GetDimensions]()  zeigt eine Liste aller in Maple vorhanden Dimensionen, in der auch die fr die Technische Mechanik wichtigen Basisgren length ( Lnge), mass (Masse), time (Zeit) und thermodynamic_temperature; (Thermodynamische Temperatur)  enthalten sind. 
> Units[GetDimensions]();
# Einheiten werden in Systemen zusammengefasst, etwa dem Systme International d'Units (SI) oder dem foot-pound-second (FPS) System. Um die komplette  Liste von Einheiten in Maple anzusehen, wird auf die entsprechende Hilfe-Seite verwiesen, beispielsweise  kennt Maple fr die Dimension Lnge folgende Einheiten
> ?Units,length;
# Mit dem Befehl convert knnen Einheiten ineinander umgerechnet werden. Zur Umrechnung absoluter Temperaturen unterschiedlicher Skaleneinheiten wird die Option convert/temperature  bentigt. Beispielsweise entsprechen 30 Grad Celsius 86 Grad Fahrenheit, wie die folgende Rechnung zeigt: 
> convert(30.,temperature, degC, degF);
# Die Konvertierung von Temperaturnderungen erfolgt mit dem Befehl convert/units. Beispielsweise entspricht einem Anstieg von 30 Grad Celsius eine Tempereturnderung von 30 Grad Kelvin. 
> convert(30.,units, degC, K);
# In der Standard-Umgebung knnen in Maple keine Gren verarbeitet werden, die mit Einheiten belegt sind. Ausgenommen davon sind Konvertierungen von Einheiten. Siehe hierzu
> ?Units,default;
# Um Berechnungen mit Ausdrcken durchzufhren, die Einheiten enthalten, ist zunchst das Paket Units zu laden. 
> with(Units);
# Maple empfiehlt die Verwendung des  Paketes Units[Standard], womit eine automatische Vereinfachung aller Ausdrcke erfolgt.
> with(Units[Standard]);
# Welches System gerade im Gebrauch ist, das liefert uns der Befehl UsingSystem()
> UsingSystem();
# Eine Auflistung aller von Maple untersttzten Systeme liefert der Befehl GetSystems()
> GetSystems();
> Laenge:=250.*Unit(meter);
> Breite:=0.75*Unit(km);
> Hoehe:=120.*Unit(cm);
> Flaeche:=2*Laenge*Breite/8;
> Volumen:=Laenge*Breite*Hoehe;
# Maple gibt das Ergebnis unter Verwendung  der Basiseinheit  m aus. 
> Masse:=500.00*Unit(kg);
> Zeit:=30.0*Unit(s);
> Kraft:=Masse*Laenge/Zeit^2;
# Maple gibt die Kraft in der aus den SI-Basiseinheiten abgeleiteten Einheit N aus.
> 60*Unit(km)/Unit(h);
# Einheiten knnen wieder umgewandelt werden. 
> convert(combine(%,'units'),'units',km/h);
# und in das FPS-System 
> convert(combine(%,'units'),'system','FPS');
> 35.*Unit('mile')/Unit('hour');
> 5.5*Unit(km)+300*Unit(meter);
> v:=(10*tan(x)+x^2)*Unit(m)/Unit(s);
> int(v,x*Unit(s));
> diff(%,x*Unit(s));
# Um ein Einheitensystem zu ndern, wird der Befehl Units[UseSystem] benutzt
> UseSystem(FPS);
> UsingSystem();
> Volumen:=1.5*Unit(cm)*Flaeche;
# Maple untersttzt das Rechnen mit wissenschaftlichen Konstanten. Das Paket ScientificConstants bietet 
# Physikalische Konstanten und 
# Werte chemischer Elemente und Isotope. 
# Eine Auflistung der wissenschaftlichen Konstanten in Maple entnehmen wir der Hilfe-Seite
> ?ScientificConstants,PhysicalConstants;
# Die allgemeine Gravitationskonstante    hat beispielsweise in Maple die Bezeichnung G
> with(ScientificConstants);
> GetConstant('G');
# Um wissenschaftliche Konstanten zu nutzen (hier G), muss zuerst ein ScientificConstants-Objekt erzeugt werden. Dazu wird der Befehl Constant bentigt
> G:=Constant('G');
# Wir kehren wieder zum SI-System zurck. 
> UseSystem(SI);
# und berechnen den nummerischen Wert von G
> evalf(G);
# Mit dem Befehl GetUnit() lassen wir uns die  Einheiten dieser Konstanten anzuzeigen, 
> GetUnit(G);
# Um in Rechnungen mit  wissenschaftlichen Konstanten  Einheiten verwenden zu knnen, muss der Wert der Konstanten sowie die Einheit angegeben werden. 
> evalf(Constant('G',units));
# Wir zeigen eine solche Berechnung am Beispiel der Fallbeschleunigung g.  Betrgt die Masse der Erde mE etwa
> mE:=5.9736*10^(24)*Unit(kg);
# und der Radius rE der Kugel mit dem Volumen der Erde nherungsweise 
> rE:=6371.2*Unit(km);
# dann liefert die formale Anwendung des Newtonschen Gravitationsgesetzes die Fallbeschleunigung
> g:=evalf(Constant('G',units))*mE/rE^2;
> 
;
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
