Einführung in Mathematica

Grundlegendes

Ausführen von Befehlen

4+1

(3+6)*7^2/700

(* Symbolisches Rechnen *)
2a+5a

(a + b) (a - b)

Expand[(a+b)(a-b)]

Simplify[a^2-2a b+b^2]

(* Ergebniss unterdrücken *)
4+1;

(* Befehle hintereinander ausführen *)
2^10
4^5
5^23

(* Sequenz *)
x=1 ; y=x+1; y+x

Eine Sequenz ist ein einfacher Ausdruck, und kann Funktionen als Parameter übergeben werden.
Wichtig für das imperative Programmieren mit Mathematica.

Exp[x=1; y=x+1; y+x]

Syntax

Kommentare: (* ... *)
Ausdrücke gruppieren: ( )
Funktionsparamter: [ ]
Listen, Mengen, Matrizen: { }
Indizierung: [[ ]]

Zugriff auf berechnete Ergebnisse

2+3;

(* Aufrufen des zuletzt berechneten Ergebnisses *)
Sqrt[%]

(* Aufrufen des vorletzten Ergebnisses *)
Sqrt[%%]

(* Numerische Berechnung *)
N[%]

Variablen und Zuweisungen

a=2+3

c = Sqrt[a]

a=10

c

(* Löschen von Variablen *)
Clear[a,c]

a

b=5

(* Alternativ mit dem Unset-Operator =. *)
b=.

b

Elementare Funktionen und Konstanten

Pi

N[Pi,1000]

(* Eulersche Zahl *)
E

N[E]

(* Komplexe Einheit *)
I

I^2

Cos[Pi]

Sin[Pi]

Tan[Pi]

Cot[Pi]

Exp[Pi]-E^Pi

Log[E^2]

Log[10, 100]

Hilfe

?Sin

??Solve

Ausdrücke und Funktionen

Ausdrücke

Clear[x]
f=1+Sqrt[x]

f

(* f ist keine Funktion *)
f[1]

(* Substitution *)
f/.x->1

Funktionen

Clear[f,x]

Beim definieren von Funktionen müsssen die Variablen als Pattern (z.B.: var_ ) deklariert werden.

f[x_]:= 1+Sqrt[x];

f[3]

Clear[g]

ACHTUNG!
Die folgende Gleichung definiert keine Funktion.

g[x]:=1+Sqrt[x]

g[3]

Mittelwert[x_,y_]:=(x+y)/2;

Mittelwert[3,5]

"Set" und "SetDelayed"

Clear[ff,x]

x=4;

Bei Funktionsdefinitionen mittels "Set (=)" wird die rechte Seite sofort evaluiert.

ff[x_]=2x;

ff[x]
ff[3]
ff[y]

Clear[ff,x]

x=4;

Bei Funktionsdefinitionen mittels "SetDelayed (:=)" wird die rechte Seite lazy evaluiert.
Dies ist normalerweise das gewünsche Verhalten.

ff[x_]:=2x;

ff[x]
ff[3]
ff[y]

z=3;

Globable Variablen sind trotzdem möglich.

gg[x_]:=2x+z

gg[x]
gg[3]
gg[y]

Listen, Mengen und Matrizen

Listen

li={a,b,c,d}

(* Zugriff auf Elemente *)
First[li]
Last[li]
li[[1]]
li[[3]]
li[[-1]]
li[[{1,3}]]

Append[li,a]

Length[li]
Reverse[li]
Delete[li,2]

(* Aneinanderhängen von Listen *)
Join[li,{1,2,3}]

Erzeugen und Manipulieren von Listen

Range[10]

Range[5,10]

Range[1,10,3]

Table[i^2,{i,1,10}]

range=Range[10];
MemberQ[range,5]
MemberQ[range,11]

f[x_]:=x^2;
Map[f,{1,2,3,4,5}]

