Einführung in Mathematica

Simone Szurmant, ADDITIVE GmbH
simone.szurmant@additive-net.de

Mathematica?

CellPrint[TextCell[Animate[
ParametricPlot[{trajectory[t,params0],trajectory[t,params1],trajectory[t,params2]},{t,0,time},PlotRange->{{0,540},{-45,110}},
PlotStyle->{Red,Green,Blue},ImageSize->800,
Epilog->{PointSize[.015],Red,Point[trajectory[time,params0]],Green,Point[trajectory[time,params1]],Blue,Point[trajectory[time,params2]]}],
{time,0.1,5.1},
Initialization:>{
MPH2=5280/60^2;
KPH2=1000/60^2;
trajectory[t_,{vel_,ang_,g_}]:={t vel Cos[ang],1/2 (-g t^2+2 t vel Sin[ang])};
trajectory[t_,{vel_,ang_,g_},"Horizontal"]:=t vel Cos[ang];
trajectory[t_,{vel_,ang_,g_},"Vertical"]:=1/2 (-g t^2+2 t vel Sin[ang]);
trajectory[t_,{vel_,ang_,g_,0|0.0}]:={t vel Cos[ang],1/2 (-g t^2+2 t vel Sin[ang])};
trajectory[t_,{vel_,ang_,g_,0|0.0},"Horizontal"]:=t vel Cos[ang];
trajectory[t_,{vel_,ang_,g_,0|0.0},"Vertical"]:=1/2 (-g t^2+2 t vel Sin[ang]);
trajectory[t_,{vel_,ang_,g_,k_}]:={(-Log[Sec[ang]/vel]+Log[k t+Sec[ang]/vel])/k,(Log[Cos[Sqrt[g] Sqrt[k] t-ArcTan[(Sqrt[k] vel Sin[ang])/Sqrt[g]]]]+1/2 Log[1+(k vel^2 Sin[ang]^2)/g])/k};
trajectory[t_,{vel_,ang_,g_,k_},"Horizontal"]:=(-Log[Sec[ang]/vel]+Log[k t+Sec[ang]/vel])/k;
trajectory[t_,{vel_,ang_,g_,k_},"Vertical"]:=(Log[Cos[Sqrt[g] Sqrt[k] t-ArcTan[(Sqrt[k] vel Sin[ang])/Sqrt[g]]]]+1/2 Log[1+(k vel^2 Sin[ang]^2)/g])/k;
params0={91.2 MPH2,38 °,32,0.0};
params1={91.2 MPH2,38 °,32,.001};
params2={91.2 MPH2,38 °,32,.002}
},SaveDefinitions->True],"Picture"]]

Mathematica ist mehr als nur ein Computeralgebrasystem: es eignet sich nicht nur für Berechnungen der unterschiedlichsten mathematischen Fragestellungen, sondern auch für interaktive Präsentationen, Datenanalyse, Simulationen und Visualisierungen - und vieles mehr.

ADDITIVE?

ADDITIVE ist seit über 25 Jahren Distributor für wissenschaftliche Software und verfügt über ein interdisziplinäres Team von Mitarbeitern mit überwiegend akademischer Ausbildung. 
Neben Lizenzberatung bieten wir umfangreichen Support, Schulungen und spezialisierte Lösungen für unsere Kunden. Bei uns steht der Anwender im Mittelpunkt!

Inhalt

Grundlagen für die Arbeit mit Mathematica

Berechnungen ausführen

Graphen, Diagramme und andere Visualisierungen

Interaktivität, Demonstrations und Deployment

Im- und Export von Dateien, Arbeiten mit Daten aus der Wolfram Datenbank

Weiterführende Hinweise

Grundlagen für die Arbeit mit Mathematica

Das Mathematica-Notebook

Das Mathematica-Notebook bildet die Schnittstelle zwischen dem Anwender und dem Mathematica-Kernel.

Grundzüge des Programms

Eingaben mit Mathematica werden mit Shift+Enter abgeschickt:

3+6

2+2

Funktionsnamen beginnen mit Großbuchstaben (Tipp:eigene Variablen klein schreiben) und sind in der Regel nicht abgekürzt. Die Argumente der Funktion werden in eckige Klammern gesetzt; die geschweiften Klammern bedeuten hier “für x von 0 bis 4 Pi”:

Plot[Sin[x],{x,0,4π}]

Funktionen können auch auf Listen angewandt werden - Listen werden durch geschweifte Klammern gebildet:

Plot[{Sin[x],Cos[x], Tan[x]},{x,0,4π}]

Im Regelfall zeigen geschweifte Klammern eine Liste an. Einige Funktionen, die einen Wertebereich erfordern, wie bspw. der Plot-Befehl, verwenden aber auch geschweifte Klammern.

In Mathematica ist alles ein “Symbol”, mit dem gerechnet werden kann:

Solve[x^2+ x+1==0,x]

Funktionen können verschachtelt werden:

Graphics3D[Sphere[RandomInteger[{-5,5},{10,3}]]]

Hilfestellungen

Im Help-Menü kann das Documentation Center aufgerufen werden, welches auf vielfältige Art Hilfestellung leistet.

Über das Help-Menü kann das umfangreiche “Documentation Center” aufgerufen werden.
Alternativ: Markierung + F1

Solve

Eine Auswahlmenü (das während der Eingabe eines Befehls eingeblendet wird) hilft, wenn der vollständige Funktionsname unbekannt ist:

Pl

Sehr hilfreich bei der Arbeit mit Mathematica ist die Template-Hilfe (Aufruf über Pfeiltasten direkt bei der Eingabe oder später mit  Ctrl+⇧+K)

Plot

Bei der Eingabe von mathematischen Ausdrücken hilft die “Basic Math”-Palette. Für das Schreiben von Texten gibt es die “Writing Assistant Palette”, für Präsentationen die “Sliding Show”-Palette usw.
Nach einer Eingabe erscheint eine “Suggestions Bar” unterhalb der letzen Ausgabe, die weiterführende Befehle anzeigt. Diese Hilfsmittel werden nicht in der Präsentationsansicht gezeigt.

Wolfram|Alpha Integration

Mit der Wolfram|Alpha-Integration in  Mathematica können Anweisungen auch umgangsprachlich eingegeben werden. Hierzu am Beginn einer Eingabezelle ein “=” eingeben:

Auch die vollständigen Wolfram|Alpha-Suchergebnisse lassen sich mit Mathematica abrufen (zwei “=” zu Beginn einer Zelle eingeben). Um Zwischenschritte anzuzeigen, klicken Sie auf “Step-by-Step-Solution”.

ChatGPT mit “Wolfram Superpowers”

Mathematica kann ab Version 13.3. in sog. Chat-enabled Notebooks large-language models (LLMs) verwenden.

File ▶ New ▶ Chat–Enabled Notebook

‘ erzeugt eine neue chat input cell

External Evaluate >

Durch Eingabe des Zeichens > zu Beginn einer Input-Zelle wird diese in eine ExternalEvaluate-Zelle umgeformt.

Beispiel mit Octave/Matlab

x = -2:0.25:2;
y = x;
[X,Y] = meshgrid(x);
F = X.*exp(-X.^2-Y.^2);
surf(X,Y,F)

Plot3D[x (E^(-(x^2)-(y^2))), {x,-2,2}, {y,-2,2}, ColorFunction->"Rainbow"]

Andere Möglichkeit:

ExternalEvaluate["Python",{"def f(x): return x**2","f(3)"}]

Funktionen

Funktionen in Mathematica werden auf die folgende Weise definiert (Unterscheidung in direkte und verzögerte Zuweisung):

f[x_]:=(x^2)

g[x_] = (x^2)

Das x_ steht für einen beliebigen Ausdruck:

f[3.1415]

f[{1,2,3,4,5}]

f[\[MathematicaIcon]]

Es ist auch möglich eine Fallunterscheidung z treffen, so dass die Funktion für unterschiedliche Übergabewerte andere Werte annimmt.

f[x_Integer]:=Sin[(1/(x-1))]
f[x_Real]:=N[Pi,50]

f[10]

f[10.1]

h[x_/;x=0]:=
h[x_/;x!=2]:="Prima"

h[1]

h[0]

Listen

Listen sind zentrale Konstrukte in Mathematica and  werden verwendet um Matrizen, Mengen, Folgen etc. darzustellen.

