# Lektion 1
# Grundkonzepte  der Computeralgebra
# © 2015  Friedrich U. Mathiak, 
# mathiak@mechanik-info.de
# 
> restart:
# Die Computeralgebra beschäftigt sich hauptsächlich mit dem symbolischen Rechnen, wobei die Symbole mathematische Objekte darstellen. Das können Zahlen, Mengen, Folgen, Funktionen, Matrizen, Integrale, Gleichungen oder  auch geometrische Gebilde sein. Alle diese Objekte können 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. Für weitere Informationen siehe ininame und inifcns.  Weitere Konventionen zur Namensgebung können der online-Hilfe entnommen werden, siehe name . Der Maple-Befehl zur Aktivierung der Hilfe-Seite  für den plot-Befehl lautet beispielsweise
> help(plot);
# oder alternativ und kürzer
> ?plot;
# Weitere Hinweise erhält 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 (willkürlichen)  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 schließen  wir mit einem Semikolon (;) ab , weil wir eine Ausgabe erhalten möchten. Soll dagegen die Ausgabe unterdrückt 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 anschließend 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 behält 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 können. 
# Eine Sequenz ist eine geordnete Aufzählung 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 können wir zugreifen, wenn wir an den Namen der Sequenz den Index  j in eckigen Klammern hinzufügen:
> seq1[2];
# Das Anfügen und Voranstellen eines Elementes e an eine bestehende Sequenz geschieht wie folgt
> seq2:=seq1,e; seq3:=e,seq1;
# Eine Sequenz lässt 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 erhält 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 zunächst 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 löschen, 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 geprüft 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 eingeführt  (hier p)
> member(Mausi,Mitglieder,'p');
> p;
# Listen können mit dem Befehl  sort   sortieren werden. Wenn ein Ordnungskriterium vorhanden ist, können beispielsweise mit  sort  Zahlen nach aufsteigender Größe 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 Möglichkeiten 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 können 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];
# Schließen wir die Sequenz in geschweifte Klammern ein, so erhalten wir die Menge (set) der in der Sequenz aufgezählten 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':
# Für 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 geprüft werden
> menge2;
> member(3*a+5*b,menge2);
> member(7,menge2);
# Wir prüfen 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 müssen, können die Indizes von Tabellen jeden Wert annehmen. Das ermöglicht dem Anwender, in Datenstrukturen mit natürlichen Namen zu arbeiten. 
> Stahl_Daten:=table([Dichte=[7.85,g/cm^3],Elastizitätsmodul=[210000,N/mm^2],Temperaturdehnzahl=[12.*10^(-6),K^(-1)]]);
> Stahl_Daten[Dichte];Stahl_Daten[Elastizitätsmodul];
> op(Stahl_Daten);op(op(Stahl_Daten));
# Der Befehl  indices liefert eine Sequenz der Indizes, allerdings in einer willkürlichen Anordnung, die vom Benutzer nicht beeinflusst werden kann.
> indices(Stahl_Daten);
# Der Befehl entries liefert eine Sequenz der Einträge, ebenfalls in einer willkürlichen 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 Anführungszeichen (engl. double quote characters) gestellt und können einem Namen zugeordnet werden
> text1:=" dieser text";text2:=" gefällt mir";
# Zeichenketten können mit dem Befehl  cat  verbunden werden
> cat(text1,text2);cat(text2,text1);
> text3:=" dieser text"" gefällt mir nicht";type(text3,string);
# Durch Einfügung eines Leerzeichens (blank) zwischen beiden Zeichenketten wird das Anführungszeichen nicht geschrieben.
> "dieser text" " gefällt mir";
# Soll das Anführunszeichen im Text erscheinen, dann ist wie folgt vorzugehen:
> "dieser text\" gefällt mir";
# Verarbeitung von Zahlen in Maple
# Wir beginnen mit den ganzen Zahlen (integer). 
> i1:=-38;     i2:=837689;
# Die maximale Länge einer Ganzzahl ist systemabhängig 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 Brüchen in Dezimalzahlen geschieht mittels des Befehls evalf  (evaluate using floating-point arithmetic). Standardmäßig 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 geändert 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. Für die  Zahlen a = 2010  bzw. b = 1/50  kann beispielsweise gewählt 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 Lösungen 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 Näherungen durch Dezimalzahlen:
> sqrt(2), Pi, exp(1);
> sqrt2_fl:=evalf(sqrt(2));  Pi_fl:=evalf(Pi);  e_fl:=evalf(exp(1));
# Wir überprüfen 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 imaginäre 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 Imaginärteil erfolgt mit dem Befehl evalc 
> evalc(a1);evalc(a2);
# Komplexe Zahlen können auch in folgender Form eingegeben werden
> a1:=alpha1+I*beta1;a2:=alpha2+I*beta2;
# Um Real- und Imaginärteil einer komplexen Zahl a1 auszugeben, stehen die Kommandos  Re  und  Im  zur Verfügung 
> 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 erklärt 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 imaginären Zahlen  in der Menge der komplexen Zahlen enthalten. Insbesondere wird
> ie:=evalc(Complex(0,1));
# als imaginäre Einheit bezeichnet, für die gilt
> ie^2;
# Mit dem  Befehl  interface(imaginaryunit = val)  kann die in Maple verwendete Bezeichnung für 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 Imaginärteil ä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))); #Imaginärteil 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, für 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 Lösungen, 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);
# Für m = 2 (Quadratwurzel, sqrt) erhalten wir beispielsweise mit  z1  die beiden Lösungen
> 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 löschen und auf den Ausgangszustand zurückzusetzen.
> restart:
# Maple bietet die Möglichkeit, symbolische und nummerische Berechnungen unter Verwendung von Einheiten durchzuführen, und es können eigene Einheiten definiert werden. Einige Operationen mit Einheiten werden durch Context-Menüs unterstützt. Der  Befehl Units[GetDimensions]()  zeigt eine Liste aller in Maple vorhanden Dimensionen, in der auch die für die Technische Mechanik wichtigen Basisgrößen length ( Länge), mass (Masse), time (Zeit) und thermodynamic_temperature; (Thermodynamische Temperatur)  enthalten sind. 
> Units[GetDimensions]();
# Einheiten werden in Systemen zusammengefasst, etwa dem Système International d'Unités (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 für die Dimension Länge folgende Einheiten
> ?Units,length;
# Mit dem Befehl convert können Einheiten ineinander umgerechnet werden. Zur Umrechnung absoluter Temperaturen unterschiedlicher Skaleneinheiten wird die Option convert/temperature  benötigt. Beispielsweise entsprechen 30 Grad Celsius 86 Grad Fahrenheit, wie die folgende Rechnung zeigt: 
> convert(30.,temperature, degC, degF);
# Die Konvertierung von Temperaturänderungen erfolgt mit dem Befehl convert/units. Beispielsweise entspricht einem Anstieg von 30 Grad Celsius eine Tempereturänderung von 30 Grad Kelvin. 
> convert(30.,units, degC, K);
# In der Standard-Umgebung können in Maple keine Größen verarbeitet werden, die mit Einheiten belegt sind. Ausgenommen davon sind Konvertierungen von Einheiten. Siehe hierzu
> ?Units,default;
# Um Berechnungen mit Ausdrücken durchzuführen, die Einheiten enthalten, ist zunächst das Paket Units zu laden. 
> with(Units);
# Maple empfiehlt die Verwendung des  Paketes Units[Standard], womit eine automatische Vereinfachung aller Ausdrücke erfolgt.
> with(Units[Standard]);
# Welches System gerade im Gebrauch ist, das liefert uns der Befehl UsingSystem()
> UsingSystem();
# Eine Auflistung aller von Maple unterstützten 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 können 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 unterstützt 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 benötigt
> G:=Constant('G');
# Wir kehren wieder zum SI-System zurück. 
> 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 können, muss der Wert der Konstanten sowie die Einheit angegeben werden. 
> evalf(Constant('G',units));
# Wir zeigen eine solche Berechnung am Beispiel der Fallbeschleunigung g.  Beträgt die Masse der Erde mE etwa
> mE:=5.9736*10^(24)*Unit(kg);
# und der Radius rE der Kugel mit dem Volumen der Erde näherungsweise 
> rE:=6371.2*Unit(km);
# dann liefert die formale Anwendung des Newtonschen Gravitationsgesetzes die Fallbeschleunigung
> g:=evalf(Constant('G',units))*mE/rE^2;
> 
;
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
# 