(* Anonyme Funktionen *)
Map[#^2&,{1,2,3,4,5}]

(* Elemente auswählen *)
Select[range, #>5 && # < 8&]

Nest[#+1&,1,5]

Clear[f]
Nest[f,a,5]

Sum[i,{i,1,100}]
Product[i,{i,1,100}]

Mengen

li2={a,c,e,f}

Union[li,li2]

Intersection[li,li2]

Complement[li,li2]
Complement[li2,li]

Subsets[Range[5]]

Matrizen

A={{1,2,3},{6,3,4},{3,4,5}}

A//MatrixForm

A//TableForm

Det[A]

Inverse[A] //MatrixForm

(* Matrix Multiplikation *)
A . Inverse[A] //MatrixForm

(* Multiplication mit Skalar *)
2 A //MatrixForm

A[[1,1]]=0; A //MatrixForm

Polynome

Clear[f,x,y]
f=(x+y)^10-(x+y^2)^5

Expand[f]

Collect[f,x]

Collect[f,y]

Factor[f]

Collect[f,x,Factor]

Coefficient[f,x,5]

Coefficient[f,x^5]

Exponent[f,x]
Exponent[f,x,Min]

Exponent[f,y]
Exponent[f,y,Min]

Analysis

Differentation

f=(Sin[x]+Cos[x]^2)/Exp[x]

D[f,x]

(* 3. Ableitung nach x *)
D[f,{x,3}]

Integration

(* Unbestimmtes Integral *)
Integrate[f,x]

D[%,x]

TrigFactor[%]

TrigFactor[f]

(* Bestimmtes Integral *)
Integrate[f,{x,0,Pi}]

Grenzwerte

Limit[f,x->Infinity]

(* Grenzwert von links *)
Limit[Tan[x],x->π/2,Direction->1]

(* Grenzwert von rechts *)
Limit[Tan[x], x->π/2, Direction->-1]

Symbolische Summen, Reihen

Sum[Binomial[n,i]2^i,{i,0,n}]

Sum[1/i^2, {i,1,Infinity}]

Symbolische Summen, Reihen

Sum[Binomial[n,i]2^i,{i,0,n}]

Sum[1/i^2, {i,1,Infinity}]

Grafik

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

sinus=Table[Sin[x/10],{x,1,10^2}];

ListPlot[sinus]

data = Table[{Cos[2Pi x/20],Sin[2Pi x/20]},{x,0,20}];

ListPlot[data,PlotStyle->{PointSize[0.02`],Hue[0.7`]}]

ListPlot[data,Joined->True,AspectRatio->1]

Zahlentheorie

Euklidscher Algorithmus

(* Grösster gemeinsamer Teiler *)
GCD[10,15]

ExtendedGCD[10,15]

-1*10+1*15

(* Kleinstes gemeinsame Vielfache *)
LCM[3,4]

GCD[2^2000-1,3^1000-1]

LCM[2^2000-1,3^1000-1]

Primzahlen und Faktorisierung

(* Berechnen der n-ten Primzahl *)
Prime[1]

Prime[10^9]

(* Liste der ersten 100 Primzahlen *)
Table[Prime[i],{i,1,100}]

(* Primzahl Test *)
PrimeQ[19]
PrimeQ[20]

(* 20. Mersienne Primzahl (1961) *)
Timing[PrimeQ[2^4423-1]]

<<"PrimalityProving`"

ProvablePrimeQ[19]
ProvablePrimeQ[20]

p=NextPrime[2^200]

Timing[ProvablePrimeQ[p]]
Timing[PrimeQ[p]]

(* Primfaktorisierung *)
factors=FactorInteger[2^200-1]

MultiplyFactors[list_]:=Times@@Map[#[[1]]^#[[2]]&,list]

MultiplyFactors[factors]==2^200-1

Restklassen

Mod[67,20]
Quotient[76,20]

Timing[Mod[3^10000000,77]]

Timing[PowerMod[3,10000000,77]]

Mod[3^(2^100),77]

PowerMod[3,2^100,77]

(* Inverses Element modulo 11 *)
PowerMod[57,-1,11]

(* Probe *)
Mod[57 * 6,11]

Mathematica als Programmiersprache

fact1[n_] := n!

fact2 := #!&

fact3[0]:=1
fact3[n_]:=n fact3[n-1];

fact3a[0]:=1
fact3a[n_/;n>0]:=n fact3a[n-1];

fact4[n_]:=Product[i,{i,n}]

fact5[n_]:=Module[{t=1},For[i=1,i≤n,i++, t*=i];t]

fact6[n_]:=Module[{i=1,t=1}, While[i <= n, t=t*i; i++];Return[t]]

fact7[n_Integer]:=Fold[#1 #2&,1, Range[n]]

fact7a[n_Integer]:=Fold[Function[{x,y},x*y],1,Range[n]]

fact7list[n_Integer]:=FoldList[#1 #2&,1,Range[n]]

MyFold[f_,e_,{}]:=e;
MyFold[f_,e_,list_]:=MyFold[f,f[e,First[list]],Rest[list]]

fact8[n_Integer]:=MyFold[#1 #2&,1,Range[n]]

fact9[n_]:=Times@@Range[n]

fact10[n_]:=Apply[Times,Range[n]]

fact11[n_/;n≥0]:=If[n==0,1,n fact11[n-1]]

fact12 = If[#1 == 0, 1, #1 #0[#1 - 1]]&;

Laufzeitvergleiche

Timing[fact1[50000];]

Timing[fact4[50000];]

Timing[fact5[50000];]

Timing[fact6[50000];]

Timing[fact7[50000];]

Timing[fact8[50000];]

Timing[fact10[50000];]