list={1,2,3,4,5,6,7,8,9,10}

Eine Liste kann aber auch anders, über eine Vorschrift definiert werden:

Table[(i^2),{i,1,100}]

Auf Listenelemente kann mit dem Befehl Part zugegriffen werden:

Part[list, 3]

Kurzschreibweise:

list[[3]]

Mächtig werden Listen in Mathematica durch die Funktionen wie Map[]:

Map[f,list]

Anwendungsbeispiel:

Testwerte= {-Pi,2, E};

f[a_]:= NSolve[x^a + 2x+7 == 17, x, Reals]

loesung =Map[f, Testwerte]

Interpretation: für a= - Pi löst 0.49677... die Gleichung. Wie kommt man an den Wert:

ersteLoesung=x/.loesung[[1,1]]

(x^(-π))+ 2x+7 == 17/. x->ersteLoesung

Wichtige Programmierkonzepte für Profis - ein kurzer Ausblick

Eine wichtige Kategorie von Funktionen in Mathematica sind die sog. Pure Functions:

Map[# + 3&,liste]

Integrate[1/(x^3-1),x]

Map[Integrate, {1/(x^3-1), 1/(x^4-1)}]

Hierfür benötigen wir Pure Functions:

Map[Integrate[#, x]&, {1/(x^3-1), 1/(x^4-1)}]

Zum Weiterlesen im Wolfram Documentation Center:
Pure Functions

Hier können Sie mehr über die funktionale Programmierung in Mathematica lesen: 
Functional Programming im Documentation Center

Wichtig sind auch Ersetzungsregeln

{a, b+x, c x, d} /. x-> e

{{1,2}, {2,4},{4,8}}/. {a_, b_/;b>5}->{a, (Sqrt[b])}

aber Vorsicht:

{{1,0,1}, {1,3,7}, {4, -1, 2}} /. {a_, b_, c_} -> {a+b, c}

Lösung in diesem Sonderfall geht nicht mit der Kurzschreibweise -> , sondern nur über den vollständigen Befehl und einem Zusatzargument für die Ebene:

Replace[{{1,0,1}, {1,3,7}, {4, -1, 2}} , {a_, b_, c_} -> {a+b, c}, {1}]

Übung: Finden Sie die Fehler!

Jede der folgenden Eingaben enthält einen Fehler. Der Sinn jeder Eingabe wird vor dem Beispiel angegeben. Identifizieren und korrigieren Sie die Fehler.

Verwenden Sie die Funktion Round , um die Zahl 2.3 zur nächsten ganzen Zahl zu runden.

Round (2.3)

Berechnen Sie das bestimmte Integral der Funktion x sin (x) für x von 0 bis 4.

Integrate[x sin[x],x,0,4]

Zeichnen Sie die Funktion x sin (x) für x zwischen 0 und 4.

Plot[xSin[x],{x,0,4}]

Übung: Documentation Center und Paletten verwenden

Öffnen Sie das Documentation Center. Schlagen Sie dort die Funktionen nach, um folgende Aufgaben lösen zu können:

Erweitern Sie (((1+x+y))^2), um 1+2x+(x^2)+2y+2x y+(y^(2 ))zu erhalten.

Erzeugen Sie eine Liste der ersten 40 Primzahlen

Öffnen Sie nun den Basic Math Assistant und lösen damit die folgenden Aufgaben:

Berechnen Sie das Integral von (x^2) sin (x)  für x von -4 π und 4 π.

Berechnen Sie die 5.te Wurzel aus e.

Unterschiede zwischen Maple und Mathematica

Maple

h:=x->x^2*tan(x);
plot({h, D(h)}, -Pi/2..Pi/2, -50..50);

ImageCrop[, 575]

Mathematica

Computeralgebra und numerische Berechnungen

Eigenvalues[(({{a, b}, {c, d}}))]

Limit [((Sin[x])/x),x->0]

Computeralgebra

Umformungen

Faktorisieren von Termen:

Factor[(x^4) (y^2)+2 (x^4) y z+(x^4) (z^2)+2 (x^3) (y^3)+2 (x^3) (y^2) z-2 (x^3) y (z^2)-2 (x^3) (z^3)+(x^2) (y^4)-2 (x^2) (y^3) z-6 (x^2) (y^2) (z^2)-2 (x^2) y (z^3)+(x^2) (z^4)-2 x (y^4) z-2 x (y^3) (z^2)+2 x (y^2) (z^3)+2 x y (z^4)+(y^4) (z^2)+2 (y^3) (z^3)+(y^2) (z^4)]

Vereinfachen von Ausdrücken:

Simplify[2Tan[x]/(1+Tan[x]^2)]

Vereinfachen von Ausdrücken unter bestimmten Annahmen:

Simplify[Cos[k Pi]^m,Element[k,Integers],Assumptions->Mod[m,2]==0]

Umformen auf einen gemeinsamen Nenner:

Together[(1/x)+(1/(x+1))+(1/(x+2))]

Lösen von Gleichungen

Der folgende Befehl löst ein lineares Gleichungssystem, das aus den Gleichungen x + 4y = 5 und 2x + 3y = 7 besteht.

LinearSolve[{{1,4},{2,3}},{5,7}]

sol=Solve[x^2+y^2==g&&x+2y==3,{x,y}]

{x,y}/.sol[[1]]

Integralberechnung

Eingabe über die Palette....

(∂_({x}))((Sin[x y])^3)

(∫_0^∞)(((∏_(k=0)^8)Sin[(x/(2 k+1))])/(x^9))\[DifferentialD]x

oder mithilfe der Mathematica-Befehle:

Integrate[((Sin[x])^4)((Cos[x])^3), x]

f[x_]:=x^5+6x^3

D[f[x],x]

f'[x]

f'[5]

f'''[-1]

Differentialgleichungen

Die wichtigste Funktion zum Lösen von Differentialgleichungen lautet DSolve.

loesungDGL=DSolve[{y'[x]+y[x]==a Sin[x],y[0]==0},y[x],x]

eineLoesung=y[x]/.loesungDGL/. a->3

Plot[eineLoesung, {x,-0.1,0.1}]

Plotten einer stückweise definierten Differentialgleichung (man beachte: wir erhalten eine “Function” als Rückgabewert, da wir nach y und nicht nach y[x] fragen.)

Numerische Berechnungen

Genauigkeit des Ergebnisses

Mathematica hingegen kann Zahlen theoretisch unbegrenzter Länge verarbeiten. Verwendet werden State-of-the-Art-Algorithmen sowie eigens von Wolfram Research entwickelte Verfahren.

Um ein approximiertes numerisches Ergebnis zu erhalten, gibt es in Mathematica eine eigene Funktion N.

N[(24262618023850825018385924805218290358209582934058023852/6284908609428690423869024869024869024890682108649028609286),100]

//N liefert ein numerisches Ergebnis und ist eine andere Schreibweise für N[x].

2^100//N

Gibt man eine ganze Zahl ein, so geht Mathematica davon aus, dass diese exakt ist. Bei Eingabe einer reellen Zahl (wie etwa 4.5) mit einem Dezimalpunkt wird angenommen, dass diese nur nur für eine begrenzte Anzahl von Dezimalstellen genau ist.

Beispiel: Maschinengenauigkeit

NestList[11*#-1&, 0.1, 30]

Bei der Anwendung numerischer Funktionen wie NDSolve und NMinimize, verwendet Mathematica standardmässig Maschinengenauigkeit. Mit der Option WorkingPrecision->n kann die Rechengenauigkeit angepasst werden.

Beispiel: Numerische Integration mit Maschinengenauigkeit

NIntegrate[Sin[Sin[x]],{x,0,1}]

Beispiel: Numerische Integration mit 30-stelliger Working Precision

NIntegrate[Sin[Sin[x]],{x,0,1},WorkingPrecision->30]

Das Setzen der WorkingPrecision legt einen Wert für die Genauigkeit der internen Berechnung fest. Im Laufe der Berechnungen können Genauigkeisstellen verlorengehen.

Um die Genauigkeit anzugeben, die das Ergebnis schlussendlich haben woll, verwendet man die Optionen PrecisionGoal bzw.  AccuracyGoal. Zu beachten ist, dass hohe Werte für diese Optionen die Rechenzeit deutlich verlängern können.

Beispiel: Resultat einer Numerischen Integration mit 25-stelliger Genauigkeit.

NIntegrate[Sin[Sin[x]],{x,0,1},WorkingPrecision->30,PrecisionGoal->25]

50-stellige Ergebnisgenauigkeit kann nicht mit 30-stelliger Rechengenauigkeit errreicht werden.

NIntegrate[Sin[Sin[x]],{x,0,1},WorkingPrecision->30,PrecisionGoal->50, MaxRecursion->20]

Numerisches Lösen von Gleichungen

Viele Funktionen, die i.A. ein symbolisches Ergebnis liefern, besitzen ein numerisches “Äquivalent”, z.B. Solve und NSolve, Sum und NSum...

NSolve[x y==z^2-x&&x y z==2&&x^2+y^2+z^2==5,{x,y,z},Reals]

NSolve[Gamma[x]-Log[x]==I/2&&Abs[x-2]<3/2,x]

NMinimize[{2x+3y,x+5y>=10,x-y>=2,x>=1},{x,y}]

Fitfunktionen

Zunächst benötigen wir einige Daten. Der folgende Befehl erzeugt eine Tabelle von Zahlen der Funktion  Exp[(x/5)] für x-Werte von 0 bis 20:

daten =Table[N[Exp[n/5]],{n,0,20}]

Mit dem Befehl Fit wird ein Fit ausgeführt:

fit=Fit[daten, {1,x,x^2, x^3}, x]

Nun plotten wir unsere Daten gegen den Fit:

Show[ListPlot[daten, PlotStyle->Red], Plot[{fit}, {x, 0, 21}]]

Der Befehl Interpolation liefert eine Funktionsobjekt zurück.

f=Interpolation[RandomReal[1,20]]

Plot[f[x],{x,1,20}]

Numerisches Lösen einer partiellen DGL

Gegeben: Region, Wärmeleitungsgleichung und Randbedingungen:

Ω=ImplicitRegion[!((x-5)^2+(y-5)^2≤3^2),{{x,0,5},{y,0,10}}];

RegionPlot[Ω]

op=(∂_t)u[t,x,y]-(InactiveLaplacian[u[t,x,y], {x,y}, Inactive])-20;

Die Randbedingungen: hier Dirichlet- und Neumann-Randbedingungen für elliptische Probleme:

(Subscript[Γ, D])=DirichletCondition[u[t,x,y]==0,x==0&&8≤y≤10];

(Subscript[Γ, N])=NeumannValue[-2*u[t,x,y],(-5+x)^2+(-5+y)^2== 9];

Lösen der PDE und speichern der Lösung:

uifHeat=NDSolveValue[{op==(Subscript[Γ, N]),(Subscript[Γ, D]),u[0,x,y]==0},u,{t,0,100},{x,y}∈Ω];

Animation der Lösung:

Animate[Plot3D[uifHeat[t,x,y],{x,y}∈uifHeat["ElementMesh"],PlotRange->{0,160}, ColorFunction->"SunsetColors"],{{t,10},0,40,2}, AnimationRunning->False,SaveDefinitions->True]

Übungen

Lösen von Gleichungen

Berechnen Sie die Werte von x, die die Gleichung a (x^2)+b x+c=0 lösen.

Finden Sie die Lösungen {x,y} welche die Gleichungen  x^2+y^2==1 und x+y==a erfüllen.

Verwenden von Voraussetzungen

Verwenden Sie die Funktion Simplify mit den angemessenen Voraussetzungen, um zu zeigen, dass der folgende Ausdruck Null ist, wenn x positiv und n eine ganze Zahl ist.

Sqrt[x^2]-x Cos[2n Pi]

Kurvenanpassung

Werten Sie die folgenden zwei Eingaben aus, um Werte für xdata und ydata zu definieren. In dieser Übung bildet der Wert von xdata die Werte der unabhängigen Variablen in einem Datensatz ab, und der Wert von ydata gibt Werte für die abhängige (Antwort-) Variable an.

xdata={1,3,4,7,8,11,12,15};

ydata={1.7,5.9,12.8,25.1,29.2,30.1,42.0,43.9};

Werten Sie die folgende Eingabe aus, um eine grafische Darstellung dieser Daten zu sehen. Transpose[{xdata,ydata}] wird hier verwendet, um xdata und ydata in einer Liste von Paaren passend für die Verwendung als Eingabe in ListPlot zu kombinieren.

xydata=Transpose[{xdata,ydata}]

dataplot=ListPlot[xydata]

Verwenden Sie LinearModelFit, um das lineare Modell a+b x an diese Daten anzupassen.

Zeichnen Sie die Funktion, die von FindFit zurückgegeben wird, über einen den Daten entsprechenden Bereich.

Verwenden Sie Show, um die Daten und die Anpassung in derselben Grafik darzustellen.

Unterschied zwischen Maple und Mathematica

Maple

pickrand:=proc(num,list)
local a,b,i:
randomize():
a:=nops(list):
for i from 1 to num do
  b||i:=rand(1..a)():
end do:
seq(list[b||i],i=1..num);
end proc:

a:=[3,6,7,8,3,6,5,7,8,9,1,2,3,4]:

pickrand(3,a);

          [8,8,5]

Mathematica

RandomChoice[{3,6,7,8,3,6,5,7,8,9,1,2,3,4}, 3]

Visualisierungen und Bildbearbeitung

TabView[{
Style["2D visualization",FontFamily->"Arial",FontSize->14, Background->White]->,
Style["3D visualization",FontFamily->"Arial",FontSize->14, Background->White]->,
Style["data visualization",FontFamily->"Arial",FontSize->14, Background->White]->,
Style["specialized subjects & fields",FontFamily->"Arial",FontSize->14, Background->White]->
}]

Eine Übersicht der verschiedenen Plot-Befehle findet man in der Basic Math Assistant Palette, die Diagramme sind in der Palette Chart Element Schemes dargestellt.

Syntaxregeln

Plot[((Sin[x])/x),{x,-10,10}]

Plot[{((Sin[x])/x),Sin[x]},{x,-2π,2π}]

Drehen, Verschieben und Zoomen

3D-Grafiken sind interaktiv -- Klicken und Ziehen zum Drehen, Ctrl-Klick zum Zoomen und ⇧+Klick um zu verschieben.

Plot3D[Sin[x] Sin[y],{x,0,2π},{y,0,2π}]

Diagramme

data=Table[RandomReal[NormalDistribution[RandomReal[{-2,2}],RandomReal[{0.5,2}]], 100], {i,10}];

BoxWhiskerChart[data]

InteractiveTradingChart[{"AAPL",{{2010,1},Date[]}}]

Viele Optionen möglich

Viele verschiedene Optionen ermöglichen es dem Benutzer, den Plot an eigene Bedürfnisse anzupassen, bspw. Transparenz, Farbe, etc.

ParametricPlot3D[{(1.16^v) Cos[v] (1+Cos[u]),-(1.16^v) Sin[v] (1+Cos[u]),-2 (1.16^v) (1+Sin[u])},{u,0,2 π},{v,-15,6},PlotRange->All,Mesh->None,Boxed->False,Axes->False,PlotStyle->{Orange,Opacity[0.75],Specularity[White,20]},MaxRecursion->3,Background->Black,RotationAction->"Clip"]

Beispiel Image Processing: Wege durchs Labyrinth

Thinning[]

Pruning[%, ∞]

Beispiel Filter: Rauschunterdrückung

TotalVariationFilter[,0.35,Method->"Poisson"]

Beispiel: Bildvergleich

ImageDifference[,]

Übung: Zeichnen von Punkten

Zeichnen Sie die folgende Liste von Punkten.

{{1,90.2},{2,112.8},{3,100.8},{4,11.4},{5,-56.2},{6,-54.0},{7,-10.6},{8,20.9},{9,20.1},{10,4.5},{11,-3.7},{12,-2.2},{13,-0.9},{14,0.5},{15,2.2},{16,3.7},{17,-4.5},{18,-20.1},{19,-20.9},{20,10.6},{21,54.0},{22,56.2},{23,-11.4},{24,-100.8},{25,-112.8},{26,-54.9}};

Übung: Dreidimensionale Plots

Zeichnen Sie die Funktion (e^(-(x^2)-((y )^2))) mit Hilfe der Funktion Plot3D. Wählen Sie die nach Ihrer Meinung angemessenen Grenzen für x und y.

Interaktivität

Dynamische Modelle

Das Grundprinzip, wie dynamische Elemente in Mathematica erzeugt werden, ist sehr einfach:

Plot[Sin[x],{x,0,2Pi}]

Manipulate[Plot[Sin[a x], {x, 0, 2Pi}], {a, 1, 10}]

Alternativ kann statt dem Befehl Manipulate auch der Animate-Befehl verwendet werden.

Ein Beispiel mit mehreren Veränderlichen:

Ein weiteres Beispiel:

Demonstrations und Deployment

Neben der Möglichkeit eigene Applikationen zu erstellen können Sie auch auf die Demostrations-Datenbank von Wolfram zugreifen. Über 10.000 kleiner interaktiver Anwendungen können Sie dort abrufen.

Testen Sie eines der Beispiele auf demonstrations.wolfram.com; z.B. Learning Newton's Method.

Bei allen Demonstrations kann auch das entsprechende Notebook heruntergeladen und den eigenen Bedürfnissen angepasst werden.

Unter dem Begriff Deployment versteht Wolfram Research die Möglichkeit, kleine Anwendungen wie obige weiterzugeben - zum Beispiel an Personen ohne Mathematica.
1. Schritt: Speichern des Mathematica-Notebooks als CDF-Datei
2. Schritt: Nutzern ohne Mathematica die .cdf-Datei zur Verfügung stellen. Der kostenfreie CDF-Player kann von der Wolfram Webseite heruntergeladen werden.

Alle mit dem Befehl Manipulate interaktiv gestalteten Funktionen können innerhalb des CDF-Players bedient werden.

Übung: Gestalten Sie einen Befehl dynamisch!

Werten Sie die folgenden Ausdrücke zunächst aus, um einen Eindruck über ihre Funktionsweise zu erhalten. Gestalten Sie dann den Ausdruck dynamisch, indem Sie den Befehl Manipulate verwenden.

N[π, 200]

π soll mit einer Genauigkeit zwischen 100 und 1000 angezeigt werden (in 100 er Schritten)

Graphics[Line[{{-1,0},{0,0},{1,1}}]]

Ersetzen Sie den mittleren Punkt der Linie durch einen sogenannten Locator (siehe Documentation Center).

Unterschiede zwischen Maple und Mathematica

70 Zeilen Code und 6 wizards in Maple um eine einfaches simple mouse-driven interface zu erstellen

ImageCrop[, 1500, Bottom]

Mathematica

Manipulate[
Plot[a*function[f*(x-p)]+c,{x,-2π,2π},
Ticks->{{-2π,-((3π)/2),-π,-(π/2),(π/2),π,((3π)/2),2π},True},
PlotStyle->{Thickness[0.008],Hue[.6]},
PlotRange->{-6,6},
PlotLabel->Style[a*function[f*(x-p)]+c,14,Bold],
GridLines->Automatic,
LabelStyle->Directive[FontFamily->"Helvetica",FontSize->12],
ImageSize->{300,200}
],
{{f,1,"frequency"},1,5,Appearance->"Labeled"},
{{a,1,"amplitude"},-5,5,Appearance->"Labeled"},
{{p,0,"horizontal shift"},-3,3,Appearance->"Labeled"},
{{c,0,"vertical shift"},-2,2,Appearance->"Labeled"},
{function,{Sin,Cos,Tan,Csc,Sec,Cot}},
SaveDefinitions->True]

Arbeiten mit Daten

Mathematica unterstützt den Import und Export vieler Dateiformate.....

...und Mathematica erlaubt den Zugriff auf Daten einer großen Anzahl von Fachgebieten.

Unterstützte Dateiformate

$ImportFormats

$ExportFormats

Import von Daten

Import["C:/Windows/Media/chimes.wav"]

data1=Import["C:/Windows/Media/chimes.wav","Data"]

ListPlot[data1[[1]]]

Beispiel für den Import einer Excel-Tabelle

data2 =Import["D:\\Beispiel.xls"]

TableForm[data2]

Import von Daten aus dem Internet

Import["http://exampledata.wolfram.com/hailey.dem.gz",ColorFunction->"GreenBrownTerrain"]

Export von Daten

Beim Export von Dateien ist zu beachten, dass das Dateiformat, in welches exportiert werden soll, angegeben werden muss.

testbild = Plot[Sin[x],{x,0,2Pi}]

Export["test.jpg", testbild]

Es lassen sich auch dynamische Elemente exportieren.

Export[ "test.avi", Manipulate[Plot[Sin[a x], {x, 0, 2Pi}], {a, 1, 10}]]

Der folgende Befehl zeigt das Verzeichnis an, in welchem Ihre Dateien abgespeichert werden. Möchte man nicht dieses Standardverzeichnis verwenden, kann man statt des Dateinamens auch einen vollständigen Dateipfad angeben.

Directory[]

Freiform-Eingabe

Suchen von Informationen über Wolfram Alpha:

Abfrage der Wolfram Wissensdatenbank

Inline  Free Form Input

LinguisticAssistant

(Entity["adenosine triphosphate", Entity["Chemical","AdenosineTriphosphate"], "Entity[\"Chemical\", \"AdenosineTriphosphate\"]", "chemical"])["MoleculePlot"]

https://reference.wolfram.com/language/guide/EntityTypes.html

Übung: Daten in eine Datei schreiben

Verwenden Sie Export, um die folgende Zahlenmatrix in eine Datei im Format Table zu schreiben. Sie können Ihr Ergebnis überprüfen, indem Sie FilePrint verwenden, um die Datei in dem Notebook anzuzeigen oder indem Sie die Datei mit einem herkömmlichen Editor ansehen.

data={{1.5,2.8 10^6,1},{4.1,5.3 10^6,3},{7.3,1.25 10^7,7},{8.1,2.71 10^7,6},{9.5,3.11 10^7,3}};

Verwenden Sie Import, um die Daten aus der exportierten Datei als eine Zahlentabelle einzulesen.

Weiterführende Hinweise

MouseOverLernhilfen für Mathematica    https://www.wolfram.com/wolfram-u/

Einführungshandbuch für Mathematica von Stephen Wolfram: https://www.wolfram.com/language/elementary-introduction/3rd-ed/?source=nav

ADDITIVE Schulungen

MouseOver Forum zum Austausch mit anderen Lehrenden

ADDITIVE-Mathematica Informationen zu Mathematica

Wolfram|Alpha for Educators

Noch Fragen?

Fragen zu Lizenzformen, Testversionen, Funktionsumfang etc.: 
simone.szurmant@additive - net.de

Hilfestellung zu Installation, Applikationsentwicklung etc.: support@additive - net.de

Initialization

$SupplementalFilesDirectory=FileNameJoin[{NotebookDirectory[],"SupplementalFiles"}];

SetOptions[Plot,ImageSize->300];

SetOptions[Plot3D,ImageSize->300,RotationAction->"Clip"];

SetOptions[Graph,ImageSize->200];

$Line=0;

CreateExerciseSheet[problems_List,instructions_String,windowTitle_String]:=Module[{partitionedTable},
partitionedTable=Partition[
MapIndexed[Column[{Style[StringForm["Exercise `1`.",First[#2]],"Subsubsection"],#1}]&,problems],2];
CreateDocument[{
TextCell["Name____________________________             Hour_______","Subsection"],TextCell[instructions,"Subsubsection"],
TextCell[Grid[
partitionedTable,
Spacings->{12,2}],ShowStringCharacters->False,CellMargins->{{42,Inherited},{Inherited,24}}]
},ShowCellLabel-> False,WindowTitle-> windowTitle]
]

CreateTableGridSheet[problems_List,instructions_String,windowTitle_String]:=Module[{textcells,probcells,len=Length[problems]},
textcells=TextCell[Style[StringForm["Exercise `1`.",#],"Subsubsection"],CellMargins->{{60,Inherited},{0,36}},ShowStringCharacters->False]&/@Range[len];
probcells=Map[TextCell[Row[#],ShowStringCharacters->False,CellMargins->{{60,Inherited},{12,0}}]&,problems];
CreateDocument[{
TextCell["Name____________________________             Hour_______","Subsection"],TextCell[instructions,"Subsubsection"],
Sequence@@Riffle[textcells,probcells]
},ShowCellLabel-> False,WindowTitle-> windowTitle]
]

$Line=0;