![[Graphics:Images/AllFiles.HTML_gr_1.gif]](Images/AllFiles.HTML_gr_1.gif)
![[Graphics:Images/AllFiles.HTML_gr_2.gif]](Images/AllFiles.HTML_gr_2.gif)
![[Graphics:Images/AllFiles.HTML_gr_3.gif]](Images/AllFiles.HTML_gr_3.gif)
![[Graphics:Images/AllFiles.HTML_gr_4.gif]](Images/AllFiles.HTML_gr_4.gif)
Scripta bilingua
Lauffähige Files für Windows Ausgabe ohne Output
• Des dossiers - (Files) - exécutables pour Windows • Edition sans output
Copyright Rolf Wirz
(Beispiele nach Wolfram u.a.
• Exemples d'après Wolfram et autres)
(Beispiele nach Blachman u.a., im Print gemischt mit III
• Exemples d'après Blachman et aautres, dans le "print" mêlé à III )
(Beispiele nach Blachman u.a., im Print gemischt mit II
• Exemples d'après Blachman et autres, dans le "print" mêlé à II)
(Diverse Beispiele -> Praktikum • Exemples divers -> Laboratoire)
Einst_00.nb: (Uebersicht • Vue d'ensemble)
Einst_01.nb: (Numerische Rechnungen • Calculs numériques)
etc.
........
........
........
Einst_11.nb: (Datenaustausch mit Mathematica, andere Ausgabeformen
• Echanges de donnés avec Mathematica, d'autres possibilités d'output)
In diesem Inhaltsverzeichnis ist aus Platzgründen pro File nur die oberste Gliederungsebene wiedergegeben.
• Dans cet index nous n'avons reproduit pour des raisons de place que le niveau supérieur de répartition par fichier.
Kurs_01.nb, Ueb_01.nb
Kurs_02.nb, Ueb_02.nb
Kurs_03.nb, Ueb_03.nb
Kurs_04.nb, Ueb_04.nb
Kurs_05.nb, Ueb_05.nb
Kurs_06.nb, Ueb_06.nb
Kurs_07.nb, Ueb_07.nb
Kurs_08.nb, Ueb_08.nb
Kurs_09.nb, Ueb_09.nb
Kurs_10.nb, Ueb_10.nb
Kurs_11.nb, Ueb_11.nb
Kurs_12.nb, Ueb_12.nb
Kurs_13.nb, Ueb_13.nb
Kurs_14.nb, Ueb_14.nb
Kurs_15.nb, Ueb_15.nb
Ueb_01.nb
Ueb_02.nb
Ueb_03.nb
Ueb_04.nb
Ueb_05.nb
Ueb_06.nb
Ueb_07.nb
Ueb_08.nb
Ueb_09.nb
Ueb_10.nb
Ueb_11.nb
Ueb_12.nb
Ueb_13.nb
Ueb_14.nb
Ueb_15.nb
Dazu existieren diverse Daten- und Programmfiles, die der Ordnung im Directory
und der Lesbarkeit wegen alle mit "AAA" oder mit "aaa" beginnen. Man findet sie daher zuoberst.
• Il existe aussi différents dossiers de données et de programmes qui commencent tous par "AAA"
ou par "aaa" pour des raisons d'ordre dans le directoir et pour une meilleure lisibilité. On les trouve
tout en haut.
Ueb_1_Thema.ma
etc.
........
........
........
Ueb_xx_Thema.ma
Eigenes "Root" -> "work" -> "Daten"
-> "MathemDF" -> "Kurs"
-> "Uebungen"
-> "KopieDerDaten"
(Sicherung gegen Datenverlust)
• Propre "Root" -> "work" -> "Daten"
-> "MathemDF" -> "Kurs"
-> "Uebungen"
-> "KopieDerDaten"
(Mesure de sécurité contre la
perte des données)
Die Namen sind selbsterklärend. Die Files in "Kurs" können durch Anklicken der aktionsfähigen Zellen (unbedingt der Reihe nach) abgearbeitet und dabei studiert werden.
• Les noms s'expliquent eux-mêmes. Les fichiers courrants peuvent être élaborés en marquant (par la souris) les cellules exécutables (maintenir absolument l'ordre) et en même temps ils peuvent être étudiés.
Verglichen mit einem hohen Berg ist auch ein grosses Haus eine kleine Sache.
"Kleine Einführung" muss noch lange nicht "kurze Einführung" bedeuten ....
• En comparaison d'une haute montagne, même une grande maison n'est qu'une petite chose. "Petite introduction" ne signifie pas forcément "courte introduction" ...
S. Wolfram: Mathematica
Nancy Blachman: Mathematica: A Practical Approach
Nancy Blachman: Mathematica griffbereit etc. etc. etc. ---> Bibl.!
9 + 173^101N[%]N[Sqrt[10],50](4 + 7I)^12BesselJ[0,15.2]FindRoot[BesselJ[0,x],{x,14.5}]N[Zeta[1/2+13I],36]NIntegrate[Sin[Sin[x]],{x,0,Pi}]FactorInteger[70987635488]Remove["Global`@*"]Plot[Sin[Exp[x]],{x,0,Pi}]Plot[Sin[Exp[x]],{x,0,Pi}];
Was war der Unterschied?
• Quelle était la différence?
Show[%,Frame->True,FrameLabel->{"Zeit","Weg"},
GridLines->Automatic];ContourPlot[Sin[x+Sin[y]],{x,-2,2},{y,-2,2}];Plot3D[Sin[x+Sin[y]],{x,-3,3},{y,-3,3}];ParametricPlot3D[{u Sin[t], u Cos[t], t/3},
{t,0,15},{u,-1,1},Ticks->None];
ParametricPlot3D[{Sin[t], Sin[2t] Sin[u], Sin[2t] Cos[u]},
{t,-Pi/2,Pi/2},{u,0,2 Pi},Ticks->None];
Show[%,%%];Show[Graphics3D[
{Cuboid[{0,0,0}],Cuboid[{2,2,2}],
Cuboid[{2,1,3}],Cuboid[{3,2,1}],
Cuboid[{2,1,1}]} ]]Play[Sin[1000/t],{t,-4,16}]Remove["Global`@*"]9(2+x)(x+y)+(x+y)^2Expand[%^3]Factor[%]Integrate[x^2 Sin[x]^2,x]D[%,x]Simplify[%]Series[%,{x,0,14}]
Clear[f];
Series[ (f[x + h]-f[x - h])/(2h),{h,0,6}]Remove["Global`@*"]x^3 - 7 x^2 + 3 a x == 0Solve[%,x]Solve[{a x + b y == 0, x + y == c},{x,y}]NSolve[x^5+2x+1==0,x]FindRoot[{Sin[x]==x-y,Cos[y]==x+y},{x,1},{y,0}]DSolve[y''[x]-k y[x]==1,y[x],x]NDSolve[{y''[x] + Sin[x]^2 y'[x] + y[x] == Cos[x]^2,
y[0]==1, y'[0]==0},
y, {x,0,20}]Plot[Evaluate[y[x]/.%],{x,0,20}];Remove["Global`@*"]Table[n!,{n,1,15}]N[Log[%]]ListPlot[%];Fit[%%,{1,x,x^2},x]Plot[%,{x,0,14}];arr = Table[If[GCD[i,j]==1,1,0],{i,30},{j,30}];ListDensityPlot[arr]??FourierFourier[{1, 1, 1, 1, -1, -1, -1, -1}]Max[Abs[Fourier[{1, 1, 1, 1, -1, -1, -1, -1}]]]Fourier[{1, 1, 1, 1, -1, -1, -1, -1}] // NMax[Abs[N[Fourier[{1, 1, 1, 1, -1, -1, -1, -1}]]]]Max[Abs[N[Fourier[arr]]]]
Frage: Was ist von der Ausgabe des Resultats zu halten?
• Question: Que faut-il penser de la sortie du résultat?
Remove["Global`@*"]m = Table[1/(i+j+1),{i,3},{j,3}]MatrixForm[m]Inverse[m]MatrixForm[Inverse[m]]MatrixForm[m.Inverse[m]]mNeu = m - x IdentityMatrix[3]MatrixForm[mNeu]Det[mNeu]Eigenvalues[m]N[%] // Chopn = Table[Random[],{100},{100}];Eigenvalues[%];ListPlot[Transpose[{Re[%],Im[%]}]]s = {{a,b},{-b,2a}}; MatrixForm[s]Simplify[Eigenvectors[s]]Remove["Global`@*"]y = 1 + x^2 + 3 x^3y /. x->1+a{f[1],f[2],f[3]} /. f[2]->b![[Graphics:Images/AllFiles.HTML_gr_5.gif]](Images/AllFiles.HTML_gr_5.gif){kind=small}
(n^2)![[Graphics:Images/AllFiles.HTML_gr_6.gif]](Images/AllFiles.HTML_gr_6.gif){kind=small}
(n^2)
{f[1],f[2],f[3]} /. f[n_]->n^2![[Graphics:Images/AllFiles.HTML_gr_7.gif]](Images/AllFiles.HTML_gr_7.gif){kind=small}
(n^2)![[Graphics:Images/AllFiles.HTML_gr_8.gif]](Images/AllFiles.HTML_gr_8.gif){kind=small}
(n^2)
f[n_]:= n^2;
(*Ausgabe auf dem Schirm: • Imprimer sur l'écran: *)
f[n]f[3] + f[a+b]fac[n_]:= n fac[n-1]fac[1]:= 1?facfac[25]log[x_ y_]:= log[x] + log[y]log[a b c d]g[i_] + g[j_] := g[i+j]g/: g[i_] + g[j_] := g[i+j]Clear[y];
g[x] + g[y] + g[z]Remove["Global`@*"]Permutations[{a,b,c}]Flatten[%]Position[%,b]FoldList[Times,{1},%]NestList[Cos,x,3]Plot[Evaluate[%],{x,0,1}];Clear[f];
Map[f,{a,b,c,d}]Map[Function[x,1+x^2],{a,b,c,d}]Clear[f];
f[0]=f[1]=1;
f[n_]:=f[n-1]+f[n-2]f[4]Trace[f[4],f[_]]Remove["Global`@*"]Hilbert[n_]:=Table[1/(i+j-1),{i,n},{j,n}]Hilbert[3]; MatrixForm[%]CharPoly[m_,x_]:=
Det[m-x IdentityMatrix[Length[m]]]/; MatrixQ[m]
(* Check auf Matrix bei m *)?/;m = {{1,2,3},{2,3,4},{3,4,5}};
Print[MatrixForm[m]];
CharPoly[m,x]m = {1,2,3,2,3,4,3,4,5};
Print[MatrixForm[m]];
CharPoly[m,x]
NextPrime[n_Integer]:=
Module[{k=n},
While[!PrimeQ[k],k++];
Return[k]
] NextPrime[111]Mean[list_List] :=Apply[Plus,list] / Length[list];
Variance[list_List]:=Mean[(list-Mean[list])^2];
Quantile[list_List,q_]:=
Part[Sort[list],-Floor[-q Length[list]]]/; 0<q<1;
Alles[list_, q_]:=Module[{},
Print["Mean = ",Mean[list]];
Print["Variance = ",Variance[list]];
Print["Quantile = ",Quantile[list,q]];
]??Module
l={1,2,2,3,3,3,4,4,4,5,5,6,7,7,8,9}; q=0.1;
Alles[l,q]zs[n_Integer]:=
FoldList[Plus,0,Table[Random[]-1/2,{n}]]
zs[100]ContinuedFraction[x_Real,n_Integer]:=
Floor[NestList[Function[{u},1/(u-Floor[u])],
x,n-1]]
h=N[(Sqrt[5]-1)/2,100];
Print[h]
ContinuedFraction[h,30]
e=N[E,100];
Print[e]
ContinuedFraction[e,30]
p=N[Pi,100];
Print[p]
ContinuedFraction[p,30]Jac[funs_List,vars_List]:=Outer[D, funs, vars]f={x^2+x y-1, Cos[y]-z, a x z};
v={x,y,z};
Jac[f,v]Laplace[c_,t_,s_]:=c/s/; FreeQ[c,t];
Laplace[a_+b_,t_,s_]:=
Laplace[a,t,s]+Laplace[b,t,s];
Laplace[c_ a_,t_,s_]:=
c Laplace[a,t,s]/; FreeQ[c,t];
Laplace[t_^n_.,t_,s_]:=
n!/s^(n+1)/; (FreeQ[n,t]&&n>0);
Laplace[a_. Exp[b_.+c_. t_],t_,s_]:=
Laplace[a Exp[b],t,s-c]/; FreeQ[{b,c},t];?_.?FreeQLaplace[E^t+4t^2-2t+1,t,s]RunEncode[{rest___Integer,same:(n_Integer)..}]:=
Append[RunEncode[{rest}],{n,Length[{same}]}];
RunEncode[{}]:={}r={1,2,2,2,3,3,3,3,3,3,3,4,4,5,6,6,6,7,8,9,9,9,10};
RunEncode[r]PolarPlot[r_,{t_,tmin_,tmax_}]:=
ParametricPlot[{r Cos[t], r Sin[t]},
{t,tmin,tmax},AspectRatio->Automatic]PolarPlot[t^2,{t,0,2 Pi}];PolarPlot[t^(1/2),{t,0,2 Pi}];PolarPlot[E^t,{t,0,Pi}];RootPlot[poly_,z_]:=
ListPlot[{Re[z],Im[z]}/. NSolve[poly==0,z],
AspectRatio->Automatic,
PlotStyle->{PointSize[0.04]}]/;
PolynomialQ[poly,z]RootPlot[z^20 -1,z];file[file_String]:=
ReadList[file,Number,RecordLists->True]FilePlot3D[file_String]:=
ListPlot3D[ReadList[file,Number,
RecordLists->True]]Print[file["f:\mate\Daten\aadaten"]];
FilePlot3D["f:\mate\daten\aadaten"]?RecordLists!!f:\Mathe/Daten/aadaten<<f:\Mathe/Daten/aadatenWas ist jetzt passiert?
??<<?Selectfn=FileNames[] >> f:\Mathe/Daten/aaxxx;
fnxxx=Flatten[ReadList["f:\Mathe/Daten/aaxxx",
Expression,RecordLists->True,
WordSeparators->{" "}]];
Print[fnxxx];
Print[fnxxx[[1]]];
Print[fnxxx[[3]]];
Clear[Where];
Where[s_String]:=
Select[fnxxx,(Length[FindList[#,s,1]]>0)&]Where["e"]Wo liegt also das Problem hier? • Où est le problème ici?
Remove["Global`@*"]<<Calculus`LaplaceTransform`LaplaceTransform[t^n Exp[-c/t],t,s]<<Calculus`Pade`Pade[Exp[Sin[x]],{x, 0, 2, 3}]<<Statistics`DescriptiveStatistics`LocationReport[Table[Random[],{1000}]]<<DiscreteMath`Permutations`RandomPermutation[20]ToCycles[%]<<Miscellaneous`ChemicalElements`AtomicWeight[Tungsten]AtomicWeight[Plutonium]Off[AtomicWeight::unstable]AtomicNumber[Plutonium]ListPlot[AtomicWeight[Elements]/AtomicNumber[
Elements], PlotJoined->True]<<Graphics`Polyhedra`Show[Polyhedron[GreatIcosahedron]];Remove["Global`@*"]Remove["Global`@*"]c=(a^2+b^2)/(x+y)^5![[Graphics:Images/AllFiles.HTML_gr_9.gif]](Images/AllFiles.HTML_gr_9.gif){kind=small}
InputForm[c]TeXForm[c]FortranForm[c]CForm[c]![[Graphics:Images/AllFiles.HTML_gr_10.gif]](Images/AllFiles.HTML_gr_10.gif)
![[Graphics:Images/AllFiles.HTML_gr_11.gif]](Images/AllFiles.HTML_gr_11.gif)
![[Graphics:Images/AllFiles.HTML_gr_12.gif]](Images/AllFiles.HTML_gr_12.gif)
!cd C:\\WORK;![[Graphics:Images/AllFiles.HTML_gr_13.gif]](Images/AllFiles.HTML_gr_13.gif)
ReadList["AAAdaten.txt", String]!cd C:\work;
ReadList["C:\work\AAAdaten.txt",String]![[Graphics:Images/AllFiles.HTML_gr_14.gif]](Images/AllFiles.HTML_gr_14.gif)
![[Graphics:Images/AllFiles.HTML_gr_15.gif]](Images/AllFiles.HTML_gr_15.gif)
![[Graphics:Images/AllFiles.HTML_gr_16.gif]](Images/AllFiles.HTML_gr_16.gif)
![[Graphics:Images/AllFiles.HTML_gr_17.gif]](Images/AllFiles.HTML_gr_17.gif)
![[Graphics:Images/AllFiles.HTML_gr_18.gif]](Images/AllFiles.HTML_gr_18.gif)
!cd![[Graphics:Images/AllFiles.HTML_gr_19.gif]](Images/AllFiles.HTML_gr_19.gif)
![[Graphics:Images/AllFiles.HTML_gr_20.gif]](Images/AllFiles.HTML_gr_20.gif)
![[Graphics:Images/AllFiles.HTML_gr_21.gif]](Images/AllFiles.HTML_gr_21.gif)
Die restlichen Befehle sind UNIX-Befehle. "cd": Directory-Wechsel, "ls": Directory lesen.
• Les autres ordres sont des ordres UNIX. "cd": Changer le directoire, "ls": Lire le directoire
ReadList["!square",Number]ReadList["!ls",String]ReadList["!cd C:/work;ls",String]!cd work;
ReadList["!dir",String]ReadList["!cd C:\work\AAAdaten.txt;dir",String]!cdInstall["iterat"]getdata["C:\work\AAAdaten.txt",8]FindList["C:\work\AAAdaten.txt","1"]StringReplace[%,"7"->"a"]FindList["C:\work\*","AAA"]FindList["!cd C:\work;ls","A"]FindList["!cd C:\work;ls","AA"]FindList["!cd C:\work;ls","AAA"]FindList["!cd C:\work;ls","AAA_"]Remove["Global`@*"]
Finde heraus, was von Mathematica und was von der Maschine abhängt!
• Distingue ce qui dépend de Mathematica et ce qui dépend de la machine.
Hinweis: Wenn Du einmal nicht weiterkommst, so frage den Kursleiter oder konsultiere die Literatur, z.B. "Mathematica" von Wolfram.
• Indication: Si tu as un problème, adresse-toi au professeur ou consulte la littérature, p.ex. "Mathematica" de Wolfram.
Mit welcher Mathematica-Version arbeitest Du? Drücke die Enter-Taste in der Zelle mit "$Version".
• Avec quelle version de Mathematica traveilles-tu? Appuie sur la touche "entrer" dans la cellule avec "$Version".
$Version
1. Finde heraus, was "Front-End" und was "Kernel" bedeutet.
• Que siginifie "Front-End" et "Kernel"?
2. Was bewirkt die Enter-Taste?
• Que produit la touche "Enter"?
3. Was bewirkt "Shift-Return"?
• Que produit la touche ""Shift-Return"?
4. Was bewirkt "Command"?
• Que produit la touche "Command"?
5. Was bewirken die Icons "Action" - "Interrupt" etc.?
• Que produisent les Icons "Action" - "Interrupt" etc.?
6. Wie ist es auf andern Maschinen?
• Comment cela se passe-t-il sur d'autres machines?
Apply[Plus, {a,b,c,d}]a + b + c + d
Wie ist es mit Gross- und Kleinschreibung?
Wie ist es mit den verschiedenen Klammerarten?
Wie ist es mit den "blanks"?
Wie ist es mit der Interpunktion?
Wie ist es mit dem Fond? (Fixe und variable Abstände, z. B. Courier contra Times)?
•
Pose-toi des Questions aux sujets suivants:
Majuscule - minuscule,
parenthèses,
"blanks",
ponctuation,
"fond" (distances foxes et variables, p. ex. Courier contra Times).
Potenzieren: • Calculer les puissances:
5^10Resultat der letzten Zelle verwenden: • Utiliser le résultat de la dernière cellule:
%^(1/10)% + a%3^(1/10)%%% + bNamen vergeben: • Donner des noms:
Schifflänge = 3Schifflänge20 Schifflänge2 m + 3 m
Mathematica hat sehr viele Befehle (Funktionen etc.) eingebaut.
Merke: Mathematica-Namen beginnen alle mit Grossbuchstaben.
• Dans Mathematica beaucoup d'ordres (fonctions etc.) sont incorporés.
Retenez: Les noms de Mathematica commencent tous par des majuscules.
Abs[-8]Cos[Pi]D[x^2-3x+4,x]M = {{1,2},{5,1}}; MatrixForm[M]Det[M]GCD[48005, 100098630]
Mathematica hat mehr als 700 Funktionen eingebaut, die über das Help-Service abfragbar sind. "*" figuriert dabei als "wild card". Help ist Front End-spezifisch.
Weitere Info: Mathematica Quick Reference Guide, Mathematica Help Stack, Manual, spez. Literatur.
• Dans Mathematica sont incorporées plus de 700 fonctions qui sont disponibles par le service Help. "*" y figure comme "wild card". Help est spécifique de Front End. Autres Informations: Quick Reference Guide, Mathematica Help Stack, Manual, litt. spéc..
?Factor*?FactorIntegerFactorInteger[75]FactorInteger[1122445667788]?Sin?*Sin*?Cos?Tan?Exp*?Log?DivisorsDivisors[5000]?*Graphic*?*Plot*??Plot?@Beispiel: • Exemple:
?NIntegrate
Integrate
ContourPlot
InterpolatingPolinomial
MapAt
Binomial
Eigenvalues
FindRoot
Integrate
Timing
Gehe in die nächste Zelle und drücke "Command k":
• Entrer dans la cellule suivante et appuyer "Command k" :
Sor
Gehe in die nächste Zelle, markiere mit der Maus "So" und drücke "Command k":
• Entrer dans la cellule suivante, marquer à la souris "So" et presser "Command k":
Sor
Probiere aus:
• Essayer:
Sort[{2,5,3,1,8}]
Gehe ins Menu auf ("Action" (old),) "Prepare Input", "Complete Selection":
• Entrer dans le menu sur ("Action" (old),) "Prepare Input", "Complete Selection":
Sor
Gehe ins Menu auf ("Action" (old),) "Prepare Input", "Make Template":
• Entrer dans le menu sur ("Action" (old),) "Prepare Input", "Make Template":
Sor
Gehe in die nächste Zelle und drücke "Command I": (Old?)
• Entrer dans la cellule suivante et presser "Command I": (Old?)
![[Graphics:Images/AllFiles.HTML_gr_22.gif]](Images/AllFiles.HTML_gr_22.gif)
Gehe in die nächste Zelle und drücke "Command I": (Old)
Markiere "ContourPlot" in der nächste Zelle und drücke "F1".
Markiere die nächste Zelle und drücke "Shift F1".
•
Entrer dans la cellule suivante et appuier "Command I": (Old)
Marque "ContourPlot" dans la cellule suivante et appuie "F1".
Marque la cellule suivante et appuie "Shift F1".
ContourPlot
Was bedeuten die folgenden Zeichen? • Que signifient les signes suivants?
+ - * / ^ ! < <= > >=
?+?-?*?/?^?!?<?<=?>?>=4 + 7 4/24/3N[4/3]3 < 6?<Alias["<"]Alias["="]
Wende "Alias" auf weitere mathematische Symbole an.
• Utilise "Alias" pour d'autres symboles mathématiques.
Beachte im Folgenden, sofern vorhanden, die Klammern. Was passiert jeweils?
• Observe dans ce qui suit les parenthèses, quand il y en a.
Que se passe-t-il chaque fois?
1 + 2 + 31 + (2 + 3)1 / 2 - 5(1 + 2 ) * 3(1 + 2 ) 31 / (2 - 5)?DivisorsArgumente von Funktionen: • Arguments de fonctions
Divisors[100]?RandomRandom[ ]Random[Integer]Random[Integer,{50,60}]
Mengen, Listen, Vektoren, Matrizen...:
• Ensembles, listes, vecteurs, matrices...:
{x, x^2, x^3}{{a[1,1],a[1,2]},{a[2,1],a[2,2]}}MatrixForm[{{a[1,1],a[1,2]},{a[2,1],a[2,2]}}]v={a,b,c}v[[1]]v[[2]]m = {{1,2,3},{4,5,6}}MatrixForm[m]m[[2]]m[[2,1]]7 + 4 (* Das ist ein Kommentar *)
Gewisse Befehle sind ausgelagert in sogenannten "Packages". (Vgl. in Menu: "Info", Open Function Browser" (old?) --> Help --_ Help.) Packages muss man erst laden, bevor man sie verwenden kann. (NeXT:" ` " ist Alt-Shift-n, vgl. Preferences.)
• Certains ordres sont stockés à l'extérieur dans les "Packages". (Compare dans le Menu: "Info", Open Function Browser" (old?) --> Help --_ Help.) Il faut d'abort charger Packages, avant de pouvoir les utiliser. (NeXT:" ` " est Alt-Shift-n, voir Preferences.)
?MeanMean[list] gives the mean of the entries in list.
(Durch den Aufruf ist Mean jetzt definiert. • Par l'appel Mean est défini maintenant.)
Remove[Mean](Damit Mean neu definiert werden kann, muss das alte erst gelöscht werden. • Pour redéfinir Mean, il faut d'abord effacer la vieille version)
<<Statistics`DescriptiveStatistics`?MeanMean[{1,2,3,4,5,6}]
Eine andere Art, ein Package zu laden:
• Une autre manière de charger un Package:
Needs["Graphics`Graphics`"]PieChart[{
{28,"Ingenieure"},
{21,"CMS"},
{20,"Wissensch."},
{12,"Math."},
{6,"Phys."},
{15,2"Andere"}
}];
Versuche Dich selbst im Laden von Packages mit Hilfe von Menu: ("Info", Open Function Browser" (old)) --> Help--Help.
• Essaie toi-même à charger des Packages à l'aide du menu: ("Info", Open Function Browser" (old)) --> Help--Help.
Remove["Global`@*"]
Finde alle Kommandos, die mit O beginnen ("Olga").
• Trouve tous les commandements qui commencent par O ("Olga").
?O*
Finde alle Kommandos, die das Teilwort "L i s t" enthalten.
• Trouve tous les commandements qui contiennent le mot (partie de mot) " L i s t".
?*List*
Teste alle Funktionen Deines Front-Ends.
• Examine toutes les fonctions de ton Front-End
Verwende "Alias[ ]", um die eingebaute Liste der Entsprechungen zu den Abkürzungen zu generieren.
• Utilise "Alias[ ]", por générer la liste incorporée contenant les correspondances des abréviations.
Alias[ ]
Werte die folgenden Ausdrücke aus:
•Evalue les expressions suivantes:
3 x + 7 x2 Meter + 13 Meter120 lbs (1 kg/(2.2 lbs))
Lade ("Graphics.m" (old)) "Graphics.nb" und mache ein Balkendiagramm, das Mathematica-Benützer auf Jobs aufgeteilt zeigt.
• Charge ("Graphics.m" (old)) "Graphics.nb" et fais un diagramme à barres qui divise les utilisateurs de Mathematica selon leurs emplois.
<< Graphics`Graphics`;
BarChart[{{31,"Research"},
{26,"Prof"},
{15,"Eng"},
{8,"Student"},
{13,"CS"},
{7,"Other"}}] Remove["Global`@*"]
Mathematica kennt ganze Zahlen (Integers), Fliesskommazahlen (mit Dezimalpunkt), rationale Zahlen, komplexe Zahlen sowie Zahlen, die durch Symbole gegeben sind (z.B. Pi).
• Mathematica connaît les nombres entiers (integers), les nombres avec virgule flottante (avec point décimal), les nombres rationaux, les nombres complexes ainsi que les nombres représentés par des symboles (p.ex. Pi).
Probiere aus: • Essaie:
53 + 78Multiplikation: • Multiplication:
127*9721127 9721Potenzieren: • Calculer les puissances:
![[Graphics:Images/AllFiles.HTML_gr_23.gif]](Images/AllFiles.HTML_gr_23.gif)
%^(1/56)Probiere aus: • Essaie:
2/4 + 24/1442 + 2/5Beispiel: Quadratwurzel • Exemple: racine carrée
Sqrt[17]Sqrt[17.0]Sqrt[17]Sqrt[17]//N
Falls irgendwo in einem Ausdruck ein Dezimalpunkt vorkommt, gilt der ganze Ausdruck als Fliesskommazahl.
• S'il y a quelque part dans une expression un point décimal, toute l'expression a la valeur d'un nombre à virgule flottante.
Probiere aus: • Essaie:
1/2 + 2.4/144.5/7 + Pi.5/7 + Pi // N
"I" bedeutet die imaginäre Einheit. "Re" erzeugt den Realanteil, "Im" den Imaginäranteil, "Abs" den absoluten Betrag, "Conjugate" das konjugiert Komplexe, "Round" rundet. Schaue, was Mathematica tut und überlege wieso das Resultat so aussieht:
• "I" signifie l'unité imaginaire. "Re" crée la partie réelle, "Im" la partie imaginaire, "Abs" la valeur absolue, "Conjugate" le complexe conjugé, "Round" arrondit. Observe ce que Mathematica fait et réfléchis pourquoi le résultat est ainsi:
(2 + 4I)/(5 + 2I)Re[3 + 4I]Im[3 + 4I]Conjugate[3 + 4I]Abs[3 + 4I]Round[2.7 - 8.6 I]Cos[3 + 4I] // NSin[3 + 4I] Exp[3 + 4I] // NLog[3 + 4I]
Für Mathematica ist ein Buchstabe oder eine Buchstabenfolge ein Symbol, z.B. eine Variable. Variablen können auch mit "$" beginnen. "7a" jedoch bedeutet "7 mal a". Probiere aus:
• Pour Mathematica une lettre ou une suite de lettres sont un symbole, p.ex. une variable. Les variables peuvent aussi commencer par "$". "7a" par contre signifie "7 fois a". Essaie:
7aa = 57a
In "Miscellaneus/Units.nb" sind Einheiten und Funktionen zur Einheitenverwandlung gespeichert:
• Dans "Miscellaneos/Units.nb" sont mémorisées les unités et les fonctions pour transformer les unités:
Needs["Miscellaneous`Units`"]120 PoundConvert[120 Pound, Kilogram]
Wichtige transzendente Zahlen sind als Symbole gespeichert.
Probiere aus:
• Les nombres transcendants importants sont mémorisés comme symboles.
Essaie:
EN[E]II^2DegreeN[Sin[Pi/4]]N[Sin[45 Degree]]
Mathematica kann weiter mit Listen (Vektoren, Matrizen, Tabellen etc rechnen). Der Themenkreis wird später behandelt.
• Mathematica sait aussi calculer avec des listes (vecteurs, matrices tableaux etc.) Cet ensemble de thèmes sera traité plus tard.
??List
Rationale Zahlen sind exakt gespeichert. "N" bedeutet approximieren. Probiere aus:
• Les nombres rationaux sont sauvés précisément. "N" signifie approximer. Essaie:
Sqrt[17]N[%]17^(1/2)% // N17^(0.5)N[Sqrt[17]]Sqrt[17] // NPrecision[%]
Wie gross ist also die Präzision? Die Präzision kann "beliebig" vergrðssert werden:
• Combien la précision est-elle grande? La précision peut être agrandie "autant qu'on veut":
N[Sqrt[17], 100]Wie gross ist hier die Präzision? • Combien la précision est-elle grande?
PiN[Pi]N[Pi,500]N[E,100]Probiere aus: • Essaie:
3/10 + 1/2Precision[%].36 + 1/3Precision[%]
Lasse Dir mit der Help-Funktion folgende Funktionen erklären:
• Fais-toi expliquer par la fonction Help les fonctions suivantes:
?Rationalize?Round?Chop?Floor?CeilingProbiere aus: • Essaie:
Rationalize[3.1416]Rationalize[3.1415926536]Rationalize[3.1415926536,0]Round[2.57432]Round[2,45892]Was war los ? • Que se passe-t-il?
Round[Sqrt[17]]Round[N[Sqrt[17]]]Chop[0.00000000002]Ceiling[3.4]Floor[3.4]
Man kann z.B. selbst eine Funktion definieren, die die auszugebenden Kommastellen festlegt:
• On peut définir soi-même par exemple une fonction qui détermine le nombre de places dernière la virgule à émettre:
n30[x_]:=N[x,30]Anwendung: • Application:
n30[5/7]N[5/7]
Es gibt aber auch die globale Variable "$Post", in die sich eine Funktion eingeben lässt. Diese Variable wird auf jeden auszugebenen Ausdruck angewandt:
• Mais il existe aussi la variable globale "$Post", dans laquelle on peut entrer une fonction. Cette variable est appliquée à chaque expression à émettre:
?$Post$Post=n30Sqrt[3]Precision[%]
Der Inhalt von $Post soll auch wieder gelöscht werden können. Das geschieht durch Eingabe des Zeichens für "missing value", nämlich "." :
• Il faut pouvoir aussi effacer le contenu de $Post. On peut faire cela en entrant le signe pour "missing value", c'est-à-dite "." :
$Post=.Sqrt[3]N[Sqrt[3]]N[Pi,25]N[%,200]
Wie genau ist also die übliche Präzision?
• Combien la précision courante est-elle exacte?
Mathematica bietet Möglichkeiten, die Zahlenausgabe zu formatieren. So lässt sich die Leserlichkeit verbessern. Probiere aus:
Mathematica offre la possibilité de formater la sortie de nombres. $Ainsi on peut améliorer la lisibilité. Essaie:
Options[NumberForm]1.23456789 10^20NumberForm[1.23456789 10^20,
ExponentStep -> 19,
NumberSigns -> {"-","+"}
]NumberForm[1.23456789 10^20,
ExponentStep -> 21,
NumberSigns -> {"-","+"}
]NumberForm[123456789 10^20,
ExponentStep -> 1000,
NumberSigns -> {"-","+"}
]
Falls Dir eine der folgenden Konstanten unbekannt ist, so schlage in deinem Formelbuch nach. Probiere aus:
• Si tu ne connais pas l'une des constantes suivantes, consulte ton manuel de formules. Essaie:
??Catalan?Degree?E?EulerGamma?GoldenRatio?I?PiPiNumberForm[N[Pi,45],
NumberSeparator -> " ",
DigitBlock -> 5
]Log[E]Cos[Pi/3]N[Sin[45 Degree]]avogadro = 6.02250 10^23Log[avogadro]
Mathematica besitzt die Funktion "Random", die gleichverteilte Pseudozufallszahlen generiert. Solche braucht man z.B. in der Statistik, um Testdaten zu erzeugen. Probiere aus:
• Mathematica possède la fonction "Random", qui génère des nombres pseudo-aléatoires en distribution homogène. On les emploie p.ex. dans la statistique, pour créer les données de test. Essaie:
Random[]Random[Integer]Random[Integer, {0, 100}]Random[Complex, {1 + 3I, 4 + 7I}]
Die Packages "ContinousDistributions.nb" und "DiscreteDistributions.nb" enthalten Definitionen, mit denen sich andere als gleichverteilte Pseudozufallszahlen erzeugen lassen. Probiere aus:
• Les Packages "ContinousDistributions.nb" et "DiscreteDistributions.nb" contiennent des définitions par lesquelles on peut générer des nombres pseudo-aléatoires autres que distribués homogènement. Essaie:
Needs["Statistics`ContinuousDistributions`"]Random[NormalDistribution[5]]
Der Pseudozufallszahlengenerator benutzt die Zeit seit dem Einschalten der Maschine als Variable zur Berechnung der Zahlen. Mit "SeedRandom" lässt sich der Generator wieder "zurücksetzen". Das kann benutzt werden, um mehrmals dieselben Zahlen zu generieren. Probiere aus:
• Le générateur des nombres pseudo-aléatoires utilise le laps de temps dès le démarrage de la machine comme variable pour calculer les nombres. Par "SeedRandom" on peut "remettre en arrière" le générateur. On employe cela pour générer plusieurs fois les mêmes nombres. Essaie:
??SeedRandomSeedRandom[2]{Random[], Random[]}SeedRandom[2]{Random[], Random[]}
Mathematica stellt iterative Funktionen (Iteratoren) zur Verfügung, um die Eingabe
wiederholter Rechnungen abzukürzen. Einige sind hier gezeigt. Probiere aus:
• Mathematica met à disposition des fonctions itératives pour abréger l'entrée de calculs répétés. Voici quelques-uns. Essaie:
??TableTable[x, {5}]??ProductProduct[x + k y, {k, 4}]??DoDo[Print["k: ", k], {k, 7, 9}]??TableFormTableForm[Table[{k, 10^(-k), Chop[N[10^(-k)]]}, {k, 7, 14}]]??SumSum[i x^i, {i, 3, 23, 5}]Probiere aus: • Essaie:
??MatrixForm??Inverse??Det??Eigenvalues??Eigenvectors??LinearSolve??NullSpace??RowReduce??Transpose??IdentityMatrixm1 = {{1, 2},{3, 4}}Transpose[m1] // MatrixFormMatrixForm[m1]MatrixForm[{{1, 2},{3, 4}}]m2 = {{0, -1},{8, -6}}m3 = {{0, -1},{8, -6}} // MatrixForm
Das Matrixprodukt wird mit einem gewöhnlichen Punkt geschrieben. Probiere aus:
• Le produit de matrices s'écrit avec un simple point. Essaie:
m1.m2 // MatrixFormm1.m3
Elementweise Multiplikation. Probiere aus:
• Multiplication par élément. Essaie:
m1 m2 // MatrixFormProbiere aus: • Essaie:
?NullSpacem4 = {{1,2,3},{1,2,3},{0,0,1}}NullSpace[m4]?RowReduceRowReduce[m4] // MatrixFormEigenvectors[m1]Transpose[m1] // MatrixFormm = Table[Random[], {3}, {3}]MatrixForm[m]mInv = Inverse[m]MatrixForm[%]m.mInvMatrixForm[%]Chop[%]MatrixForm[%]IdentityMatrix[7] // MatrixFormProbiere aus: • Essaie:
??Solve??NRoots??FindRootSolve[{2x - 3y ==8, 4x + y == 6},{x, y}]Solve[m1.{{x},{y}}=={{2},{5}}, {x, y,}]NRoots[x^4 +3 x^2 + 5x == 7, x]
FindRoot benutzt die Newton-Methode. Darin wird die Ableitung benutzt:
• FindRoot emploie la méthode de Newton. On y employe la déduction:
FindRoot[Sin[x]/x == 0, {x, 2}]Bessel-Funktionen: • Fonctions de Bessel
Plot[BesselJ[0, x], {x, 0, 12}];FindRoot[BesselJ[0, x]/x == 0, {x, 12}]FindRoot[BesselJ[0, x]/x, {x, 12}]FindRoot[BesselJ[0, x]/x, {x, 7}]Plot[BesselJ[0, x], {x, 0, 15}];
FindRoot benutzt die Newton-Methode. Darin wird die Ableitung benutzt. Hier ein Plot der Ableitung obiger Bessel-Funktion. (Beachte, dass die Ableitung bei x = 7 klein ist.)
• FindRoot emploie la méthode de Newton. On y employe la déduction. Voici un plot de la déduction de la fonction de Bessel ci-dessus. (Remarque que la déduction est petite pour x = 7.)
Plot[-BesselJ[1, x], {x, 0, 15}];Probiere aus: • Essaie:
??NIntegrateNIntegrate[Sin[x^2]/x^2, {x, 0, 1}]Plot[Sin[x^2]/x^2, {x, 0, 1}];NIntegrate[Sin[Sin[Cos[x^10]]], {x, 0, 1}]??NSumNSum[(n^2 - n + 1) Log[n]/n^3, {n, 1, 100}] ??NProductNProduct[(1 + 1/n)^n, {n, 1, 100}]Limit[(1 + 1/n)^n, n->Infinity]Probiere aus: • Essaie:
??NDSolveNDSolve[{y''[x] - y'[x] + x y[x] == 0, y'[0] == -1, y[0] == 1},
y, {x, 0, 5}]Plot[y[x] /. %, {x, 0, 5}];Remove["Global`@*"]
Berechne die Anzahl Minuten in einem Jahr mit 365 Tagen.
• Calcule le nombre de minutes pour une année de 365 jours.
365 Tag (24 Std/Tag) (60 Min/Std)
Berechne Pi auf 770 Stellen. Findest Du 6 sich folgende Ziffern 9?
• Calcule Pi sur 770 places. Trouves-tu 6 fois de suite le chiffre 9?
N[Pi,770]
Wie nahe ist e hoch (Pi mal Wurzel aus 163) bei einer ganzen Zahl?
• Combien près d'un nombre entiers se trouve e puissance (Pi fois racine de 163)?
N[E^(Pi 163^(1/2)),100]-Ceiling[N[E^(Pi 163^(1/2)),100]]N[E^(Pi 163^(1/2)),100]-Floor[N[E^(Pi 163^(1/2)),100]]
Verwende NumberForm um die Zahl 123456789 in 3-er-Blöcken auszugeben.
• Sers-toi de NumberForm pour sortir le nombre 123456789 en blocs de 3 chiffres.
NumberForm[123456789, DigitBlock->3]
Generiere mit Hilfe von Random zwei Pseudozufallszahlen und addiere diese.
• Générer à l'aide de Random deux nombres pseudo-aléatoires et fais-en l'addition
a=Random[];b=Random[];a+b
Schaue, was Mathematica tut, und überlege wieso das Resultat so aussieht:
• Observe ce que fait Mathematica et réfléchis pourquoi le résultat est ainsi:
Sqrt[3] + 3Exp[2 Pi I]5 > 3Pi^E > E ^ PiN[Pi^E > E ^ Pi]
Studiere die folgenden Befehle:
• Etudie les ordres suivants:
??Table??Sum??Product
Kreiere eine Liste mit 50 Ziffern 9.
• Crée une liste avec 50 fois le chiffre 9.
Table[9,{50}]
Kreiere eine Liste mit den ersten 24 Quadratzahlen.
• Crée une liste avec les 24 premiers nombres carrés.
Table[i^2,{i,24}]
Zeige mit Sum, dass 100 * 101/2 die Summe der ersten 100 natürlichen Zahlen ist.
• Montre par Sum que 100 * 101/2 est la somme des 100 premiers nombres naturels.
s = Sum[i,{i,100}] p = 100 101 / 2s == p
Berechne 1+1/1!+.....+1/10!
• Calcule 1+1/1!+.....+1/10!
Sum[1/(n!),{n,0,10}]
Berechne 6! mit "Product".
• Calcule 6! avec "Product".
Product[n,{n,1,6}]6!
Berechne die Inverse der 3*3-Hilbert-Matrix. ((i,j) = 1/(i+j-1).)
• Calcule l'inverse de la matrice de Hilbert 3*3. ((i,j) = 1/(i+j-1).)
h = Table[1/(i+j-1),{i,3},{j,3}]; MatrixForm[h]MatrixForm[Inverse[h]]
Berechne eine numerische Approximation von Pi durch Integration der Funktion
4/(1+x^2) im Intervall [0,1]
• Calcule une approximation numérique de Pi en intégrant la fonction 4/(1+x^2) dans l'intervalle [0,1]
f[x_]:=4/(1+x^2); f[x]Integrate[f[x],x]Integrate[f[x],{x,0,1}]NIntegrate[f[x],{x,0,1}]x^5+5x^4+4x^3+3x^2+2x+1=0
NRoots[x^5+5x^4+4x^3+3x^2+2x+1==0,x]sin^2(Pi x) - x^2 cos(Pi x) = x
Table[FindRoot[Sin[Pi x]^2 - x^2 Cos[Pi x] == x,
{x,x0}],{x0,-5,5}]x tan(x) = 1
Table[FindRoot[x Tan[x] == 1,
{x,x0}],{x0,13}]Remove["Global`@*"]
Mathematica kann algebraische Ausdrücke manipulieren.
• Mathematica peut manipuler les expressions algébriques
?Apart?Cancel?Collect?Expand?ExpandAll?ExpandDenominator?ExpandNumerator?Factor?Simplify?Short?Together?TrigExpandNeeds["Algebra`Trigonometry`"]?TrigExpand?TrigFactor?TrigReduce?ComplexToTrig?TrigToComplex?SumSum[i^2,{i, n}]Needs["Algebra`GosperSum`"]?GosperSum
Was in alten Versionen einmal existiert hat, braucht in neuen nicht mehr zu existieren...
• Ce qui existait dans de vieilles versions, n'existe pas forcement dans des versions nouvelles.
$Version (*Mathematica-Version*)?$VersionNeeds["Algebra`SymbolicSum`"]Sum[i^2,{i, n}]?Limit?Integrate?Series?DSolve??DSolve
Ueberlege Dir, was durch die folgenden Operationen bewirkt wird!
• Réfléchis à ce qui se produit par les opérations suivantes!
Expand[(x + 2y + z)^4]Factor[%]Factor[6x^3 + 35 x^2 y + 58 x y^2 + 21 y^3]
NRoots rechnet eine Näherung. "||" bedeutet dabei das logische "oder", "or".
• NRoots calcule une approximation. "||" signifie le "ou" logique.
NRoots[x^3 - 3 x^2 - 17 x + 51 == 0, x]
"||" ist das logische "oder".
• "||" est le "ou" logique.
??||
Gewisse algebraische Gleichungen oder Gleichungssysteme kann man jedoch exakt lösen. Dies geschieht mit "Solve".
• On peut résoudre exactement certaines équations algébriques ou certains systèmes d'équations. Cela avec "Solve".
Solve[x^3 - 3 x^2 - 17 x + 51 == 0, x]Angenähert: • Approximé
% // N
Uebersichtlicher dargestellt:
• Représenté d'une façon plus claire:
ColumnForm[Solve[{ x y + 5x + 6y == 7,
x^2 + 5x + 7y == 8}]]
Der Output besteht aus einer Menge von Ersetzungsregeln.
Wie lässt sich damit weiterrechnen?
• L'output est composé d'une quantité de règles de remplacement. Comment continue-t-on de calculer avec cela?
"/." bedeutet "ersetze jedes" resp. "ReplaceAll".
• "/." signifie "remplace tout" resp. "Remplace All".
?/.?ReplaceAll?Replace
Studiere die folgenden Anwendungen:
• Etudie les applications suivantes:
a = x /. x -> 7axWeiter: • Ensuite:
x + 5y /. {x -> 1, y -> 2/7}x + 5yWeiter: • Encore:
Solve[2 x^5 + 12 x^2 + 18x - 14 == 0]
Die Lösung hier ist nur symbolisch. Eine allgemeine algebraisch exakte Lösungsformel
für Gleichungen mit Polynomen 5. Grades existiert nicht. Approximativ allerdings geht es:
• La solution n'est que symbolique. Une forme de solution algébrique générale exacte pour les équations avec polynômes du 5e degré n'existe pas. Mais une approximation est possible (existe):
N[%]
Mathematica kann nicht die Frage beantworten, welche Outputform eines Ausdrucks für den Verwender der einfachste ist. Man muss den Ausdruck selbst in die gewünschte Form bringen. Dafür gibt es Hilfsmittel wie z.B. "Simplify":
• Mathematica ne sait pas répondre à la question, laquelle des formes de l'Output d'une expression est la plus simple pour l'utilisateur. Il faut donner soi-même la forme souhaitée à l'expression. Pour cela il y a des moyens tels que p.ex. "Simplyfy".
Solve[(a d x^3 + 14 b d x^2 + 14^2 c d x)
== 0, x] (14b + 14a)/(-c + b)Simplify[%]??Simplifyx/((x+2)(x-2))Simplify[%]x/Expand[((x+2)(x-2))]Expand[x/((x+2)(x-2))]x/Simplify[((x+2)(x-2))]
Beispiel: Partialbruchzerlegung mit "Apart". Probiere aus.:
• Exemple: Décomposition de fractions partielles en utilisant "Apart":
x/((x+2)(x-2))Apart[%]Retour: • Retour:
Together[%]
Man beachte die Reihenfolge der Terme im Output. Zuerst Konstanten, dann Symbole, alphabetisch, Terme nach steigendem Grad etc.:
• Il faut tenir compte des termes dans le output. D'abort les constantes, puis les symboles, en ordre alphabétique, termes selon le dégré en augmentant etc.:
Expand[(1 + 2y + 3z)^3]Umordnen: • Réordonner:
Collect[%, y]Expand[Sin[x]/Cos[x]]Expand[(Sin[x]+Cos[x])/Sin[x] (Sin[x]^2 + Cos[x]^2), Trig -> False]?TrigExpand[(Sin[x]+Cos[x])/Sin[x] (Sin[x]^2 + Cos[x]^2), Trig -> True]Needs["Algebra`Trigonometry`"]TrigToComplex[Sin[x]]
Mathematica bietet die Möglichkeit, Resultate abzukürzen:
• Mathematica offre la possibilité d'abréger les résultats:
Short[Expand[(x + 2y + 3z)^9]]?Short
Mit der globalen Variablen "$PrePrint" lässt sich das Abkürzen der Ausgabe generalisieren:
• Avec la variable globale "$PrePrint" on peut généralement abréger la sortie:
$PrePrint = ShortExpand[(x + 2y + 3z)^9]Expand[(x + 2y + 3z)^11]Expand[(x + 2y + 3z)^5]
Trotzdem kann man das ganze Resultat abrufen mit "Print":
• En tout cas on peut appeler le résultat entier avec "Print":
Print[%]Alter Zustand: • Ancien état:
$PrePrint = .Expand[(x + 2y + 3z)^9]
Mathematica bietet die Möglichkeit, z.B. Summen mit variablem oberen
Summationsindex zu berechnen:
• Mathematica offre la possibilité p.ex. de calculer des sommes avec un index de sommation supérieur variable:
Needs["Algebra`SymbolicSum`"]Sum[i^3,{i, n}]
Probiere eigene Aufgaben aus:
• Essaie des problèmes que tu inventes toi-même:
Beispiele: • Exemple:
Integrate[Cos[x], x]Integrate[x^4 Cos[x], x]1/(2 + 3 x^2)^3Integrate[1/(2 + 3 x^2)^3, x]
Kontrolle: Differenzieren!
• Contrôle: Différencier!
D[%, x]
Das Resultat kann durchaus anders aussehen. Es muss vielleicht umgeformt werden.
• Le résultat peut être différent. Il faut peut-être le transformer.
Simplify[%]
Mathematica kann bestimmte Integrale exakt rechnen. Probiere aus:
• Mathematica sait calculer exactement des intégrales déterminées. Essaie:
?Integrate?*Integ*Integrate[Exp[x],{x, -1, 1}]N[%]
Numerisch geht es natürlich auch. Probiere aus:
• Il va de soi qu'on peut le faire numériquement. Essaie:
NIntegrate[Exp[x],{x, -1, 1}]
Zu gewissen Funktionen kann keine einfache Stammfunktion gefunden werden:
• Pour certaines fonctions on ne trouve pas de fonction primitive (intégrale) simple:
Integrate[Sin[Sin[x]],{x, 0, 1}]
Numerisch geht es natürlich. Probiere aus:
• Numériquement ça va. Essaie:
NIntegrate[Sin[Sin[x]],{x, 0, 1}]
Bei Funktionen mit Polen können Fehler auftreten, wenn man einfach eine Stammfunktion bestimmt und die Grenzen einsetzt. Prüfe:
• Lors de fonctions avec pôles, des erreurs peuvent appataître, si on détermine simplement une fonction primitive (intégrale) et fixe les limites. Examine:
Integrate[1/(x-Pi/100)^2,{x, -1, 1}]Plot[1/(x-Pi/100)^2,{x, -1, 1}];NIntegrate[1/(x-Pi/100)^2,{x, -1, 1}]Integrate[1/x^2,{x, -1, 1}]NIntegrate[1/x^2,{x, -1, 1}]??NIntegrate
Es kann z.B. angegeben werden, dass bei 0 eine Singularität (Polstelle) ist. Prüfe:
• On peut indiquer p.ex. qu'il y a une singularité (pôle) près de 0. Examine:
NIntegrate[1/x^2,{x, -1, 0, 1}]
f(x, y) kann über x und y integriert werden. Probiere:
• f(x, y) peut être intégré sur x et y. Essaie:
Integrate[x^2 Sin[y],x, y]
Bei bestimmten Integralen sind die äusseren Grenzen zuerst anzugeben:
• Pour certains intégrales les limites extérieurs doivent êtres données d'abort.
Integrate[x^2 Sin[y],{x, 0, Pi/3}, {y, 0, x}]
Mit "Limits" lassen sich Grenzwerte berechnen. "Unendlich" ist "Infinity":
• Avec "Limits" on peut calculer des valeurs limites. "Infinie" est "Infinity":
?Limit?InfinityLimit[Sin[x]/x, x -> 0]Limit[1/x, x -> 0]
Der Wert des Grenzwerts kann davon abhängen, aus welcher Richtung man sich dem problematischen Punkt nähert. Die Richtung kann angegeben werden:
• La valeur de la valeur limite peut dépendre de la direction de laquelle on s'approche du point problématique.
Limit[1/x, x -> 0, Direction -> 1]Limit[1/x, x -> 0, Direction -> -1]Integrate[E^(-s t) t^n,{t,0,Infinity}]Integrate[E^(-s t) Sin[w t],{t,0,Infinity}]
Beispiele von Potenzreihenentwicklungen:
• Exemples de développements de séries de puissances:
Series[f[x],{x,0,9}]Series[f[x],{x,1,6}]Series[E^x,{x,0,9}]Series[Cos[x],{x,0,9}]
Solch ein Output ist noch kein algebraischer Ausdruck, mit dem weitergerechnet werden
kann, denn die angegebene Ordnung der nachfolgenden Glieder ist kein Term. Mit "Normal" kann diese Angabe entfernt werden. Probiere:
Un tel Output n'est pas encore une expression algébrique, avec laquelle on peut continuer de calculer, car l'ordre donné des membres suivants n'est pas un terme. On peut effacer ce problème par "Normal". Essaie:
a = Normal[Series[E^x,{x,0,9}]]b = Normal[Series[Cos[x],{x,0,9}]]b = Normal[Series[Cos[x],{x,0,9}]]b /. x->1a + bEtwas fürs Auge: • Quelque chose pour l'oeil:
Clear[a]prCos[x_]:= Normal[Series[Cos[x],{x,0,11}]];
p = prCos[x]Plot[{p, Cos[x]}, {x, 0, 2 Pi}];a = Append[Evaluate[Table[Normal[Series[Cos[x],{x,0,n}]],{n, 12}]],
Cos[x]]Plot[Evaluate[Table[a[[i]],{i,13}]], {x, 0, 2 Pi}];??Append
Mathematica kann gewisse einfache Differentialgleichungen exakt lösen. Probiere:
• Mathematica peut résoudre avec exactitude certaines équations différentielles. Essaie:
?DSolveDSolve[y''[x] + y'[x] + y[x] == 0, y[x], x]
"C[..]" bedeutet eine Konstante. Auch Systeme können behandelt werden. Probiere:
• "C[..]" signifie une constante. On peut aussi traiter des systèmes. Essaie:
d = DSolve[{y'[x] + y[x] == 0, y[2] == 2}, y[x], x]dd =Flatten[d][[1]]ddd = dd[[2]]Plot[ddd, {x, -3, 3}];
Aufgabe:Behandle das System {r y'[x] + y[x] == 0, y[2] == 2} für
r = -3, -2, -1, 0, 1, 2, 3 und vergleiche die Graphen.
• Problème: Traite le système {r y'[x] + y[x] == 0, y[2] == 2} pour
r = -3, -2, -1, 0, 1, 2, 3 et compare les graphes.
Remove["Global`@*"]Löse folgende Gleichung: • Résous l'équation suivante:
Solve[x^2 + 2x + 1 == 0]Löse folgende Gleichung: • Résous l'équation suivante:
Solve[ax^2 + bx + c == 0,x]Löse folgende Gleichung: • Résous l'équation suivante:
Solve[{x + y== 5, 2x + 6y == 23}]
Faktorisiere das Polynom 1-x^n. Entdeckst Du ein Gesetz?
• Factorise le pôlynome 1-x^n. Découvres-tu une loi?
Do[Print[1 - x^n,"==",Factor[1 - x^n]],{n, 2, 9}]
Faktorisiere das Polynom 1-x^11
• Factorise le pôlynome 1-x^11.
Factor[1 - x^11]
Faktorisiere das Polynom 1-x^...... (Zahl einsetzen!)
• Factorise le pôlynome 1-x^...... (Mettez un nombre!)
Factor[1 - x^13]
Mache mit "Apart" eine Partialbruchzerlegung:
• Fais avec "Apart" une décomposition d'une fraction rationelle en éléments simples:
Apart[x/(x^2 + 5x + 6)]
Mache mit "Apart" eine Partialbruchzerlegung:
• Fais avec "Apart" une décomposition d'une fraction rationelle en éléments simples:
Apart[(2x + 7)/(x^3 + 3x^2 + 3x + 1)]
Vereinfachung trigonometrischer Funktionen: Setzt Trig->True:
• Simplifications de fonctions trigonométriques: Mettez Trig->True:
Expand[Cos[x] Cos[y] + Sin[x] Sin[y],Trig->True]Factor[Cos[x] Cos[y] + Sin[x] Sin[y],Trig->True]
Vereinfachung trigonometrischer Funktionen: Setzt Trig->True:
• Simplifications de fonctions trigonométriques: Mettez Trig->True:
Expand[Cos[x] Sin[y] + Sin[x] Cos[y],Trig->True]Expand[Cos[x] Sin[y] + Sin[x] Cos[y],Trig->True]
Vereinfachung von Exponentialfunktionen: Setzt Trig->True:
• Simplifications de fonctions exponentielles: Mettez Trig->True:
Expand[E^(-I x) + E^(I x),Trig->True]Factor[E^(-I x) + E^(I x),Trig->True]
Generiere mit "Array" eine 2 x 2-Matrix mit den Elementen b[i, j]:
• Génère avec "Array" une matrice 2 x 2 avec les éléments b[i, j]:
Clear[b]; m = Array[b,{2,2}]
Invertiere und Transponiere m:
• Invertis et transforme m:
Inverse[m]Transpose[m]
Generiere mit "Array" eine 2 x 2-Matrix mit den Elementen c[i, j]:
• Génère avec "Array" une matrice 2 x 2 avec les éléments c[i, j]:
Clear[c]; n = Array[c,{2,2}]MatrixForm[n]
Berechne m n und m.n . Was ist der Unterschied?
• Calcule m n et m.n . Quelle est la différence?
m nm.nMatrixForm[m n]MatrixForm[m.n]
Integration eines Ausdrucks:
• Intégration d'une expression:
w = 1/(x^3 + 1)u = Integrate[1/(x^3 + 1),x]
Differenziere das Resultat:
• Différencie le résultat:
v = D[%,x]
Hat man nun wieder den ursprünglichen Ausdruck?
• A-t-on de nouveau l'expression d'origine?
Together[v]v=ExpandAll[Together[v]]w === v
Exakter Wert eines Integrals :
• Valeur exacte d'une intégrale:
Integrate[x y^2,{x,0,1},{y,0,Sqrt[1-x]}]
Exakter Wert eines Integrals :
• Valeur exacte d'une intégrale:
Integrate[y Exp[x^2],{x,0,1},{y,0,Sqrt[x]}]Series[E^x ,{x, 0, 12}]Series[1/(1 - x),{x, 0, 8}]Series[1/(1 - x)^2, {x, 0, 10}]Series[f[x], {x, 0, 10}]Series[1/(1 + x) ,{x, 0, 7}]Series[1/(1 - 2x),{x, 0, 8}](1+ 2x + 3x^2) Series[1/(1 - x^3), {x, 0, 8}]
Probleme mit Integration:
• Problème d'intégration
Integrate[1/(1 + Sin[x]^2 Sqrt[Pi^2 + x]),{x,-2,2}]
Näherung durch Integration einer Potenzreihe:
• Approximation par l'intégration d'une série de puissances:
Clear[s];
s = Series[1/(1 + Sin[x]^2 Sqrt[Pi^2 + x]),{x,0,8}]
Verwandlung in einen verwertbaren Ausdruck (O[...] weglassen)
• Transformation en une expression utilisable (omettre O[...])
sn = Normal[s]
Jetzt kann man integrieren:
• Maintenant on peut intégrer:
Integrate[sn,{x,-2,2}]Numerisch: • Numériquement:
N[%]DSolve[y'[x] - y[x] Tan[x]== x, y[x], x]DSolve[y'[x] + y[x] Tan[x]== Sec[x], y[x], x]Clear[y];
DSolve[{y'[x] == y[x] , y'[0] == 1}, y[x], x]DSolve[y''''[x] - k^4 y[x] == 0, y[x], x]DSolve[y'[x] y[x] + x^2 == x, y[x], x]Remove["Global`@*"]
Gewöhnliche Funktion über einem Intervall. ";" unterdrückt den letzten Output:
• Fonction commune sur un intervalle. ";" empêche le dernier output.
Plot[x^2 + 5x + 6,{x, -10, 5}];Plot[x^2 + 5x + 6,{x, -10, 5}]y = x^2 + 5x + 6;
Plot[y,{x, -10, 5}];
Pole bieten keine Probleme:
• Les pôles ne causent pas de problèmes:
Plot[Tan[x],{x, 0, 10}];
Vielleicht wird etwas abgeschnitten:
• Mathematica coupe peut-être quelque chose:
Plot[Sin[x]/x,{x, -20, 20}];
Ein Plot kann auf diverse Weise durch Angabe der Options verändert werden:
• Un plot peut être transformé de différentes façons en indiquant les options:
??PlotOptions[Plot]
Beispiel mit dem y-Intervall:
• Exemple avec l'intervalle y:
Plot[Sin[x]/x,{x, -20, 20}, PlotRange -> {0, 1}];Plot[Sin[x]/x,{x, -20, 20}, PlotRange -> All];
Vielleicht wird trotzdem "etwas" abgeschnitten...:
• Peut-être Mathematica coupe quand-même "quelque chose"...:
Plot[Cot[x],{x, 1, 10}, PlotRange -> All];Plot[Cot[x],{x, 0, 10}, PlotRange -> All];Plot[Cot[x],{x, -10, 10}, PlotRange -> All];Options[Plot]AspectRatio /. Options[Plot]??AspectRatioPlotPoints /. Options[Plot]
Der Output kann unterdrückt werden:
• On peut réprimer l'output.
test = Plot[Sin[x],{x, 0, 2 Pi},
DisplayFunction -> Identity];
Hier eine Zeichnung, die zeigt, in welchen Abständen Mathematica die Funktionswerte berechnet:
• Voici un dessin qui montre à quelles distances Mathematica calcule les valeurs des fonctions:
Show[Graphics[{Thickness[0.001], Map[Line[{{#[[1]],
0},#}]&, Nest[First, test, 4]]}],
Axes->Automatic];
Was tun die einzelnen Befehle?
• Que fait chaque ordre?
test??NestNest[First, test, 4]Nest[First, test, 5]Nest[First, test, 3]Nest[First, test, 2]Nest[First, test, 1]First[test]Map[Line[{{#[[1]],0},#}]&, Nest[First, test, 4]]Graphics[{Thickness[0.001],
Map[Line[{{#[[1]],0},#}]&,
Nest[First, test, 4]]}]Show[Graphics[{Thickness[0.001],
Map[Line[{{#[[1]],0},#}]&,
Nest[First, test, 4]]}], Axes->Automatic];
Kann das stimmen?
• Est-ce correct?
Plot[x + Sin[2 Pi x], {x, 0, 24}];
Andere Anzahl Punkte:
• Autre nombre ce points:
Plot[x + Sin[2 Pi x], {x, 0, 24}, PlotPoints -> 20];Plot[x + Sin[2 Pi x], {x, 0, 24}, PlotPoints -> 50];
Welche Punkte rechnet Mathematica?
• Quels points sont calculés par Mathematica?
Table[{x, x + Sin[2 Pi x]}, {x, 0, 24}]
Liniendicke, Graustufe, Farbe, Linienart, etc. können angepasst werden:
• Epaisseur de la ligne, nuance de gris, couleur, type de ligne etc. peuvent être adaptés:
Options[Plot]??PlotStyle??GraphicsPlotStyle /. Options[Plot]Probiere aus: • Essaie:
Plot[x, {x, 0, 10}, PlotStyle -> Thickness[0.125]];Plot[x, {x, 0, 10}, PlotStyle -> Thickness[0.03]];Plot[x, {x, 0, 10}, PlotStyle -> RGBColor[0.8,
0.2, 0.2]];Plot[x, {x, 0, 10}, PlotStyle -> GrayLevel[0.5]];Plot[x, {x, 0, 10}, PlotStyle -> Dashing[{0.04}]];Plot[Sin[x], {x, 0, 10}, PlotStyle -> {{Thickness[
0.02], GrayLevel[0.7], Dashing[{0.1}]}}];
Man kann auch eine Menge von Funktionen auf einmal ausgeben:
• On peut aussi sortir un ensemble de fonctions à la fois:
Plot[{E^x, x^E}, {x, 0, 5}];
Da es manchmal schwierig ist, die Kurven zu unterscheiden, ist es angebracht, diese verschieden darzustellen:
• Comme il est parfois difficile de distinguer les courbes, il est préférable de les représenter de différentes façons:
Plot[{E^x, x^E}, {x, 0, 5}, PlotStyle -> {
{Thickness[0.02], Dashing[{0.05, 0.03}]},
{Thickness[0.01]} } ];Plot[Evaluate[Table[x^(1/n), {n,5}]], {x, 0, 5}];Evaluate[Table[x^(1/n), {n,5}]]Table[x^(1/n), {n,5}]
"Evaluate" steuert die Operationshierarchie. Bevor die Plotpunkte berechnet werden können, muss die Tabelle generiert werden! Versuche Dich nun in eigenen Plots!
• "Evaluate" dirige la hiérarchie des opérations. Avant de pouvoir calculer les points "plot", il faut générer le tableau! Essaie des plots à toi!
In einem kartesischen Koordinatensystem in der Ebene kann eine Kurve durch einen Vektor gegeben werden, der von einer Variable (Parameter) abhängt. Beispiel:
• Dans un système de coordonnés cartésien, dans le plan, une courbe peut être donnée par un vecteur qui dépend d'une variable (paramètre). Exemple:
v[t_]:= {4 Cos[-11 t/4] + 7 Cos[t], 4 Sin[-11 t/4]
+ 7 Sin[t]}; v[t]ParametricPlot[v[t], {t, 0, 8 Pi}];ParametricPlot[{4 Cos[-11 t/4] + 7 Cos[t],
4 Sin[-11 t/4] + 7 Sin[t]},
{t, 0, 8 Pi}];ParametricPlot[{4 Cos[-11 t/4] + 7 Cos[t],
4 Sin[-11 t/4] + 7 Sin[t]},
{t, 0, 8 Pi}, Axes -> None];
Das Achsenverhältnis:
• Rapport axial:
AspectRatio /. Options[Plot]ParametricPlot[{4 Cos[-11 t/4] + 7 Cos[t],
4 Sin[-11 t/4] + 7 Sin[t]},
{t, 0, 8 Pi}, Axes -> None,
AspectRatio -> Automatic];ParametricPlot[{Cos[t], Sin[t]}, {t, 0, 2 Pi},
AspectRatio -> 1];
Man beachte den Massstab:
• Tenir compte de l'échelle:
ParametricPlot[{Cos[t], 5 Sin[t]}, {t, 0, 2 Pi},
AspectRatio -> 1];ParametricPlot[{Cos[t], 5 Sin[t]}, {t, 0, 2 Pi},
AspectRatio -> 5];ParametricPlot[{Cos[t], 5 Sin[t]}, {t, 0, 2 Pi},
AspectRatio -> 1/5];
Z.B. ein Gitter:
• P. ex. une grille:
Plot[E^-x^2 Cos[20x], {x,-2,2},
GridLines -> Automatic];
Oder ein Rahmen:
• Ou un cadre:
Plot[E^-x^2 Cos[20x], {x,-2,2}, Frame -> True];Plot[BesselJ[0, x], {x, 0, 20}, Frame -> True];
Probiere aus! (Hier werden die Achsen beschriftet):
• Essaie! (Ici on met une inscription sur les axes:)
Plot3D[Sin[x y],{x, 0, Pi}, {y, 0, 2 Pi},
AxesLabel -> {"x", "y", "z"}];Show[%, ViewPoint->{1.050, 1.910, 2.440}];
Im Menu unter ("Action", "Prepare Input") neu: "Input", "3D ViewPoint Selector" findest Du eine Hilfe, um den Blickpunkt zu verändern. Du kannst da schieben und dann z.B. die Insert-Taste (Copy-Paste) betätigen, nachdem allerdings der Cursor in einer neuen Zelle parkiert worden ist. Du bekommst dann ein lauffähiges Programm. Probiere die Sache aus!
• Tu trouves dans le menu sous ("Action", "Prepare Input") nouveau: "Input", "3D ViewPoint Selector" une aide pour changer le point de vue. Là tu peux déplacer et ensuite p.ex. appuyer sur la touche insert, après avoir note bien parqué le curseur dans une nouvelle cellule. Tu obtiendras un programme qui fonctionne. Essaie-le!
Probiere aus: • Essaie!
Options[Plot3D]LightSources /. Options[Plot3D]Lighting /. Options[Plot3D]Probiere aus: • Essaie!
??SetOptionsSetOptions[Plot3D, Lighting -> False]Plot3D[Sin[x y],{x, 0, Pi}, {y, 0, 2 Pi}];
Oder auf einmal:
• Ou à la fois:
Plot3D[Sin[x y],{x, 0, Pi}, {y, 0, 2 Pi},
Lighting -> False];
Plot3D[Sin[x y],{x, 0, Pi}, {y, 0, 2 Pi},
Lighting -> True];
Probiere die Options ein wenig aus!
• Essaie un peu les options!
?ClipFillPlot3D[1/Sin[x y],{x, 0.1, Pi-0.1}, {y, 0.1, 2 Pi},
ClipFill -> None];Plot3D[1/Sin[x y],{x, 0.1, Pi-0.1}, {y, 0.1, 2 Pi},
BoxRatios -> {1,2,4}];
Z.B. mit "ListPlot" und "ListPlot3D"
• P.ex. avec "ListPlot" et "ListPlot3D"
??ListPlot??ListPlot3D
Erst Daten generieren:
• D'abort générer des données:
data = N[Table[{x, Sin[x] + x + 0.5 Random[]},
{x, 0, 5 Pi, Pi/8}]]
Dann Daten ploten:
• Ensuite "ploter" les données:
dataplot = ListPlot[data];
Polynom durch diese Punkte als Funktion von x:
Polynôme à travers ces points comme une fonction de x:
??InterpolatingPolynomialInterpolatingPolynomial[data,x]Chop[InterpolatingPolynomial[data,x]]interplot = Plot[Evaluate[
InterpolatingPolynomial[data,x]],{x,3,12}];Plot[Evaluate[
InterpolatingPolynomial[data,x]],{x,0,20}];Show[dataplot, interplot];
Arbeiten mit "Fit":
• Travailler avec "Fit":
??Fit
Gerade durch die Punktwolke:
• En ligne droite à travers le nuage de points:
trent = Fit[data, {1, x}, x]trentplot1 = Plot[trent,{x,0,15}];Show[trentplot1, dataplot];
Polynomkurve 6. Grades durch die Punktwolke:
• Courbe polynomiale de 6e degré à travers le nuage de points:
trent6 = Fit[data, {1, x, x^2, x^3, x^4,
x^5, x^6}, x]trentplot6 = Plot[trent6,{x,0,15}];Show[trentplot6, dataplot];
Kurve als Ueberlagerung von Gerade und Cosinus- sowie
Sinusfunktion durch die Punktwolke:
• Courbe comme superposition d'une droite et d'une fonction cosinus ainsi que sinus à travers le nuage de points:
trentcc = Fit[data, {1, x, Cos[x], Sin[x]}, x]trentplotcc = Plot[trentcc,{x,0,15}];Show[trentplotcc, trentplot, dataplot];Optionen: • Options:
dataplot1 = ListPlot[data, PlotStyle->{PointSize[0.02],
GrayLevel[0.2]}];
Punkte verbinden:
• Relier les points:
dataplot2 = ListPlot[data, PlotJoined->True];
ListPlot kann auf einmal nur eine Datenmenge ploten, jedoch kann man solche Plots überlagern:
• ListPlot ne peut "ploter" qu'un ensemble de données à la fois, on peut cependant superposer de tels plots:
data1 = N[Table[{x, 1 + Cos[x] + 0.5 x +
0.5 Random[]}, {x, 0, 5 Pi, Pi/8}]];
dataplot3 = ListPlot[data1,
PlotStyle->{PointSize[0.014]}];Show[dataplot1,dataplot3];
Studiere: Zuerst Daten generieren (Tabelle mit 3 Listen zu je 5 Elementen, "DisplayFunction"):
• Etudie: D'abort générer les données (tableau à 3 listes à 5 éléments, "DisplayFunction"):
myMatrix = Table[Random[], {3}, {5}]??DisplayFunction
Graphiken rechnen, jedoch nicht einzeln ausgeben:
• Calculer des graphes, cependant ne pas les sortir:
plot1 = ListPlot[myMatrix[[1]],
PlotStyle->RGBColor[1,0,0], PlotJoined->True,
DisplayFunction->Identity];
plot2 = ListPlot[myMatrix[[2]],
PlotStyle->RGBColor[0,1,0], PlotJoined->True,
DisplayFunction->Identity];
plot3 = ListPlot[myMatrix[[3]],
PlotStyle->RGBColor[0,0,1], PlotJoined->True,
DisplayFunction->Identity];
Graphiken ausgeben, alle zusammen in einem Bild:
• Sortir les graphes, tous ensemble en une image:
Show[plot1, plot2, plot3,
DisplayFunction :> $DisplayFunction];Erklärungen: • Explications:
??$DisplayFunctionShow[plot1, plot2, plot3,
DisplayFunction -> $DisplayFunction];??->??:>Erklärungen: • Explications:
??ListContourPlot??ListDensityPlot
Erst Daten generieren:
• D'abort générer des données:
array1 = Table[x + Sin[x] + Random[], {6},
{x, 1, 6}]; Print[array1];
ListPlot3D[array1];array2 = Table[x + Sin[x] + Random[], {10},
{x, 1, 10}]; ListPlot3D[array2];
Zur besseren Sichtbarmachung zeichnet Mathematica eine Fläche und nicht eine Punktwolke im 3-dimensionalen Raum. ListContourPlot zeichnet davon eine
Höhenlinienkarte:
• Pour une meilleure perceptibilité, Mathematica dessine une surface et non pas un nuage de points dans l'espace à trois dimensions. ListContourPlot dessine une carte indiquant les courbes à niveau:
ListContourPlot[array1];
Eine andere Möglichkeit zur Veranschaulichung bietet ListDensityPlot:
ListDensityPlot offre une autre possibilité d'illustration:
ListDensityPlot[array1];
Mathematica bietet die Möglichkeit, Linien, Punkte, Kreise, Scheiben und Polygone direkt zu zeichnen. Beispiele:
• Mathematica offre la possibilité de dessigner directement des lignes, points, cercles, disques, polygones. Exemples:
Show[Graphics[{Circle[{0,0},.1]}]];
Wieso ist aus dem Kreis eine Ellipse geworden?
• Pourquoi le cercle est-il devenu une ellipse?
Options[Graphics][[1]]
Man muss also das Achsenverhältnis anpassen!
• Il faut donc adapter le rapport des axes:
Show[Graphics[{Circle[{0,0},.1]},
AspectRatio->1]];Show[Graphics[{Circle[{0,0},.1]},
AspectRatio->Automatic]];Show[Graphics[{Circle[{0,0},.1]},
AspectRatio->2]];Oder: • Ou:
Show[Graphics[{
PointSize[0.05], Point[{0, 0}], Point[{1, 0}],
Line[{{0, 0},{1, 0}}],
Circle[{0,0},.1], Circle[{1,0},.1]},
AspectRatio->Automatic]];
Oder ein Punkt im 3-dimensionalen Raum:
• Ou un point dans l'espace à trois dimensions:
Show[Graphics3D[Point[{3,2,1}]]];Show[Graphics3D[{PointSize[0.05],
Point[{3,2,1}]}]];
Oder erst Liste generieren:
• Ou générer d'abort une liste:
pts = Table[Random[], {4}, {3}]
Dann Liste manipulieren:
• Ensuite manipuler la liste:
??MapgraphicPts = Map[Point, pts]
Dann davon Plot machen:
• Ensuite faire un plot:
Show[Graphics3D[{PointSize[0.03], graphicPts}]];Mit Skala: • Avec échelle:
Show[Graphics3D[{PointSize[0.03], graphicPts}],
Axes->Automatic];
Mit Hilfe welcher Graphic-Objekte wird ein Plot ausgeführt?
• A l'aide de quels objets graphiques exécute-t-on un plot?
??InputFormbasicPlot = Plot[x^2, {x, 0, 25}];InputForm[basicPlot]
Trick: Ausgabe mehrerer Plots auf einmal:
• Truc: Emission de plusieurs plots à la fois:
Show[
Plot[Sin[x], {x, 0, 3 Pi}],
Graphics[{PointSize[0.05],
Table[Point[{n Pi, 0}], {n, 0, 3}]
}]
];
Hier sind 2 Plots gekommen. Damit nur der letzte kommt, muss man mit "DisplayFunction" arbeiten:
• Voici 2 plots sortis. Pour faire sortir seulement le dernier plot, il faut travailler avec "DisplayFunction":
Show[
Plot[Sin[x], {x, 0, 3 Pi},
DisplayFunction->Identity],
Graphics[{PointSize[0.05],
Table[Point[{n Pi, 0}], {n, 0, 3}]
}], DisplayFunction->$DisplayFunction
];
Beschriftung der x-Achse. Zuerst ohne:
• Faire des inscriptions sur l'axe x. D'abord sans inscriptions:
Plot[Sin[x], {x, 0, 3 Pi}];Dann mit: • Ensuite avec inscription:
??TicksPlot3D[Sin[x y], {x, 0, 3 Pi}, {y, 0, Pi}];Labels: • Labels:
??PlotLabel??FontForm
\n: Neue Linie
• \n: Nouvelle ligne:
Plot3D[Sin[x y], {x, 0, 3 Pi}, {y, 0, Pi},
PlotLabel -> FontForm["Hallo friend!
Plot3D[Sin[x y], \n
{x, 0, 3 Pi}, {y, 0, Pi}]",
{"Courier-Bold", 15}]];Oder: • Ou:
??TextShow[Graphics[{Circle[{0,0},1],
Text["Circle",{0,0.05}]}],
AspectRatio -> Automatic];
Package laden: • Charger Package:
<< Graphics/Shapes.mBeispiele: • Exemples:
Show[Graphics3D[Torus[]]];Show[RotateShape[Graphics3D[Torus[]],
0, 5 Pi/6, 0]];
Zuerst Graphiken rechnen (hier nur wenige Bilder zur schnellen und kurzen Demonstration, Bilderzahl bitte im Praktikum selbst erhöhen):
• D'abord calculer des graphiques (ici quelques images pour une démonstration rapide et brève, augmenter soi-même le nombre d'images lors du travail pratique):
cover = Table[Plot3D[Sin[x y], {x, 0, t/2},
{y, 0, t}, PlotPoints -> 9,
Ticks -> None],
{t, 1, 6, 3/4}]
Jede der eben ausgegebenen Graphiken ist in einer eigenen Zelle untergebracht. Alle diese Graphikzellen wiederum bilden eine gemeinsame Zelle (vgl. von links aus 2. senkrechte Linie am rechten Rand). Diese Zelle ist mit der Maus anzuklicken. (Sie wird dann dunkel markiert.) Nun wählst Du mit der Maus im Menu ("Graph") neu "Cell" und dann "Animate Selected Graphics ....y". Du wirst sehen, was geschieht! Um die Sache anzuhalten, brauchst Du nur mit der Maus irgendwohin ausserhalb der eben gewählten Menuzeile zu "klicken".
• Chacun des graphiques qui viennent de sortir est placé dans une cellule à lui. Toutes ces cellules de graphiques constituent de nouveau une cellule en commun (compare de gauche la 2e ligne verticale sur le bord de droite). Il faut toucher cette ligne avec la souris. (Elle deviendra foncée.) Maintenant tu choisis avec la souris dans le menu ("Graph") nouveau "Cell" et ensuite "Animate Selected Graphics ....y". Regarde ce qui se passe! Pour arrêter le processus, il te suffit d'activer la souris n'importe où en dehors du menu que tu viens de choisir.
??GraphicsArray??GraphicsSpacingShow[GraphicsArray[cover],
GraphicsSpacing -> 0.2];
Einige Erklärungen zu Befehlen:
• Quelques explications quant aux ordres:
??>>??Display??<<
Wir erzeugen eine Graphik:
• Nous générons un graphique:
expCos = Plot[Exp[-x^2] Cos[20 x], {x, -2, 2}];
exp1 = Plot[Exp[-x^2], {x, -2, 2}];
Nun schauen wir uns den Inhalt des Files "postscript_test1.ps" auf dem Schirm an. Du siehst sofort, dass hier offenbar Koordinaten von gerechneten Punkten gespeichert worden sind. Arbeite dazu die folgenden Befehle ab:
• Maintenant nous regardons le contenu des fichiers (files) "postscript_test1.ps" sur l'écran. Tu vois tout de suite qu'ici on a évidemment mémorisé les coordonnés des points calculés. Exécute les ordres suivants:
?exp1
Nun schreiben wir mit ">>" den PostScript-Code in ein File namens "postscript_test.ps" u.s.w. ins eigene Unterverzeichnis: (Hinweis: Der Name des Unterverzeichnisses ist hier "c:\work".)
• Maintenant nous écrivons avec ">>" le code "PostScript" dans un fichier du nom de "postscript_test.ps" etc. dans notre propre sous-dossier: (Indication: Le nom du dossier qu'on a ici est "c:\work".)
expCos >> "c:\work\postscri.ps";
exp1 >> "c:\work\postsc_1.ps";
Führe den Befehl aus und kontrolliere rasch im eigenen Verzeichnis, ob das File jetzt da steht! (Vielleicht vergeht etwas Zeit, bis es kommt.) "Display" tut dasselbe. Statt in ein PostScript-File speichern wir nachher den Code mit "Save" in ein Mathematica- File, das wir später wieder einlesen und den Mathematica-Code verwenden können. (Ausführen und kontrollieren! Probiere im einzulesenden File erst den PostScript-Code ein wenig zu verändern. Hüte Dich dabei vor Werten, die nicht verarbeitet werden können!):
• Execute l'ordre et contrôle vite dans le propre dossier, si le fichier y est! (Peut-être tu dois attendre un peu qu'il apparaisse.) "Display" fait la même chose. Au lieu de mémoriser le code dans un fichier PostScript, nous le mémorisons après avec "Save" dans un fichier de Mathematica, que nous lisons plus tard en utilisant le code de Mathematica. (Faire et contrôler! Essaie de changer d'abord un peu le code PostScript dans le fichier à lire. Evite les valeurs qui ne peuvent pas être élaborées!)
Display["c:\work\postsc_2.ps",expCos];
Display["c:\work\postsc_3.ps",exp1]Save[
"c:\work\postscri.ma",expCos];
Save[
"c:\work\postsc_1.ma",exp1]Save[
"c:\work\postscri.nb",expCos];
Save[
"c:\work\postsc_1.nb",exp1]
Nun löschen wir den PostScript-Code "expCos" u.s.w.:
• Maintenant nous effaçons le code PostScript "expCos" etc.:
Remove[expCos, exp1]??exp1??expCos
Das File kann wieder eingelesen werden:
• On peut relire le fichier:
??GetGet["c:\work\postsc_1.nb",exp1]?exp1Show[Graphics[expCos]];
Show[Graphics[exp1]];
Der Befehl ist jetzt wieder da! Nun schauen wir uns den Inhalt des Files "postscri.ps" auf dem Schirm an.
• Voici de nouveau l'ordre! Maintenant nous regardons le contenu du fichier "postscri.ps" sur l'écran.
!!"c:\work\postscri.ps"![[Graphics:Images/AllFiles.HTML_gr_24.gif]](Images/AllFiles.HTML_gr_24.gif)
![[Graphics:Images/AllFiles.HTML_gr_25.gif]](Images/AllFiles.HTML_gr_25.gif)
![[Graphics:Images/AllFiles.HTML_gr_26.gif]](Images/AllFiles.HTML_gr_26.gif)
![[Graphics:Images/AllFiles.HTML_gr_27.gif]](Images/AllFiles.HTML_gr_27.gif)
Package laden:
• Charger Package:
Needs["Graphics`ImplicitPlot`"]
Beispiel: Zuerst n = 128 Graphiken rechnen (das dauert!!!). Um Ueberraschungen zu vermeiden, ist n auf 10 eingestellt. Das geht zwar schneller, aber die Animation wird so nicht gut. Sonst kann es schon eine Lektion dauern!
• Exemple: Calculer d'abord n = 128 graphiques (cela dure!!!). Pour éviter des surprises, il faut mettre n sur 10. Cela va plus vite, mais l'animation n'est pas si bonne. Si non cela peut durer toute une leçon.
a=3;
(* n=128; *)
n=10;
tabelle1=Table[
ImplicitPlot[(x-y+2)(x^2+y^2-1) ==
N[3.(1.-Tan[b])] x, {x,-a,a},
PlotRange->{{-a,a},{-a,a}}, AspectRatio->1.],
{b,-Pi/2+Pi/n,Pi/2-Pi/n,Pi/n}];
Prepend[tabelle1,
ParametricPlot[{0.,t},{t,-a,a},
PlotRange->{{-a,a},{-a,a}}, AspectRatio->1.]];
Dann animieren!
• Ensuite animer!
2. Beispiel:
Zuerst n = 128 Graphiken rechnen. (Um Ueberraschungen zu vermeiden, ist n auf 10 eingestellt. Das geht zwar schneller, aber die Animation wird so nicht gut.)
• 2e exemple:
D'abord calculer n = 128 graphiques. (Pour éviter des surprises, il faut mettre n sur 10. Cela va plus vite, mais l'animation n'est pas si bonne.)
a=3;
(* n=128; *)
n=10;
tabelle2=Table[
ImplicitPlot[(x-y)(x^2+y^2-1)==N[Tan[b]-1] x,
{x,-a,a}, PlotRange->{{-a,a},{-a,a}},
AspectRatio->1.],{b,-Pi/2+Pi/n,Pi/2-Pi/n,Pi/n}];
Prepend[tabelle2,
ParametricPlot[{0.,t},{t,-a,a}, PlotRange->{{-a,a},
{-a,a}},AspectRatio->1.]];
Dann animieren!
• Ensuite animer!
(Um Ueberraschungen zu vermeiden, sind statt 60 nur 5 Schritte eingestellt.
Das geht zwar schneller, aber die Animation wird so nicht gut.)
• (Pour éviter des surprises, il faut 5 au lieu de 60 étapes. Cela va plus vite, mais l'animation réussit moins bien.)
Table[Plot3D[
Sin[3t+(x-3)^2+(y-2)^2]/(1+(x-3)^2+(y-2)^2)+
3/5Sin[5/3(3t+(x+3)^2+(y-2)^2)]/(1+(x+3)^2+(y-2)^2)+
3/4Sin[4/3(3t+x^2+(y+3)^2)]/(1+x^2+(y+3)^2),
{x,-8,8},{y,-8,8},
PlotRange->{{-8,8},{-8,8},{-1,1}},
PlotPoints->30],
(* {t,0,2Pi,2Pi/60}]; *)
{t,0,2Pi,2Pi/5}];
Wähle die Zelle an, die alle ausgegebenen Bilder umschliesst. Animiere mit "Animate Selected Graphics ...y" in Menu ("Graph") neu "Cell". Beobachte, welche Zonen sich bewegen und welche Zonen ruhig bleiben. Gibt es Interferenzen?
• Choisir la cellule qui inclut toutes les images sorties. Anime par "Animate Selected Graphics ...y" dans le menu ("Graph") nouveau "Cell". Observe quelles zones restent tranquilles. Y a-t-il des interférences?
Remove["Global`@*"]
Sinus ohne ";"
• Sinus sans ";"
Plot[Sin[x],{x,0,6 Pi},
AspectRatio -> 1/2,
PlotLabel -> "Sin[x]",
AxesLabel -> {"x", "y"},
AxesOrigin -> {2 Pi, 1/2} ]
Sinus mit ";" --- Unterschied?
• Sinus avec ";" --- y a-t-il une différence?
Plot[Sin[x],{x,0,6 Pi},
AspectRatio -> 1/2,
PlotLabel -> "Sin[x]",
AxesLabel -> {"x", "y"},
AxesOrigin -> {2 Pi, 1/2} ];
Schätze die Nullstellen mit Hilfe des Plots:
• Evalue les zéros à l'aide de "Plots":
Plot[2x^3-7x^2-17x+10,{x,-6,6}];
Verifiziere die Schätzung mit "Solve":
Vérifier l'évaluation par "Solve":
Solve[2x^3-7x^2-17x+10==0,x]
Schätze die Nullstellen mit Hilfe des Plots auf 3 Stellen (herauszoomen):
• Evalue les zéros à l'aide des "Plots" (3 places, zoom):
Plot[BesselJ[0,x],{x,-6,6}];
Verifiziere die Schätzung mit "Solve":
• Vérifie l'évaluation par "Solve":
Solve[2x^3-7x^2-17x+10==0,x]
Zeichne den Graphen der Besselfunktion J0 sowie Liniensegmente, die vom Startpunkt der Newton-Iteration für die Nullstellen schliesslich zur Nullstelle führen:
• Dessine le graphe de la fonction d'après Bessel J0 ainsi que des segments de lignes, qui vont du point de départ de l'itération d'après Newton pour les zéros au zéro:
Show[
Plot[BesselJ[0,x],{x,0,20},
DisplayFunction -> Identity],
Table[Graphics[{Dashing[{1/(10t)}],
Thickness[0.01],
Line[{
{t,BesselJ[0,t]},
{x/. FindRoot[BesselJ[0,x]==0,
{x,t}],0}
}]
}],
{t,0,20,3}
],
DisplayFunction :> $DisplayFunction
];
f definieren:
• Définir f:
Clear[f]; f[x_]:=1/(1 + Sin[Sqrt[Pi^2 + x]^2]); f[x]
Verwende Series und Normal: Achtung: Viel Output!
• Utilise "Series" et "Normal": Attention: Beaucoup d'Output!
n[x_]:=Normal[Series[f[x],{x,0,8}]];
nTest[x_]:=Normal[Series[f[x],{x,0,3}]];
nTest[x]
Plot von f und n:
• Plot de f et n:
Print[N[n[x]]]a = 1;
Plot[Evaluate[N[n[x]]],Evaluate[{x,-a,a}],
PlotStyle->{{Thickness[0.01],
Dashing[{0.04}]}}];a = 1; (*PlotRange*)
Show[
Plot[f[x],Evaluate[{x,-a,a}],
DisplayFunction -> Identity,
PlotStyle->{GrayLevel[0.1]}],
Plot[Evaluate[N[n[x]]],Evaluate[{x,-a,a}],
DisplayFunction -> Identity,
PlotStyle->{{Thickness[0.01],
Dashing[{0.04}]}}],
DisplayFunction :> $DisplayFunction];
x^2+cos(22x) :
Fehler beim Plotten bei normal vielen PlotPoints (in alten Versionen):
• Erreurs qui apparaissent en plotant avec un nombre normal de Plotpoints (vieilles vérsions):
Plot[x^2 + Cos[22x], {x,-5,5}];![[Graphics:Images/AllFiles.HTML_gr_28.gif]](Images/AllFiles.HTML_gr_28.gif)
x^2+cos(22x) :
Wähle 70 PlotPoints:
• Choisir 70 "PlotPoints":
![[Graphics:Images/AllFiles.HTML_gr_29.gif]](Images/AllFiles.HTML_gr_29.gif)
ParametricPlot[{Cos[4t] Cos[t],Cos[4t] Sin[t]},{t,0,2 Pi},
AspectRatio->Automatic];ParametricPlot[{Cos[7t] Cos[3t],Cos[7t] Sin[3t]},{t,0,2 Pi},
AspectRatio->Automatic];ParametricPlot[{Cos[7t] Cos[11t],Cos[7t] Sin[11t]},{t,0,2 Pi},
AspectRatio->Automatic];Einbinden: • Lier:
Needs["Graphics`Polyhedra`"];
Graphik ansehen:
• Regarder le graphique:
Show[Graphics3D[Icosahedron[]]];
Graphik ansehen:
• Regarder le graphique:
Show[Graphics3D[Stellate[Icosahedron[],3]],
Boxed->False];Normal: • Normal:
Plot3D[Sin[x y],{x,-5,5},{y,-5,5}];Lighting false: • Lighting false:
Plot3D[Sin[x y],{x,-5,5},{y,-5,5},Lighting->False];Normal: • Normal:
Plot3D[Sin[x y],{x,-5,5},{y,-5,5},Lighting->True,
ViewPoint->{0,0,3}];Anders: • Autrement:
Plot3D[Sin[x y],{x,-5,5},{y,-5,5},Lighting->True,
ViewPoint->{0,0,10}];
Nochmals anders:
• Encore autrement:
Plot3D[Sin[x y],{x,-5,5},{y,-5,5},Lighting->True,
ViewPoint->{0,3,10}];
Oder so:
• Ou ainsi:
Plot3D[Sin[x y],{x,-5,5},{y,-5,5},Lighting->True,
ViewPoint->{2,-4,6}];Contour: • Contour:
ContourPlot[Sin[x y],{x,-5,5},{y,-5,5}];Density: • Density:
DensityPlot[Sin[x y],{x,-5,5},{y,-5,5}];Contour: • Contour:
ContourPlot[x^2 + 2 y^2,{x,-5,5},{y,-5,5},
AspectRatio->Automatic];
Primzahlen generieren:
• Générer des nombres premiers:
t = Table[Prime[n],{n,10}]Plot: • Plot:
ListPlot[t,PlotStyle->{PointSize[0.05]}];
Punkte verbinden:
• Relier des points:
ListPlot[t,PlotStyle->{PointSize[0.05]},
PlotJoined->True];Fit: • Fit:
tfit = Fit[t,{1,x,x^2},x]
Fit-Kurve ansehen:
Regarder la courbe Fit:
Plot[tfit,{x,0,30}];
Kurve zusammen mit Punkten ansehen:
• Regarder la courbe et les points ensemble:
Show[
ListPlot[t,PlotStyle->{PointSize[0.05]},
DisplayFunction -> Identity],
Plot[tfit,{x,0,10},DisplayFunction -> Identity], DisplayFunction :> $DisplayFunction
]; Abweichungen: • Ecarts:
Clear[tfit]; tfit[x_] := Fit[t,{1,x,x^2},x];
te = Table[Prime[n]-tfit[n],{n,10}]
Abweichungen im Plot:
• Ecarts dans le Plot:
Show[
ListPlot[t,PlotStyle->{PointSize[0.05]},
DisplayFunction -> Identity],
ListPlot[te,PlotStyle->{PointSize[0.035]},
DisplayFunction -> Identity],
Plot[tfit[x],{x,0,10},DisplayFunction -> Identity],
DisplayFunction :> $DisplayFunction
];
Also los (Golden Gate Bridge):
• Allez-y (Golden Gate Bridge):
Show[
Graphics[{ (*Brücke*)
Circle[{-2,1},1,{3 Pi/2, 2 Pi}],
Circle[{0,1},1,{Pi, 2 Pi}],
Circle[{2,1},1,{Pi, 3 Pi/2}],
Line[{{-2,0},{2,0}}],
Line[{{-1,-0.5},{-1,1}}],
Line[{{1,-0.5},{1,1}}] }],
Graphics[ (*Wasser*)
Table[Circle[{x,-0.5},0.1,{Pi, 2Pi}],
{x, -2, 2, 0.2}] ],
Graphics[{ (*Fisch*)
Circle[{0,-1.2},0.4,{Pi/6, 5 Pi/6}],
Circle[{0,-0.8},0.4,{7 Pi/6, 11 Pi/6}],
Point[{-0.2,-0.95}],
Circle[{-0.3,-1},0.2,{- Pi/4, Pi/4}],
Line[{{0.35,-1},{0.5,-0.85},
{0.5,-1.15},{0.35,-1}}]
}],
AspectRatio->Automatic,
PlotRange->All ];
Also los (geometrisches Gesicht):
• Allez-y (visage géométrique):
Show[
Graphics[{
(*Augen*)
PointSize[0.04],
Point[{-0.3,0.1}],
Point[{0.3,0.1}],
(*Nase*)
Disk[{0,0},0.35,{23 Pi/16, 25 Pi/16}],
(*Mund*)
Line[{{-0.3,-0.5},{0,-0.6}}],
Line[{{0,-0.6},{0.3,-0.5}}],
(*Kopf*)
Circle[{0,0},1]
}],
AspectRatio->Automatic,
PlotRange->All ];
Wie wirken Farben?:
• Quels sont les effets des couleurs?
Show[
Graphics[
Table[{
RGBColor[0,x/4.,1.-x/4.],
Point[{x, Cos[x^2] - Sin[x]}]},
{x,0,4,0.01}
]
],
Axes->Automatic
];
Remove["Global`@*"]Remove["Global`@*"]
"Material" erzeugen zur späteren Benutzung:
• Générer des "materiaux" à utiliser plus tard:
(*n30*)Clear[n30]n30[x_]:=N[x,30]a = 4n30[Pi]Plot[-2x,{x,-1,1}];
Anzahl Output-Charakter verändern:
• Changer le charactère de l'output:
??SetOpt*??$Output??Pag*??PageWidthSetOptions[$Output, PageWidth -> 45]Options[$Output]
In 5.2. werden folgende Befehle besprochen: "In", "Out". Probiere:
• Dans 5.2. on discute les ordres suivants: "In", "Out". Essaie:
??Inlinie = $Line;
??Outlinie
"Material" erzeugen zur späteren Benutzung:
• Générer des "materiaux" à utiliser plus tard:
Plot[Sin[x],{x,0,50}];Plot[x^2,{x,0,1}];
Mit "Recall" in älteren Versionen. Neu mit "InString":
• Dans les versions plus vieilles avec "Recall". Dans les versions nouvelles avec "InString":
Recall[1, 2, 3]??InStringInString[{1, 2, 3, 4, 5, 6}]In[1]Out[1]??In
Das Folgende gibt sehr viel Output (zum Drucken hier gesperrt):
• Ce qui suit produit beaucoup d'output (ici défense d'imprimer):
(* ??Out *)Save["C:\work\ASession.nb",
In, linie, (*Out*)]!!C:\work\ASession.nb
Einige Edit-Funktionen:
• Quelques fonctions Edit:
??Edit![[Graphics:Images/AllFiles.HTML_gr_30.gif]](Images/AllFiles.HTML_gr_30.gif){kind=small}
??EditDefinition??EditDef??EditIn??*Edit*Beispiele: • Exemples
Edit[Expand[(x+2y)^6]]Oder: • Ou:
EditDefinition[n30]EditDefinition[a]
Funktioniert der Befehl auf NeXT?
• L'ordre fonctionne-t-il sur NeXT?
??n30??a
Weisst Du beim Schreiben innerhalb eines Befehls nicht mehr weiter, so kannst Du in der selben Zelle die Help-Funktion benutzen.
• Si tu ne t'en sors plus en écrivant à l'intérieur d'un ordre, tu peux utiliser la fonction Help dans la même cellule.
Beispiel: • Exemple:
Series[Csc[x],
?Series
Natürlich kannst Du auch eine neue Zelle machen:
• Naturellement tu peux faire une nouvelle cellule:
?Csc
Das Problem besteht nur bei Version 1.2.:
• Le problème existe seulement pour la version 1.2.:
?X* Z*Names["W*"]Oder: • Ou:
Names["A*"]
Das Problem besteht nur bei Version 1.2.:
• Le problème existe seulement pour la version 1.2.:
Names["*"]
Beispiel: Die Funktion "f(x) = sin(x) * cos(2x)" soll definiert werden.
Der Unterstrich "_" gibt die Funktionsvariable an. ":=" bedeutet "definiere":
• Exemple: Il faut définir la fonction "f(x) = sin(x) * cos(2x)". Le trait "_" indique la variable de la fonction. ":=" signifie "définis":
f[x_]:= Sin[x] Cos[2 x]
Ausgabe zur Kontrolle:
• Sortie de contrôle:
f[x]Anwendung: • Application:
f[Pi]Plot[f[x],{x, 0, 10}];
Kurz in einer Zelle eine andere Funktion:
• Brièvement une autre fonction dans une cellule:
f1[x_]:= Sin[2x] Cos[3 x^2];
Plot[f1[x],{x, 0, 10}];
Zum Vergleich, wie es nicht funktioniert:
• En tant que comparaison: Voici comme ça ne fonctionne pas:
g[x]:= Sin[2x] Cos[3 x^2];
Plot[g[x],{x, 0, 10}];g1[x_]= Sin[2x] Cos[3 x^2];
Plot[g1[x],{x, 0, 10}];g2[x]= Sin[2x] Cos[3 x^2];
Plot[g2[x],{x, 0, 10}];
Beispiel: Die Funktion "N" mit Klammern "[...]":
• Exemple: La fonction "N" avec des parenthèses "[...]":
N[Sqrt[2]/2]
Beispiel: "N" kommt hinten, abgetrennt durch "//":
• Exemple: "N" se place derrière, séparé par "//":
Sqrt[2]/2 // N
Damit lassen sich "Pipes" bilden. d.h. mehrere Funktionen nacheinander ausführen. Beispiele:
• Ainsi on peut former des "pipes", c'est-à-dire générer plusieurs fonctions l'une après l'autre. Exemples:
"W*" // Names"W*" // Names // Lengthx = Pi/2Sin[x]Sin[x] // Sin // NSin[x] // Sin // Sin // NSin[x] // Sin // Sin // Sin // Sin // NN[Sin[Sin[Sin[Sin[Sin[x]]]]]]Beispiel: • Exemple:
Sin[4.08]Sin[3.96];Abrufen: • Appeler:
%Beispiele: • Exemples:
a=1; b=2; c=3; d=4a=1; b=2; c=3; d=4;a=1; b=2; Print[b]; c=3; d=4;a=1; b=2; Print[b]; c=3; d=4a=1; b=2; Plot[x,{x,0,1}]; c=3; d=4
Mit "Timing" wird die CPU-Zeit gemessen. Beispiele:
• Avec "Timing" on mesure le temps CPU. Exemple:
Timing[N[Pi,500]]
Ohne den Output der Rechnung:
• Sans l'output du calcul:
Timing[N[Pi,500];]Timing[N[Pi,2000];]Plot[Sin[x],{x, 0, 50}] // TimingPlot[Sin[x],{x, 0, 50}]; // Timing
Während der Rechnungsausführung hast Du im Menu unter ("Action") neu "Kernel" - "Interrupt" die Möglichkeit, mit "Abort" abzubrechen oder mit "Interrupt Calculation" zu unterbrechen.
Der Abbruch ist auf NeXT auch möglich über die Tastatur mit "Command" und "." zusammen gedrückt. U.s.w..
Probiere aus (z.B. 5000 Fakultät....):
• Dans le menu sous ("Action") nouveau "Kernel" - "Interrupt" tu as la possibilité d'interrompre le calcul par "Interrupt Calculation" ou définitivement par "Abort".
Sur NeXT l'interruption définitive est aussi possible avec les touches "Command" et ".", pressées simultanément. Etc..
Essaie (p.ex. 5000 factoriel)
5000!
Braucht wohl die Bildschirmausgabe oder die Rechnung mehr Zeit? Probiere aus!
• Est-ce la sortie ou le calcul qui dure plus de temps? Essaie!
1000! // Timing
Mathematica stellt einige Variablen zur Verfügung. Diese beginnen mit dem Zeichen "$". Hier sind sie:
• Mathematica met quelques variables à disposition. Elles commencent par le signe "$". Les voici:
??$*
Einige Anwendungen:
• Quelques applications:
??$Line$Line$Version$VersionNumber$Letters
Mathematica-Zeichen sind Abkürzungen für Funktionen:
• Les signes de Mathematica sont des abréviations de fonctions:
??/Alias["/"]2/3 // NDivide[2, 3] // NDivide[2, 3]Apply[Divide,{2,3}]??ApplyRemove["Global`@*"]
Sinus ohne " ; ", damit Input-Lines erzeugt werden.
• Sinus sans " ; ", pour créer des Input-Lines.
Plot[Sin[x],{x,0,6 Pi},
AspectRatio -> 1/2,
PlotLabel -> "Sin[x]",
AxesLabel -> {"x", "y"},
AxesOrigin -> {2 Pi, 1/2} ];
Plot[2x^3-7x^2-17x+10,{x,-6,6}];
Solve[2x^3-7x^2-17x+10==0,x]Mit "??": • Avec "??":
??In
Finde alle Kommandos mit den Worten "Matrix" und "Power" im Namen:
• Trouve tous les commandements qui ont les paroles "Matrix" et Power" dans leur nom:
?*Matrix* *Power*Oder: • Ou:
??*Matrix* *Power*Oder: • Ou:
Print[Names["*Matrix*"]];
Names["*Power*"]
Kurze Neugier:
• Petite curiosité:
??Names
Invertierung einer 3 x 3-Matrix. Postfix-Notation verwenden.
Erst Matrix generieren:
• Invertir une matrice 3 x 3. User la notation postfixe. Générer d'abord la matrice:
m = Table[Random[ ], {3}, {3}]; MatrixForm[m]
Dann Inverse rechnen und Zeit messen (Postfix-Notation):
• Ensuite calculer l'inverse et mesurer le temps (notation postfixe):
m // Inverse // MatrixForm // Timing
Matrix generieren, Inverse rechnen und Zeit messen (Postfix-Notation):
• Générer une matrice, calculer l'inverse et mesurer le temps. (Notation postfixe):
Table[Random[ ], {10}, {10}] // Inverse; // Timing
1 ! bis 5 ! • 1! à 5!
Do[Print[i!], {i, 5}]
1 ! bis 250 ! Achtung! Der Rechner kann damit unmöglich fertig werden.
Die Zahlen sind zu gross! Daher musst Du den Vorgang unterbrechen!
Versuche in Action, Interrupt, Abort Calculation oder Interrupt Calculation.
• 1 ! à 250 ! Attention! La calculatrice ne peut pas en venir à bout. Les nombres sont trop grands! Tu dois donc interrompre le processus! Essaie
dans (Action) Kernel, Interrupt, Abort Calculation ou Interrupt Calculation.
Do[Print[i!], {i, 42}]
Bitte nicht ausdrucken:
• S.v.p. ne pas imprimer:
(* Do[Print[i!], {i, 250}] *)500!??$Line??$Version??$VersionNumberRemove["Global`@*"]
Listen - was sind Listen - was ist das?
• Des listes - qu'est - ce?
??List
Eingabe einer Liste:
• Entrer une liste:
list0 = {5, 4.78, a, 8x + y, Sin[x], D,
Integer, x->E}
Oft gibt Mathematica auch Listen aus. Beispiel:
• Mathematica sort souvent des listes. Exemple:
Solve[{2x + 5y == 19, 3x + 7y == 27}]
Hier ist eine Liste mit einer Liste ausgegeben worden.
• Ici on a sorti une liste qui contient une liste.
Ebenso z.B. bei "Options":
• Egalement p.ex. avec "Options":
Options[NIntegrate]
Hier ist eine Liste ausgegeben worden.
• Ici on a sorti une liste.
Zur Erzeugung von Listen stehen verschiedene Befehle zur Verfügung:
• Pour créer des listes on a plusieurs ordres à disposition:
??Range??Table??ArrayBeispiele: • Exemples:
Range[5]Range[7.896]Range[6,12]Range[3.4, 8.7]Range[3.4, 8.7, 1.2]Beispiele: • Exemples:
Table[hoi,{6}]Table[i!,{i, 6}]Table[3i,{i, 6, 14}]Table[i,{i, 4, 40, 5}]Table[{i, i^2},{i, 5}]Table[a[i] + b[j], {i, 1, 3}, {j, 4, 6}]
Das ist eine Liste von Listen, d.h. eine Matrix.
Zur besseren Darstellung verwenden wir "MatrixForm":
• C'est une liste de listes, c'est-à-dire une matrice.
Pour plus de clarté nous utilisons "MatrixForm"
MatrixForm[%]
Ein Iterator kann auch von einem andern abhängen:
• Un itérateur peut aussi dépendre d'un autre:
Table[a[i] + b[j], {i, 1, 3}, {j, i, 6}]MatrixForm[%]
Mit "Array" kann man eine symbolische Matrix erzeugen:
• Avec "Array" on peut créer une matrice symbolique:
Clear[a]Array[a,{2, 3}]MatrixForm[%]a = 17; Array[a,{2, 3}] // MatrixForm??Sort??Reverse??RotateLeft??RotateRight??Permutations??Drop??Take??First??Last??Part??Rest??Select
Hier einige Beispiele:
• Voici quelques exemples:
listA = Table[Random[Integer, {0, 12}],{16}]Sort[listA]Union[listA]
"Sort" sortiert die Liste, "Union" sortiert sie auch, eliminiert aber Duplikate
von Elementen.
• "Sort" trie la liste, "Union" la trie aussi, mais élimine les doubles des éléments.
Reverse[listA]RotateLeft[%,3]RotateRight[%,4]Permutations[{a, b, c}]Permutations[{a, b, b}]Probiere aus: • Essaie:
?Append?AppendTo?Drop?Insert?Prepend?PrependTo?Rest?Take?First?Last?Part?SelectProbiere aus: • Essaie:
Print[listA];
Rest[listA]
Was ist passiert?
• Que s'est-il passé?
Drop[listA, 10]Drop[listA, -5]Drop[listA, {2}]Drop[listA, {1}]Drop[listA, {3}]Drop[listA, {1,8}]Drop[listA, {4,12}]Take[listA,4]Take[listA,-6]Take[listA,{4,6}]Append[listA, 99]Prepend[listA, 100]Insert[listA, 999, 4]listA
Bei all diesen Operationen ist "listA" unverändert geblieben. Nicht aber bei den folgenden Operationen:
• Pendant toutes ces opérations "listA" n'a pas changé. Cela n'est pas le cas pour les opérations suivantes:
Print[listA];
AppendTo[listA, 2000]PrependTo[listA, 555]Probiere aus: • Essaie:
?Length?DimensionsLength[listA]Length[{a, 4, 2^8, t^2 + 2t - 6, matrix}]Length[{{a, 4, 2^8, t^2 + 2t - 6, matrix},
listA}]Dimensions[{{a, 4, 2^8, t^2 + 2t - 6, matrix},
listA}]Dimensions[{{a, 4, 2^8, t^2 + 2t - 6, matrix},
listA}, 0]Dimensions[{{a, 4, 2^8, t^2 + 2t - 6, matrix},
listA}, 1]Dimensions[{{a, 4, 2^8, t^2 + 2t - 6, matrix},
listA}, 2]MatrixForm[{{a, 4, 2^8, t^2 + 2t - 6, matrix},
listA}]Dimensions[{{a, 4, 2^8, t^2 + 2t - 6},
{1, 2, 3, 4}}, 2]MatrixForm[{{a, 4, 2^8, t^2 + 2t - 6},
{1, 2, 3, 4}}]Probiere aus: • Essaie
?Complement?Union?Join?IntersectionComplement[{1, 2, 3, 4, 5},{1, 2, 3}]Intersection[{a, b, c, d, e, f},
{d, e, f, g, h, i, j, k}]Union[{a, b, c, d, e, f},
{d, e, f, g, h, i, j, k}]Union[{1, 1, 1, 1, 2, 1, 3, 3, 3, 2, 4, 2, 4, 4,
3, 3, 3}]Join[{a, b, c, d, e, f},{d, e, f, g, h, i, j, k}]Join[{1, 2, 1, 1, 2, 2},{1, 2, 2, 1, 3, 2, 1,
3, 3}]Union[{1, 2, 1, 1, 2, 2},{1, 2, 2, 1, 3, 2, 1,
3, 3}]Probiere aus: • Essaie:
?Flatten
?Partition?Transposevector1 = Range[10]matrix1 = Partition[vector1, 5]MatrixForm[matrix1]matrix2 = Partition[vector1, 4]matrix3 = Partition[vector1, 3]matrix4 = Partition[vector1, 2.5]
Was ist passiert?
• Que s'est-il passé?
Partition[{1, 35, 432, 2, 5467, 4, 3, 987, 87},
3]Partition[{1, 2, 3, 4, 5, 6, 7}, 3, 1]Partition[{{1, 2, 3}, {4, 5, 6}, {7, 8, 9},
{a, b, c}}, 2, 1]Print[matrix1];
Flatten[matrix1]m = {{1, 2, 3, a},{4, 5, 6, b}}Transpose[m]Print[MatrixForm[m]];
MatrixForm[Transpose[m]]
Oben sind schon "First", "Last" und "Part erwähnt worden.
• Plus haut on a déjà nommé "First", "Last", et "Post".
liste1 = {a, b, c, d, e, f, g}First[liste1]Last[liste1]liste1[[4]]Print[{liste1[[2]],liste1[[3]],liste1[[4]],
liste1[[5]]}]liste1[[ Range[2, 5] ]]array1 = Array[a, {2, 2}]array1[[2]]array1[[1, 2]]Probiere aus: • Essaie:
?Select?*Q?DigitQ?IntegerQ?LetterQ?LowerCaseQ?MachineNumberQ?MatrixQ?NameQ?NumberQ?OddQ?EvenQ?PrimeQ?UpperCaseQ?ValueQ?VectorQ?Positiv*?Negat*Probiere aus: • Essaie:
MemberQ[liste1, 3]MemberQ[liste1, a]menge = {-4, 3, 5.678, emil, Emma, 4, 0, -2, -4,
Pi, 2^(1/2)}Select[menge, Positive]Select[{a, b, c, d, x, y, z}, Positive]
Bei "Select" steht also hinten das Selektionskriterium. Solche Kriterien kann man selbst definieren. Beispiel:
• Quant à "Select", le critère de sélection se trouve à la fin. On peut définir soi-même de tels critères. Exemple:
?Precision?===exakt[x_] := Precision[x] === InfinitySelect[{-6, 0, 3, 3.1414333, 1.111111, Pi, E,
N[Sqrt[2], 10], 5.66}, exakt]?Sum?Plus?ApplySum[n^2, {n, 7}]meineDaten = {3.4, 6.1, 5.3}Sum[meineDaten[[n]], {n, Length[meineDaten]}]Plus[1, 1, 1, 1, 1]Plus[1, 2, 3, 4, 5]Plus[a, b, c, d]Plus[{a, b, c, d}]??Plus
"Plus" hat das Attribut "Listable".
• "Plus" a l'attribut "Listable".
??Listable
"Plus" auf eine Liste angewandt addiert nur ein Element, nämlich die Liste selbst. Wie nun "Plus" aber auf die Elemente anwenden? - So:
• "Plus" appliqué à une liste additionne seulement un élément, c'est-à-dire la liste même. Comment appliquer "Plus" aux éléments? - Ainsi:
Apply[Plus, {a, b, c, d}]
Was geht nun schneller, "Sum" oder "Plus" ?
• Qu'est-ce qui est plus rapide, "Sum" ou "Plus"?
Timing[Apply[Plus, Range[500]]]Timing[Sum[n, {n, 500}]]
Wir wenden "Log" auf eine Liste an:
• Nous appliquons "Log" à une liste:
??LogLog[{1, 2, 3, 4, 5, 6, 7}]N[%]
Oder mit "Sinus":
• Ou avec "Sinus":
Sin[{1, 2, 3, 4, 5, 6, 7}]Sin[{1, 2, 3, 4, 5, 6, 7}] // N
Oder "Plus":
• Ou "Plus":
?Plus?*Form*FullForm[a + b]Plus[{1, 2, 3, 4}, {a, b, c, d}]{1, 2, 3, 4} + {a, b, c, d}
Attribute einiger Funktionen:
• Attributs de quelques fonctions:
Attributes[{Exp, Log, Sin, Cos, Plus, Times}]Attributes[Attributes]
"Attributes" hat also auch das Attribut "Listable".
• "Attributes" a donc aussi l'attribut "Listable".
Probiere: • Essaie:
??Map?Listable?Apply
Es gibt zwei Wege, eine Funktion auf eine Liste anzuwenden: mit "Listable" als Attribut und mit der Funktion "Map". Probiere:
• Il y a deux façons d'appliquer une fonction à une liste: avec l'attribut "List" et avec la fonction "Map". Essaie:
f[{1, 2, 3, 4, 5, 6}]?f
f ist nicht "Listable".
• F n'est pas "Listable"
Map[f, {1, 2, 3, 4, 5, 6}]
So geht's! Oder so:
• Voilà! Ou ainsi:
Map[f, a x^2 + b x + c]
Map wirkt auf die Teile eines Ausdrucks! Beachte:
• Map a un effet sur les parties d'une expression! Remarque:
Map[f, {a, b, c, d, e}]Apply[f, {a, b, c, d, e}]
Mit Apply wird f angewandt auf die Elemente der Menge als Ganzes, während mit Map diejenige Menge gebildet wird, die als neue Elemente die Funktionswerte der einzelnen alten Elemente enthält.
• Avec Apply on applique f aux éléments de l'ensemble comme un tout, tandis qu'avec Map on forme l'ensemble qui contient en tant qu'éléments nouveaux les valeurs des fonctions des vieux éléments.
Statt Apply und Map kann man auch /@ und @@ benutzen. Beispiele:
• On peut employer aussi /@ et @@ au lieu de Apply et Map. Exemple:
f/@{a, b, c, d, e}f@@{a, b, c, d, e}Sin/@{0, Pi, 2 Pi, 2, 3, 4, 5, 6}f1[x_, y_,z_]:= Sin[x z^2] Cos[y]f1@@{1, 2, 3}Probiere: • Essaie:
?ColumnForm?MatrixForm?TableForm?Binomialpascal[n_]:= Table[Binomial[n, i],{i, 0, n}]pascal[5]Table[pascal[n],{n, 0, 5}]ColumnForm[Table[pascal[n],{n, 0, 5}]]ColumnForm[Table[pascal[n],{n, 0, 5}], Center]ColumnForm[Table[pascal[n],{n, 0, 5}], Right]ColumnForm[Table[pascal[n],{n, 0, 5}], Left]TableForm[Table[pascal[n],{n, 0, 5}]]MatrixForm[Table[pascal[n],{n, 0, 5}]]MatrixForm[Table[n - i,{i,5},{n, 5}]]Remove["Global`@*"]Mit Range • Avec Range
Range[1,20,2]Mit Table • Avec Table
oddList = Table[2i-1,{i,10}]
Die ersten 4 Elemente nehmen:
• Prendre les 4 premiers éléments:
Take[oddList,4]
Die letzten 4 Elemente weglassen:
• Supprimer les 4 derniers éléments:
Drop[oddList, -4]
Eingabe der Matrizen
• Entrer les matrices
m = {{2, 4, 6}, {5, 7, 9}}; n = {{1, 2, 3}, {4,
5}};
Print[MatrixForm[m]]; Print["***"]; Print[MatrixForm[n]];Dimension • Dimension
Dimensions[m]Dimensions[n]
Länge • Longueur
Length[m]
Length[n]
Zwei Listen kreieren:
• Créer deux listes
li1 = Table[Random[Integer,{0,10}],{i,10}]
li2 = Table[Random[Integer,{0,10}],{i,10}]
Als Mengen:
• Comme ensembles:
Union[li1]Union[li2]
Sortieren von li1:
• Trier li1:
Sort[li1]An li1: • A li1:
Append[li1, 5]
von li1 und li2:
• de li1 et li2:
Intersection[li1, li2]
von li1 und li2:
• li1 et li2:
Union[li1, li2]
von li1 und li2:
• li1 et li2:
Join[li1, li2]
in li1 und li2:
• dans li1 et li2:
Complement[Union[li1, li2],Intersection[li1, li2]]
li1 ohne li2:
• li1 sans li2:
Complement[li1, li2]
von li1 und li2 bezüglich Range[10]:
• de li1 et li2 par rapport à Range[10]:
Complement[Range[10],Union[li1, li2]]
Liste von Listen von Zahlen:
• Liste de listes de nombres:
myList = {{-1,-1,2},{-1,-1,2},{-1,-1,2},{-1,-1,2}}Length[Union[myList]]
Liste von Polynomen:
• Liste de polynômes:
myList = {x^2-1,x^2-1,x^2-1,x^2-1,(x-1)(x+1)}Length[Union[myList]]
Liste generieren mit 16 Zahlen zwischen 0 und 100:
• Générer une liste de 16 nombres entre 0 et 100:
li3 = Table[Random[Integer,{0,100}],{i,16}]
mit 4 Teilmengen
• avec 4 sous-ensembles
li4 = Partition[li3,4]
Matrizenform:
• Forme de matrice:
MatrixForm[li4]li4[[3]]Transpose[li4][[3]]Transpose[li4][[3]] // MatrixFormMittelwet: • Valeur moyenne:
mean = Sum[li3[[i]],{i,1,Length[li3]}]/Length[li3]Oder: • Ou:
Apply[Plus,li3]/Length[li3]Median: • Médiane:
Erst Liste sortieren:
• D'abord trier la liste:
sLi3 = Sort[li3]
Mittleres Element resp. Durchschnitt der beiden mittleren Elemente rechnen, erst Funktion definieren:
• Calculer l'élément du milieu, resp. la moyenne des deux éléments, d'abord définir la fonction:
median[x_List] := (x[[Ceiling[ Length[x] /2]]] +
x[[ Floor[(Length[x]+2)/2]]]
) / 2
Versuche, dieses Programm zu begreifen!
• Essaie de comprendre ce programme!
Rechnen: • Calculer la médiane:
median[sLi3]
Liste mit ungerader Anzahl Elemente definieren, sortieren:
• Définir une liste avec nombre impair d'éléments, trier:
sLi4 = Sort[Append[li3,99]]
Median rechnen:
• Calculer la médiane:
median[sLi4]Liste: • Liste:
li3Programm: • Programme:
greater50[x_]:= x > 50Anwenden: • Appliquer:
Select[li3, greater50]
Liste eingeben:
• Entrer une liste:
Clear[myList]; myList = {{a,b},{c,d}}
(a) ausprobieren:
• essayer:
Apply[f, myList]
(b) ausprobieren:
• essayer:
Map[f, myList]
(c) On-line help:
• On-line help:
??MapAt??MapAll
(d) ausprobieren:
• essayer:
MapAt[f, myList, {2}]
(e) ausprobieren:
• essayer:
MapAll[f, myList]Zahlenreihen: • Ensembles de nombres:
r1 = {15, 17, 18, 32, 29}
r2 = {14, 18, 22, 29, 26}Programm: • Programme:
Map[Min, Transpose[{r1, r2}]]
Dazu Details:
• Quelques détails:
Transpose[{r1, r2}] // MatrixForm
Generiere eine Liste von 80 Punkten im 3-dimensionalen Raum:
• Générer une Liste de 80 points dans l'espace à trois dimensions
li5 = Table[Table[Random[Integer,{0,100}],{i,3}],
{j,80}]MatrixForm[%]
Graphik-Objekte herstellen:
• Faire des objets graphiques
punkte = Map[Point, li5]Ploten: • "Ploter":
Show[Graphics3D[{PointSize[0.025], punkte}],
Axes -> Automatic];Show[Graphics3D[{RGBColor[0.5,0.5,0.5],
PointSize[0.025], punkte}],
Axes -> Automatic];
Eine mögliche Lösung:
• Une solution possible:
Show[Graphics3D[
Table[{
RGBColor[i/100,(i/100)^2,(i/100)^3],
PointSize[0.025+i/1000],
punkte[[i]]
},{i,Length[punkte]}]
],
Axes -> Automatic
];Remove["Global`@*"]
Es geht hier darum zu zeigen, wie ein Name einem Wert oder einer Operation zugewiesen wird. Oder wie Symbole in Ausdrücken durch Werte ersetzt werden.
• Il s'agit de montrer ici comme un nom est assigné à une valeur ou à une opération. Ou comme on remplace des symboles dans des expressions par des valeurs.
Namen bestehen aus Buchstaben, Ziffern oder "$".
Eingebaute Mathematica-Namen beginnen mit Grossbuchstaben oder "$".
Namen mit "$" am Anfang sind globale Variablen. Probiere aus:
• Les noms sont formés de lettres, chiffres ou "$". Les noms incorporés de Mathematica commencent par une majuscule ou par "$". Les noms qui commencent par "$" sont des variables globales. Essaie:
a = 5a + 4
Statt Werte kann man auch Ausdrücke zuordnen und damit rechnen:
• Au lieu des valeurs on peut aussi assigner des expressions et calculer avec celles-ci:
a = 3x + y1/a
"." heisst "missing value". Weist man "." zu, so ist die Variable "leer":
• "." veut dire "missing value". Si on assigne ".", la variable est "vide":
a = .a
"=" oder "Set" bewirkt eine sofortige Zuordnung. Probiere aus:
• "=" ou "Set" produisent une application immédiate. Essaie:
?Set?=Set[a, 33444]arandom1 = Random[]2 3 + random1
":=" oder "SetDelayed" bewirkt die Zuordnung erst dann, wenn die nachstehende Funktion aufgerufen wird. Probiere:
• ":=" ou "SetDelayed" produisent l'application seulement, quand la fonction suivante est appelé. Essaie:
?:=?SetDelayedrandom2 := Random[]
Kein Output, da random2 nicht gerufen, sondern erst gesetzt worden ist.
Vergleiche und erkläre:
• Pas de "Output" car random2 n'a pas été appelé, mais seulement été placé. Compare et explique:
Table[random1,{5}]Table[random2,{5}]
Was ist der Unterschied und wieso tritt er auf? (Du kannst auch mehrmals probieren.) Anwendung auf die Definition von Funktionen:
• Quelle est la différence et pourquoi apparaît-elle? (Tu peux essaier plusieurs fois.) Application à la définition de fonctions:
Remove[f];Remove[g];
a) Unmittelbare Zuweisung. Beobachte, was b bewirkt:
• Application immédiate. Observe ce que produit b:
b = 3;
f[x_] = x + b
Veränderung des Wertes und Aufruf: Was bewirkt b?
• Changement des valeurs et appel: Que produit b?
b = 100;
f[5]
b) Verzögerte Zuweisung. Beobachte, was b bewirkt:
• Application retardée. Observe ce que produit b:
b = 3;
g[x_] := x + b
Veränderung des Wertes und Aufruf: Was bewirkt b?
• Changement de la valeur et de l'appel: Que produit b?
b = 100;
g[5]
Abruf der Definitionen:
• Appel des définitions:
?f?g
In einem Schritt können mehrere Zuordnungen gemacht werden. Mathematica arbeitet die Zuordnungen von rechts nach links ab:
• On peut faire plusieurs applications en une démarche. Mathematica achève les applications de droite à gauche:
a1 = a2 = a3
Oder listenweise:
• Ou par listes:
{u, v} = {4, 15}{s, t} = {u, v}{t, s}??Out
Durch rekursive Zuweisung (rekursive Funktion) kann eine Liste erzeugt werden. Hier das Beispiel der Fakultäten:
• Par une application (fonction) récursive on peut créer une liste. Voici l'exemple pour des factoriels:
Remove[fac];
fac[1] = 1;
fac[n_]:= fac[n] = n fac[n-1];?facTable[fac[n],{n,1,5}]fac[50];
Timing[fac[50]]Probiere: • Essaie:
Remove[fak];
fak[1] = 1;
fak[n_]:= n fak[n-1];
Table[fak[n],{n,1,5}]fak[50];
Timing[fak[50]]
Wieso braucht Mathematica das zweite Mal weniger Zeit? Das erste Mal speichert es wegen der Zwischenzuweisung alle Werte ab und kann den gewünschten Wert dann aus dem Speicher holen. Das zweite Mal muss das Programm rechnen!
• Pourquoi Mathematica emploie-t-il moins de temps la deuxième fois? La première fois il mémorise toutes les valeurs à cause des applications intermédiaires et peut sortir la valeur desirée de la mémoire. La deuxième fois le programme doit calculer!
Beispiel: • Exemple:
Remove[x] ; x = 1 ; Print["1) ", x] ;
x = . ; Print["2) ",x] ??xx = 1 ; Print["1) ", x] ??xx = . ; Print["2) ",x] ??x?fakfak[1] = .fak[n_] = .?fak
Zwar ist kein Wert mehr zugewiesen, doch die Funktion ist noch bekannt.
• Aucune valeur n'est plus assignée, cependant la fonction est encore connue.
Anderes Beispiel:
• Autre exemple:
kubus[x_] = x^3?kubusClear[kubus]?kubus
Zwar ist keine Funktionsvorschrift mehr zugewiesen, doch der Name der Funktion ist noch bekannt.
• Aucune prescription de fonction n'est assignée. Cependant le nom de la fonction est encore connu.
Attributes[kubus] = {Listable}Clear[kubus]?kubus
Sogar das Attribut ist noch bekannt.
• Même l'attribut est encore connu.
ClearAll[kubus]?kubus
Jetzt ist das Attribut nicht mehr bekannt.
• Maintenant l'attribut n'est plus connu.
Remove[kubus]?kubus
Jetzt ist auch der Name nicht mehr bekannt.
• Maintenant même le nom n'est plus connu.
Remove[Apply]
(Hier handelt es sich um einen Mathematica-Namen!)
• (Ici il s'agit d'un nom de Mathematica))
Es kann passieren, dass man eine Funktion aus einem Package aufruft, bevor das Package geladen worden ist. Nach dem Aufruf erscheint vielleicht eine Meldung, worauf man dann den Aufruf des Packages nachholt. Da aber vom ersten Aufruf her die Funktion schon registriert ist, lässt sie sich jetzt nicht einfach überschreiben. Man muss sie erst wieder löschen. Die mit dem Package geladene Funktion bleibt dann bestehen. Beispiel:
• Il peut arriver qu'on appelle une fonction d'un package avant le changement du package. Après l'appel il apparaît peut-être un message de rattraper l'appel du package. Mais comme la fonction a déjà été enregistrée au premier appel, elle ne se laisse pas surcharger maintenant. Il faut d'abord l'effacer. La fonction chargée du Package reste. Exemple:
Show[Graphics[{CMYColor[0.6,0.5,0.4],
Point[{0,0}]}]];Needs["Graphics`Colors`"]?CMYColorRemove[CMYColor]?CMYColor
Folgender Befehl löscht alle globalen Variablen und Funktionen, die mit einem Kleinbuchstabe oder mit "$" beginnen und nicht"protected" sind.
• L'ordre suivant efface toutes les variables et fonctions globales qui commencent par une minuscule ou par "$" et qui ne sont pas "prodected".
?fakRemove["Global`@*"]?fak
Der folgende Befehl löscht alle Variablen und Funktionen, die nicht"protected" sind. Achtung vor der Anwendung!
• L'ordre suivant efface toutes les variables et fonctions qui ne sont pas "protected".
(* Remove["@*"] *)
Falls was schief gegangen ist, kannst Du im Menu unter ("Action") "Kernel", "Kernels and Tasks..." einen neuen Kernel starten.
• Si quelque chose n'a pas fonctionné, tu peux démarrer un nouveau Kernel dans le menu sous ("Action") "Kernel", "Kernels and Tasks...".
?/.?ReplaceAll?Replace
In Mathematica gibt es also die Möglichkeit, nach der Berechnung durch Anwendung einer Ersetzungsregel einen Ausdruck durch etwas anderes zu ersetzen. Beispiele:
• Dans Mathematica il y a la possibilité, après un calcul où on emploie une règle de remplacement, de remplacer une expression par autre chose. Exemple:
x + 7yx + 7y /. x->4x + 7y /. {x->4, y->3}x + 7y
Die Ersetzung ist also nicht bleibend! Beachte:
• Le remplacement n'est pas définitif! Observe:
3x + 7x /. {3x->y, y->3}
Da zuerst gerechnet wird, kommt die Ersetzungsregel gar nie zur Ausführung.
• Comme on commence par le calcul, la règle de remplacement n'arrive pas à être utilisée.
Vergleiche: • Compare:
?->?:>
Man hat also eine ähnliche Situation wie bei "=" und ":=". Beispiele:
• On a donc une situation semblable comme pour "=" et ":=". Exemple:
Table[x, {6}]Table[x, {6}] /. x-> Random[]
Offenbar ist erst gerechnet worden. Dann wurde Random[ ] einmal ausgeführt, darauf zugewiesen. x bleibt leer:
• Apparemment on a d'abord calculé. Ensuite on a exécuté une fois Random[ ], puis assigné. x reste vide.
xTable[x, {6}] /. x:> Random[]
Hier ist demnach Random[ ] jeweils vor der nächsten Zuweisung verzögert ausgeführt worden.
• On a donc retardé chaque fois l'exécution de Random[ ] avant la prochaine assignation.
Studiere: • Etudie:
?//.Vergleiche: • Compare:
log[a b c d] /. log[x_ y_] -> log[x] + log[y]log[a b c d] //. log[x_ y_] -> log[x] + log[y]
Studiere, welche Optionen im nächsten Beispiel verzögert und welche gewöhnlich sind:
• Etudie quelles options, dans l'exemple suivant, sont retardées et lesquelles sont normales:
Options[ContourPlot]
Aufgabe: Jeder Plot soll als Label das Kommando erhalten, das ihn generiert hat.
Studiere, was nun folgt:
• Problème: Chaque Plot reçoit en tant que Label le commandement qui l'a généré. Etudie ce qui en suit:
?$Line$Line?InString?ToString?StringJoin?SetOptionsSetOptions[Plot,PlotLabel :> StringJoin[
"In[", ToString[$Line], "] :> ",
InString[$Line]
]];
Plot[Sin[x],{x, 0, 2 Pi}];Plot[Cos[x],{x, 0, 2 Pi}];
Dazu gab es ein Package. (Neu bei Build-in Functions)
• Pour cela il existait un Package. (Nouveau avec Build-in Functions)
Needs["Algebra`Trigonometry`"] (* old ! *)??TrigReduce??TrigReduceRel
Offenbar kann (konnte) man Dinge nicht ansehen, die mit "Private" spezifiziert sind (waren). Beachte die Anwendung:
• Apparemment on ne peut (pouvait) pas regarder les choses qui sont (étaient) spécifiées par "Private". Tiens compte de l'application:
TrigReduce[Sin[x + Pi]]
Beachte die Ersetzungsregeln im Aufbau des folgenden Programms.
(Die Sache wird in einem späteren Kapitel erklärt. Hier ist nur Text - so läuft es nicht.)
• Considère les règles de remplacement dans la construction (structure) du programme suivant. (La chose sera expliquée dans un chapitre ultérieur. Ici il n'y a que du texte - cela ne va (tourne) pas ainsi.)
BeginPackage["Algebra`Trigonometry`", "Global`"]
TrigCanonical::usage = "TrigCanonical[expr] is obsolete.
Its functionality is now built-in."
TrigExpand::usage = "TrigExpand[expr] is obsolete.
Its functionality is provided by Expand[expr, Trig->True]."
TrigFactor::usage = "TrigFactor[expr] tries to write sums of trigonometric
functions as products."
TrigReduce::usage = "TrigReduce[expr] writes trigonometric functions of
multiple angles as sums of products of trigonometric functions of
that angle."
TrigReduce::notes = "TrigReduce simplifies the arguments of trigonometric
functions. It is, in a way, the inverse of TrigExpand."
TrigToComplex::usage = "TrigToComplex[expr] writes trigonometric functions
in terms of complex exponentials."
ComplexToTrig::usage = "ComplexToTrig[expr] writes complex exponentials
as trigonometric functions of a real angle."
Begin["`Private`"]
{`x, `y, `r, `n, `m, `a, `b, `c, `i, `e};
TrigCanonical[e_] := e
TrigExpand[___] := $Failed /;
Message[TrigExpand::obsfn, TrigExpand, Expand]
TrigExpand[e_]:=Expand[e,Trig->True]
`TrigFactorRel = {
a_. Sin[x_] + a_. Sin[y_] :> 2 a Sin[x/2+y/2] Cos[x/2-y/2],
a_. Sin[x_] + b_. Sin[y_] :> 2 a Sin[x/2-y/2] Cos[x/2+y/2] /; a+b == 0,
a_. Cos[x_] + a_. Cos[y_] :> 2 a Cos[x/2+y/2] Cos[x/2-y/2],
a_. Cos[x_] + b_. Cos[y_] :> 2 a Sin[x/2+y/2] Sin[y/2-x/2] /; a+b == 0,
a_. Tan[x_] + a_. Tan[y_] :> a Sin[x+y]/(Cos[x] Cos[y]),
a_. Tan[x_] + b_. Tan[y_] :> a Sin[x-y]/(Cos[x] Cos[y]) /; a+b == 0,
a_. Sin[x_] Cos[y_] + a_. Sin[y_] Cos[x_] :> a Sin[x + y],
a_. Sin[x_] Cos[y_] + b_. Sin[y_] Cos[x_] :> a Sin[x - y] /; a+b == 0,
a_. Cos[x_] Cos[y_] + b_. Sin[x_] Sin[y_] :> a Cos[x + y] /; a+b == 0,
a_. Cos[x_] Cos[y_] + a_. Sin[x_] Sin[y_] :> a Cos[x - y]
}
TrigFactorRel = Dispatch[TrigFactorRel]
Protect[TrigFactorRel]
TrigFactor[e_] := FixedPoint[(# /. TrigFactorRel)&, e]
`TrigReduceRel = {
Cos[n_Integer x_] :> 2^(n-1) Cos[x]^n +
Sum[ Binomial[n-i-1, i-1] (-1)^i n/i 2^(n-2i-1) Cos[x]^(n-2i),
{i, 1, n/2} ] /; n > 0,
Sin[m_Integer?OddQ x_] :>
Block[{`p = -(m^2-1)/6, `s = Sin[x], `k},
Do[s += p Sin[x]^k;
p *= -(m^2 - k^2)/(k+2)/(k+1),
{k, 3, m, 2}];
m s] /; m > 0,
Sin[n_Integer?EvenQ x_] :>
Sum[ Binomial[n, i] (-1)^((i-1)/2) Sin[x]^i Cos[x]^(n-i),
{i, 1, n, 2} ] /; n > 0,
Tan[n_Integer x_] :> Sin[n x]/Cos[n x],
Sin[x_ + y_] :> Sin[x] Cos[y] + Sin[y] Cos[x],
Cos[x_ + y_] :> Cos[x] Cos[y] - Sin[x] Sin[y],
Tan[x_ + y_] :> (Tan[x] + Tan[y])/(1 - Tan[x] Tan[y]),
Sin[r_Rational x_] :> (Sin[Numerator[r] `symb] /. TrigReduceRel /.
`symb -> x/Denominator[r]) /; Numerator[r] != 1,
Cos[r_Rational x_] :> (Cos[Numerator[r] `symb] /. TrigReduceRel /.
`symb -> x/Denominator[r]) /; Numerator[r] != 1,
Tan[x_/2] :> (1 - Cos[x])/Sin[x],
Cos[x_/2]^(n_Integer?EvenQ) :>
((1 + Cos[x])/2)^(n/2),
Sin[x_/2]^(n_Integer?EvenQ) :>
((1 - Cos[x])/2)^(n/2),
Sin[x_/2]^n_. Cos[x_/2]^m_. :> Tan[x/2]^n /; m == -n,
Sin[r_ x_.] Cos[r_ x_.] :> Sin[2 r x]/2 /; IntegerQ[2r]
}
TrigReduceRel = Dispatch[TrigReduceRel]
TrigReduce[e_] := e //. TrigReduceRel
`TrigToComplexRel = {
Sin[x_] :> -I/2*(-E^(-I*x) + E^(I*x)),
Cos[x_] :> (E^(-I*x) + E^(I*x))/2,
Tan[x_] :> (-I*(-E^(-I*x) + E^(I*x)))/(E^(-I*x) + E^(I*x)),
Csc[x_] :> (2*I)/(-E^(-I*x) + E^(I*x)),
Sec[x_] :> 2/(E^(-I*x) + E^(I*x)),
Cot[x_] :> (I*(E^(-I*x) + E^(I*x)))/(-E^(-I*x) + E^(I*x)),
Si[x_] :> -I/2(ExpIntegralE[1, I x] - ExpIntegralE[1, -I x]) + Pi/2,
Ci[x_] :> -1/2(ExpIntegralE[1, I x] + ExpIntegralE[1, -I x])
}
TrigToComplexRel = Dispatch[TrigToComplexRel]
TrigToComplex[e_] := e //. TrigToComplexRel
`ComplexToTrigRel = {
Exp[a_ b_Plus] :> Exp[Expand[a b]],
Exp[c_Complex x_. + y_.] :> Exp[Re[c] x + y] (Cos[Im[c] x] + I Sin[Im[c] x])
}
ComplexToTrigRel = Dispatch[ComplexToTrigRel]
ComplexToTrig[e_] := Cancel[e //. ComplexToTrigRel]
End[] (* Algebra`Trigonometry`Private` *)
Protect[ TrigCanonical, TrigExpand, TrigFactor, TrigReduce,
TrigToComplex, ComplexToTrig ]
EndPackage[]
Das Original befindet (befand) sich im Root-Verzeichnis unter "LocalLibrary", "Mathematica", "Packages", "Algebra", "Trigonometry.m" (NeXT).
• L'original se trouve (touvait) dans le directoire Root sous "LocalLibrary", "Mathematica", "Packages", "Algebra", "Trigonometry.m" (NeXT).
Studiere die folgende Anwendung:
• Etudie l'application suivante:
Needs["Statistics`DescriptiveStatistics`"]dReport = DispersionReport[{3,4,2,3,6,7,4,8,9,
5,2,4}]
Das Resultat ist also eine Liste von Regeln! Nun wollen wir einen Wert extrahieren:
• Le résultat est donc une liste de règles! Maintenant nous en extrayons une valeur:
MeanDeviation /. dReport
Oder wir können das Resultat in eine Variable speichern:
• Oubien nous pouvons mémoriser le résultat dans une variable:
x1 = MeanDeviation /. dReportx1
Manchmal erscheint der Output in Form von Ersetzungsregeln.
Mit ihnen kann z.B. wie folgt direkt weitergerechnet werden (Beispiel):
• Parfois l'output apparaît en forme de règles de remplacement. Avec celles-ci on peut continuer de calculer par exemple comme il suit:
Remove[x]wurzeln = Solve[x^2 + 13x - 34 == 0]
Hier ist ein solcher Output in Form von Ersetzungsregeln gegeben. Wir verwenden diese Regeln, die nun den Namen "wurzeln" haben, direkt hinter "/." weiter. Wir wollen die Lösungen wieder in die Gleichung einsetzen:
• Voici un tel output en forme de règles de remplacement. Nous continuons d'employer ces règles qui ont dès maintenant le nom "racines" directement derrière "/." . Nous allons remplacer la solution dans l'équation:
x^2 + 13x - 34 == 0 /. wurzelnSimplify[%]Oder: • Ou:
x /. wurzeln[[1]]
Die erste Regel wurde extrahiert! Oder:
• Cette règle a été extraite! Ou:
2x + 13 /. wurzeln[[1]]Studiere: • Etudie:
?==Anwendung: • Application:
Expand[(x + y)^2] == x^2 + 2x y + y^2
Vergleich mit "=":
• Comparaison avec "=":
Expand[(x + y)^2] = x^2 + 2x y + y^2
Eingebaute Funktionen sind "protected". Man kann dies allerdings ändern. Beispiel:
• Les fonctions incorporées sont "prodected". Mais on peut changer cela. Exemple:
?OutAttributes[Out]
Achtung: Das gibt viel Output...... Vgl. 7.1.4.
• Attention: Cela fait beaucoup d'output.... Compare 7.1.4.
(* ??Out *)?UnprotectUnprotect[Out]Clear[Out]; Protect[Out]
Wieviel Output ist es noch?
• Combien d'output cela fait-il encore?
Studiere: • Etudie:
?ToRulesNRoots[x^3 - 5 x^2 - 19 x + 66 == 0 , x]
Der Output kommt hier in Form einer logischen oder-Verknüpfpung.
Wir wollen daraus Regeln machen:
• L'output se manifeste ici en forme de composition (avec "ou"). Nous voulons en faire des règles:
ToRules[%]Probiere aus: • Essaie:
?=?==?===?!=?=!=?Set?Equal?SameQ?Unequal?UnsameQStudiere: • Etudie:
N[Pi, 5] == N[Pi, 30]
Hier hat Mathematica nur die Gleichheit bis auf die kleinere angegebene
Stellenzahl geprüft.
• Ici Mathematica n'a examiné l'égalité que jusqu'au plus petit degré indiqué.
Clear[x]; Clear[y];x == y
Hier gab es nichts zu prüfen.
• Ici il n'y avait rien à examiner.
1 != 2Das stimmt. • C'est vrai.
Im folgenden Beispiel wird die syntaktische Gleichheit geprüft, auch wieder bis auf die kleinste angegebene Genauigkeit:
• Dans l'exemple suivant on examine l'égalité syntaxique de nouveau jusqu'à la plus petite exactitude donnée.
N[Pi, 3] === N[Pi, 30]Oder: • Ou:
N[Pi, 3] =!= N[Pi, 30]x =!= yx === yRemove["Global`@*"]Clear[f];Clear[g];a)
f[x_]=x/.a->7b)
g[x_]:=x/.a->7c)
f[3+a]d)
g[3+a]e)
f[x_]=x + %f)
g[x_]:=x + %g)
f[x_]=N[x]h)
g[x_]:=N[x]i)
f[x_]=Expand[2x]j)
g[x_]:=Expand[2x]k)
?fl)
?gIntegrate[x^2,x]
Wieso wohl schreibt Mathematica vor die Input line .... := und vor die Output line .... =, ohne den Doppelpunkt?
• Pourquoi est-ce que Mathematica écrit devant la ligne Input.....:= et devant la ligne Output ....=, sans le double point?
Verdoppelung jeweils des zweiten Elements:
• Redoublement du deuxième élément:
{{1,1},{2,2},{3,3}}/.{x_,y_}:>{x,2y}
Gleiches Vorgehen wie in a), nur mit kleinerer Menge:
• Même procédé que dans a), seulement avec un ensemble plus petit:
{{1,1},{2,2} }/.{x_,y_}:>{x,2y}
Wieso hat die Regel jetzt anders funktioniert? (Hinweis: Welche Möglichkeiten bestehen jeweils, das Paar zu interpretieren?)
• Pourquoi la règle a-t-elle fonctionné autrement? (Indication: Quelles possibilités y a-t-il pour interpréter la paire?)
Schreibe eine Regel, die einen Punkt (x, y, z) des 3-dimensionalen Raumes projiziert in den Punkt des 2-dimensionalen Raumes (x, y):
• Ecris une règle, qui projette un point (x, y, z) de l'espace à 3 dimensions dans un point de l'espace à 2 dimensions (x, y):
Regel: • Règle:
p[x_,y_,z_]={x,y,z}/.{x_,y_,z_}:>{x,y}Anwendung: • Application:
p[7,4,9]
Schreibe eine Regel, die aus einer Liste von 4 Paaren {xi, yi} und einer Liste von 4 Werten zi eine neue Liste von Tripeln {xi, yi, zi} macht:
• Ecris une règle qui fait d'une liste de 4 paires{xi, yi} et d'une liste de 4 valeurs zi une nouvelle liste de triples {xi, yi, zi}:
Paare: • Paires:
paare = Table[{x[i],y[i]},{i,4}]z-Werte: • Valeurs z
zWerte = Table[z[i],{i,4}]
Noch nicht gewünschte Liste:
• List pas encore désirée:
{paare,zWerte}{paare,zWerte}//MatrixForm{paare,zWerte}//Transpose//MatrixForm{paare,zWerte}/.{xyListe_List,zListe_List}:>
Transpose[xyListe] // MatrixForm{paare,zWerte}/.{xyListe_List,zListe_List}:>
Append[Transpose[xyListe],zListe] // MatrixForm
Gewünschte Liste:
• Liste désirée:
{paare,zWerte}/.{xyListe_List,zListe_List}:>
Transpose[Append[Transpose[xyListe],zListe]]//
MatrixFormy (x+2)(x-2)/. y z_ -> y Expand[z]
Schreibe eine Regel, die das Produkt (x+2)(x-2) ausmultipliziert.
• Ecris une règle qui multiple le produit (x+2)(x-2).
y (x+2)(x-2)/. y z_ :> y Expand[z]
Hinweis: Was ist der Unterschied bezüglich Parameter bei fixer und bei verzögerter Zuordnung?
• Indication: Quelle est la différence par rapport aux paramètres lors d'une assignation fixe et d'une assignation retardée?
Ein altes Package enthält die folgende Regel:
• Un vieux Package contient la règle suivante:
a_. Cos[x_] Cos[y_] + a_. Sin[x_] Sin[y_] :>
a Cos[x - y]
Wieso enthält es dazu nicht auch die folgende Regel?
• Pourquoi ne contient-il pas non plus la règle suivante?
a. Cos[x_ - y_] :>
a Cos[x] Cos[y] + a Sin[x] Sin[y]
Hinweise: Unendlicher loop ......
• Indications: Loop infini ......
Verwende DSolve, um die folgende D'Gl. zu lösen: y'=y:
Utilise DSolve pour résoudre l'équation différentielle suivante: y'=y:
DSolve[y'[x]==y[x],y[x],x]
Probiere, aus der Lösungsliste die Resultatsfunktion herauszugreifen und wieder in die Gleichung einzusetzen, um zu überprüfen, ob das Resultat stimmt!
• Essaie de prender la fonction des résultats dans la liste des solutions et de l'insérer dans l'équation différentielle!
r = Flatten[DSolve[y'[x]==y[x],y[x],x]]
s[x]:=y[x]/.r ; s[x]Einsetzen: • Insérer:
D[s[x],x] == s[x]
Putzmaschine" einsetzen
• Employer la "machine de nettoyage
Remove["Global`@*"]
Mathematica kennt keine Deklarationen von Typen für die Variablen wie z.B. in klassischen Programmiersprachen, z.B. Modula II. Trotzdem.... Mathematica kann selber merken, um welchen Typ es sich handelt...
• Mathematica ne connaît pas de déclarations de types pour les variables comme p.ex. dans des langues de programmation classiques, p.ex. Modula II. Pourtant.... Mathematica s'aperçoit de quel type il s'agit....
Jeder Ausdruck ist aus folgenden "atomaren Typen" zusammengesetzt: Integer, Real, Rational, Complex, Symbol, String.
• Chaque expression est composée des "types atomiques" suivants: Integer, Real, Rational, Complex, String.
??Integer?Real?Rational?Complex?Symbol?String?HeadHead[3452]Head[67.94]Head[3 + 4 I]Head[E]Head[Pi]Head["Tschou zämä!"]
Neben den atomaren Typen gibt es übergeordnete Typen. Z.B. Integer, Real,
Rational u.s.w. sind Zahlen. Ein Vektor ist eine Liste etc.. Um zu prüfen, um welchen Typ es sich gerade handelt, existieren sogenannte Prädikatenfunktionen. Beispiele:
• A part des types atomiques il y a des types supérieurs. P.ex. Integer, Real, Rational etc. sont des nombres. Un vecteur est une liste etc.. Pour examiner de quel type il s'agit, il existe les dites fonctions de prédicats.
NumberQ[5/2 + 8 I/5]NumberQ[5/2 + 8 I/5 - Pi]VectorQ[{a, b, c, d, e, f, g}]
Die Prädikatenfunktionen enden mit "Q". Ihr Wertebereich ist {True, False}. Hier sind sie alle:
• Les fonctions de prédicats se terminent par "Q". Leur domaine de valeurs est "True, False". Voici tous:
?*Q
Operationszeichen oder spezielle Symbole wie "+", "/", "#", "/@" u.s.w. werden intern dargestellt durch Funktionen. Mit den Funktionen "FullForm[...]", "FullForm[Hold[...]]" oder "TreeForm" kann die interne Darstellung in Mathematica sichtbar gemacht werden.
• Signes d'opérations ou symboles spéciaux tels que "+", "/", "#", "/@" etc. sont représentés intérieurement par des fonctions. Par les fonctions "FullForm[...]", "FullForm[Hold[...]]" ou "TreeForm" on peut rendre visible la représentation intérieure dans Mathematica.
?FullForm?TreeFormBeispiele: • Exemples:
FullForm[4/7]FullForm[4 - 7 I]FullForm[f[x]]FullForm[x y^z / w]TreeForm[x y^z / w]FullForm[2 + 3 15]
Im letzten Beispiel ist zuerst die Rechnung ausgeführt worden. Erst darauf wurde dann die Funktion "FullForm" angewandt. Die gültige Abarbeitungshierarchie kann aber geändert werden. Dazu dienen folgende Befehle:
• Dans le dernier exemple on a d'abord exécuté le calcul. Ensuite seulement on a appliqué la fonction "FullForm". On peut changer la hiérarchie de l'exécution valable par les ordres suivants:
?Hold?HoldForm?ReleaseHold?EvaluateBeispiele: • Exemples
FullForm[Hold[2 + 7 - 4]]Hold[2 + 7 - 4]HoldForm[2 + 7 - 4]ReleaseHold[Hold[2 + 7 - 4]]meineListe = {"Or", "And", "Abs"};
Attributes[meineListe]Attributes[Evaluate[meineListe]]t[x_] = Table[x^n, {n,4}]Plot[t[x], {x, -1.5, 1.5}];Plot[Evaluate[t[x]], {x, -1.5, 1.5}];
Was ist passiert?
• Que s'est-il passé?
Vergleiche: • Comparer:
Head[x + y]FullForm[x + y]Head[FullForm[x + y]]FullForm[{x, y}]Head[{x, y}]FullForm[Cos[x^3 - 4 x^2]]Head[Cos[x^3 - 4 x^2]]Vergleiche: • Comparer:
FullForm[{x, y, z, w}]FullForm[x + y + z + w]{x, y, z, w} /. List -> Plus
Was ist passiert? Der "Kopf" ist ausgewechselt worden! Doch Mathematica kann noch mehr: Mit "Apply" lässt sich ein weiterer "Kopf" einem Ausdruck voranstellen:
• Que s'est-il passé? On a remplacé la "tête"! Mathematica peut cependant davantage. Pour "Apply" on peut placer devant une expression une autre "tête" encore.
FullForm[{x, y, z, w}]summe = Apply[Plus, {x, y, z, w}]FullForm[summe]Head[summe]Oder so: • Ou ainsi:
Apply[Plus, Range[1000]]
Das ist die Summe der natürlichen Zahlen von 1 bis 1000.
• Voici la somme des nombres naturels de 1 à 1000.
Studiere: • Etudier:
?Position?[[?PartneueListe = 2 Range[9]neueListe[[4]]Head[neueListe[[4]]]HoldForm[neueListe[[4]]]Bearbeite: • Travailer:
ausdruck = 4 + a - b + Cos[4 Pi x^z - 3]TreeForm[ausdruck]ausdruck[[3]]ausdruck[[4]]ausdruck[[4, 1]]ausdruck[[4, 1, 2]]
Was ist passiert? --- Studiere weiter die Funktion "Position":
• Que s'est-il passé? --- Continuer d'étudier la fonction "Position":
ausdruck1 = Expand[(r + s + w)^3]Position[ausdruck1,r]Position[ausdruck1,s]
Deute diesen Output! --- Damit kann man auch komponieren:
Interpréter cet output! --- On peut aussi en faire des compositions:
u = {ausdruck1[[2]], ausdruck1[[2,2]],
ausdruck1[[2,2,1]], ausdruck1[[5,2]]}v = Apply[Plus, u]v /. r->3Studiere: • Etudier
?InfinityHead[Infinity]1 a0 a0 50 Infinity?LimitLimit[1/x, x->0]Limit[Log[x], x->0]Head[-Infinity]FullForm[-Infinity]Limit[Log[1/x], x->0]-5 Infinity7 / 0?ComplexInfinity0 / 0?IndeterminateStudiere: • Etudier:
?MemoryInUseBeispiele: • Exemples:
MemoryInUse[]
"Putzmaschine" einsetzen:
• Effacer:
Remove["Global`@*"]MemoryInUse[]t = 1;MemoryInUse[]
Was hat t sowie die ausgeführten Operationen "gekostet"?
• Qu'est-ce que t ainsi que les opérations exécutées ont-ils "coûté"?
vorher = MemoryInUse[]Table[Random[],{10000}];nachher = MemoryInUse[]N[nachher - vorher] / 1000
Wieviel Speicher hat Mathematica "verbraten"?
• Combien de mémoire Mathematica a-t-il "gaspillé"?
Studiere: • Etudier:
( Clear[a, b];
vorher1 = MemoryInUse[];
a = Table[Random[],{10000}];
nachher1 = MemoryInUse[];
b = a;
nachher2 = MemoryInUse[];
{nachher1 - vorher1, nachher2- nachher1}
)
Beachte: b hat keinen Speicher mehr belegt. b belegt erst dann Speicher, wenn a manipuliert wird. Offenbar gibt es von a und b aus Zeiger auf diesselbe Speicheradresse. Das kann mit der Funktion "Share" auch künstlich bewirkt werden. Im folgenden Beispiel werden 1000 Pseudozufallszahlen im Intervall zwischen 10'000 und 10'100 gerechnet. Da dieses Intervall nur 100 Zahlen enthält, gibt es sicher Duplikate. Mit "Share" kann dabei eine Mehrfachspeicherung vermieden werden. Probiere:
• Retenir: b n'a pas plus occupé de mémoire. b occupe la mémoire seulement si l'on manipule a. Il est évident qu'il a de a et de b des indicateurs pour la même adresse dans la mémoire. On peut obtenir cela aussi artificiellement par la fonction "Share". Dans l'exemple suivant on calcule 1'000 nombres pseudo-aléatoires dans l'intervalle entre 10'000 et 10'100. Comme cet intervalle ne compte que 100 nombres, il y aura certainement des doubles. Par "Share" on peut éviter une mise en mémoire répétitive. Essaie:
?Share( Clear[c];
vorherSpeicher = MemoryInUse[];
c = Table[Random[Integer, {10000, 10100}],
{10000}];
nachherSpeicher = MemoryInUse[];
c = Share[c];
nachherShare = MemoryInUse[];
{nachherSpeicher - vorherSpeicher,
nachherShare- vorherSpeicher}
)Probiere: • Essaie:
?ByteCountt = 2ByteCount[t]ByteCount[neueVariable]neueVariable = 1;ByteCount[neueVariable]ByteCount[a]ByteCount[{a, b}]
Beispiele für Speicherbelegung:
• Exemple pour l'occupation de mémoire:
z = 15; {Head[z], ByteCount[z]}z = 1; {Head[z], ByteCount[z]}z = 100; {Head[z], ByteCount[z]}z = 1000000000000000; {Head[z], ByteCount[z]}z = 3.1; {Head[z], ByteCount[z]}z = 3.14159666666666; {Head[z], ByteCount[z]}z = 3/8; {Head[z], ByteCount[z]}z = 3 + 5 I; {Head[z], ByteCount[z]}z = Range[10]; {Head[z], ByteCount[z]}z = Range[10000]; {Head[z], ByteCount[z]}z = "tschou"; {Head[z], ByteCount[z]}z = "t"; {Head[z], ByteCount[z]}z = "tschou zaeaeaeaeaeaemmaeaeaeaeaeaeaeae";
{Head[z], ByteCount[z]}Remove["Global`@*"]a) 35 a
FullForm[35a]b) a 35
FullForm[a35]c) - x
FullForm[-x]d) - 3
FullForm[-3]e) x - 3
FullForm[x - 3]f) 3 - x
FullForm[3 - x]g) Sqrt[5]
FullForm[Sqrt[5]]h) Series[Tan[x],{x,0,9}]
Series[Tan[x],{x,0,9}]FullForm[Series[Tan[x],{x,0,9}]]
g) Normal[Series[Tan[x],{x,0,9}]]
Normal[FullForm[Series[Tan[x],{x,0,9}]]]x^y^z
2^3^4x^(y^z)
2^(3^4)(x^y)^z
(2^3)^4x^y^z
2^3^4FullForm[2^3^4]x^(y^z)
2^(3^4)FullForm[2^(3^4)](x^y)^z
(2^3)^4FullForm[(2^3)^4]
Operation:
Liste von 1000 Integer-Zufallszahlen zwischen 100 und 200 rechnen:
• Opération:
Calculer une liste de 1000 nombres aléatoires "Integer" entre 100 et 200:
aufruf1 = MemoryInUse[];
kleineInt = Table[Random[Integer,{100,200}],
{1000}];aufruf2 = MemoryInUse[];
aufruf2 - aufruf1
Operation:
Liste von 1'000 Integer-Zufallszahlen zwischen 300 und 400 rechnen:
• Opération:
Calculer une liste de 1'000 nombres aléatoires integer entre 300 et 400:
kleineInt = Table[Random[Integer,{300,400}],
{1000}];aufruf3 = MemoryInUse[];
aufruf3 - aufruf2
Wieviel Memory ist mehr benutzt worden?
(Mathematica ist so gebaut worden, weil eine Klasse mehr benutzt wird...)
• Combien de mémoire en plus a-t-on occupé?
(Mathematica a été construit ainsi, parce qu'on utilise une classe de plus...)
Operation:
Liste von 1'000 Real-Zufallszahlen (default-Präzision) rechnen:
• Opération:
Calculer une liste de 1'000 nombres aléatoires réels (précision default):
realInt = Table[Random[],{1000}];aufruf4 = MemoryInUse[];
aufruf4 - aufruf3
Annahme: Zur Speicherung einer Floating-point-Zahl braucht es 32 = 2^5 Bytes.
• Supposition: Pour mémoriser un nombre à virgule flottante on utilise
32 = 2^5 bytes.
NSolve[2^x==10^6,x]
1 Mb entspricht etwa 2^20 Bytes.
• 1 Mb correspond à environ 2^20 bytes.
Anzahl Floating-point Zahlen in 4 Mb:
• Nombre (quantité) de nombres à virgule flottante dans 4 Mb:
a = 4 2^19.9316/2^5
Seitenlänge der quadratischen Matrix:
• Longueur d'un côté de la matrice carrée:
s = Floor[Sqrt[a]]Remove["Global`@*"]
Erst "Clear", damit keine Ueberraschung auftritt! Beispiel: Quadrieren...
• D'abord "Clear", pour ne pas avoir de susrprise! Exemple: Elever au carré...
Clear[quadrat];
quadrat[x]:=x^2;
quadrat[x]{quadrat[y], quadrat[5], quadrat[12]}
Offenbar klappt es bei dieser Funktion nicht mit demVariablenwechsel resp. mit dem Einsetzen von Werten. Wieso?
• Il est évident que le changement de variables ne fonctionne pas pour cette fonction, le placement de valeurs non plus. Pourquoi?
??quadrat?_
Die Variable x ist kein "Muster", das für irgend einen andern Ausdruck oder Wert stehen kann. Nehmen wir "x_" statt "x", so klappt es:
• La variable x n'est pas un "patron" qui peut remplacer une expression ou une valeur quelconque. Si nous prenons "x_" au lieu de "x", cela fonctionne:
Clear[quadrat1];
quadrat1[x_]:=x^2;
quadrat1[x]{quadrat1[y], quadrat1[5], quadrat1[12]}??quadrat1Oder: • Ou:
Table[quadrat1[n],{n,12}]Oder: • Ou:
quadrat1[9z^3+2z-1]quadrat1[9z^3+2z-1] // ExpandOder: • Ou:
Ein Beispiel, dass alles sagt (Cosinus-Satz):
• Un exemple qui dit tout (théorème du cosinus):
Clear[c];
c[a_, b_, gamma_] = Sqrt[a^2 + b^2
- 2 a b Cos[gamma]];
c[u, v, w]c[3, 5, Pi/3]
Beispiel: Umrechnung in Polarkoordinaten:
• Exemple: Transformation en coordonnées polaires:
PolarTransformation[r_, phi_] := (
x = r Cos[phi];
y = r Sin[phi];
{x, y} );
PolarTransformation[a, b]
Neudefinition: Die Umrechnung in Polarkoordinaten könnte auch für einen Vektor aufgerufen werden. Daher ist eine zweite Definition ratsam:
• Nouvelle définition: La transformation en coordonnées polaires pourrait être appelée aussi pour un vecteur. C'est pourquoi on conseille une deuxième définition:
PolarTransformation[{r_, phi_}] :=
PolarTransformation[r, phi];
PolarTransformation[{a, b}]PolarTransformation[{3, 2}]PolarTransformation[3, 2]PolarTransformation[3, 2] // N
"f[arg_typ]" funktioniert nur, falls gilt "Head[arg] === typ". Probiere:
•
"f[arg_typ]" fonctionne seulement s'il vaut "Head[arg] === typ". Essaie:
?BinomialClear[pascal];
pascal[n_Integer]:=Table[Binomial[n,i],{i,0,n}];pascal[0]pascal[1]pascal[2]pascal[3]pascal[4]pascal[5]pascal[5.6]pascal[6/5]
Ein anderes Beispiel (ausprobieren):
• Autre exemple (essayer):
Clear[mittelWert];mittelWert[x_List] := Apply[Plus, x]/Length[x];
mittelWert[{1,2,3,4,5}]mittelWert[1,2,3,4,5]
Test, ob ein Ausdruck ein Polynom, eine Primzahl, ein Vektor u.s.w. ist, d.h. ob ein Ausdruck unter einer Prädikatenfunktion "wahr" ergibt. Beispiel:
• Tester si une expression est un polynôme, un nombre premier, un vecteur etc., c'est-à-dire, si une expression est "vraie" sous une fonction de prédicats. Exemple:
?*Q{PrimeQ[45], PrimeQ[17]}
Anwendung auf die Definition einer Funktion:
• Application à la définition d'une fonction:
Clear[halb];
halb[x_?EvenQ] := x/2;
{halb[1], halb[2], halb[3], halb[4], halb[5]}{halb[2], halb[4], halb[6], halb[8], halb[9]}
Was ist passiert?
• Que s'est-il passé?
Ein Beispiel in mehreren Schritten:
• Un exemple en plusieurs étapes:
Remove[signum];
signum[0 ] := 0;
signum[x_/; Positive[x]==True ] := 1;
signum[x_/; Negative[x]==True ] := -1;{signum[3], signum[-1], signum[0], signum[2]}??Positive??IntegerPositive[1]signum[1]??signum
Bei der Definition von "signum" ist in der Klammer "[ ]" nach "x_" das Symbol "/;" angegeben. Darauf folgt jeweils eine Bedingung! Damit können Funktionen punktweise oder intervallweise definiert werden!!!!!! Anwendungen:
• Dans la définition de "signum", le symbole "/;" est indiqué dans la parenthèse "[ ]" après "x_". Il suit chaque fois une condition! Ainsi on peut définir des fonctions ponctuellement ou par intervalles! Applications:
Plot[signum[x], {x, -3, 3}];Oder: • Ou:
Clear[rechteck];
rechteck[x_/; (-1<=x && x<=1) ]:= 2;
rechteck[x_/; Abs[x] > 1 ]:= 0;
Plot[rechteck[x], {x, -3, 3}];
Etwas "schöner":
• Un peu plus esthétiquement:
Plot[rechteck[x], {x, -3, 3},
PlotStyle -> {{Thickness[0.01],
GrayLevel[0.4]}}];
Solche Funktionen können sogar integriert werden:
• On peut même intégrer de telles fonctions:
??rechteckNIntegrate[rechteck[x], {x, -1, 1}]NIntegrate[rechteck[x], {x, -3, 3}]
Was ist passiert? Studiere:
• Que s'est-il passé? Etudie:
?WhichRemove[funkt];
funkt[x_] := Which[x<=Pi,-2 Sin[x],x>Pi,
(x^1.3-Pi^1.3) Cos[x]];
Plot[funkt[x],{x,-2Pi,3Pi}];Remove[funkt];
funkt[x_] := Which[x<=Pi,2 Sin[x],x>Pi,
(x^1.3-Pi^1.3) Cos[x]];
Plot[funkt[x],{x,-2Pi,3Pi}];
Das Muster "x_." bewirkt, dass x "default" mit dem neutralen Element der am
"stärksten" mit x verknüpften Operation belegt wird. Dazu ein Beispiel:
• Le patron "x_." fait que x "default" est occupé par l'élément neutre de l'opération qui est le plus "fortement" lié à x. Voici un exemple:
Clear[f];
f[x_. + y_. z_.^e_.] := {x, y, z, e};
Clear[f];
f[x_. + y_. z_^e_.] := {x, y, z, e};
?ff[4]{f[0], f[1], f[2], f[3], f[4], f[5]}{x, y, z, e}
Finde heraus, welche Werte "default" jeweils für x, y, z und e genommen worden sind und wieso!
• Cherche quelles valeurs "default" ont été prises respectivement pour x, y, z et e et pour quelle raison!
Das Muster "x_:Wert" bewirkt, dass x "default" mit Wert belegt wird. Dazu ein Beispiel:
• Le patron "x_:Valeur" fait que x "default" est occupé par valeur. Voici un exemple:
Clear[UnserBereich];
UnserBereich[start_:34, ziel_] :=
Range[start, ziel];
UnserBereich[100]UnserBereich[80, 100]UnserBereich[36]UnserBereich[34]UnserBereich[30]
Mathematica bearbeitet die spezielleren Regeln vor den generelleren Regeln. Mit "?" kann die Abarbeitungshierarchie eingesehen werden.
• Mathematica travaille les règles spéciales avant les règles générales. Avec "?" on peut voir la hiérarchie de travail.
Clear[r];
r[x_] := x^2;
r[x_Integer]:= x;
r[5] := 11;
?r
Beachte, dass die Reihenfolge der Ausgabe nicht mit der der Eingabe übereinstimmt. Wieso wohl?
Considère que l'ordre de la sortie ne correspond pas à celui de l'entrée. Pourquoi?
{r[5], r[5.5], r[6], r[r.5], r[7]}
Z.B. f[x_] + g[x_] := h[x_] "funktioniert" nicht. Beispiel:
• P.ex. f[x_] + g[x_] := h[x_] ne "fonctionne" pas. Exemple:
f[x_] + g[x_] := h[x_]
Wie lässt sich das Funktionieren trotzdem erzwingen? -
Dafür ist das Symbol "f/ : " vorgesehen. Studiere das folgende Beispiel:
• Comment obtenir quand même le fonctionnement? -
Pour cela est prévu le symbole "f/ : ". Etudie l'exemple suivant:
Remove[f];
f/: f[x_] + g[x_] := h[x_] ?ff[5] + g[5]
f wird hier assoziiert mit f[x]+g[x] := h[x]. Wird f[x]+g[x] gerufen, so erscheint h[x]. Andernfalls erscheint f[x] oder f[x1]+g[x2].
• Ici on associe f avec f[x]+g[x] := h[x]. Si on appelle f[x]+g[x], il arrive h[x]. Autrement il apparaît f[x] ou f[x1]+g[x2].
f[5]f[5] + g[6]Beispiel: • Exemple:
Remove[f];
f/: f[x_] + Sin[x_] := x^3;
f[3] + Sin[3]Vergleiche: • Compare:
??_?_.?:?/;???
Beachte, dass die Regel s[-x_] :> -s[x] den Ausdruck s[-a] in -s[a] transformiert, s[-3] aber nicht transformiert. Was wird mit s[1-x] geschehen und wieso?
• Considère que la règle s[-x_] :> -s[x] transforme l'expression s[-a] en -s[a], mais ne transforme pas s[-3]. Que se passe-t-il avec s[1-x] et pourquoi?
sRegel = s[-x_] :> -s[x]s[-a] /. sRegels[-3] /. sRegel
Wieso geschieht das? Beobachte, wie Mathematica -a und -3 interpretiert:
• Pourquoi cela arrive-t-il? Observe comment Mathematica interprète -a et -3:
FullForm[-a]FullForm[-3]
Der Ausdruck -a ist mit dem Muster -(x_) verträglich, der Ausdruck -3 nicht.
• L'expression -a est compatible avec le patron -(x_), l'expression -3 ne l'est pas.
FullForm[1-x]
Der Ausdruck (1-x) ist mit dem Muster -(x_) nicht verträglich:
• L'expression (1-x) n'est pas compatible avec le patron -(x_).
s[1-x] /. sRegel
Bisher ist öfters schon das Symbol "?" erschienen. Damit ist einige Information abrufbar. Beispiel:
• Jusqu'à présent le symbole "?" est apparu plusieurs fois. Par cela on peut appeler bien de l'information. Exemple:
?f?Sin??Sin
Manchmal möchte man aber gern dem System eigene Kommentare einverleiben, die dann wieder abgerufen werden können. Das ist möglicn mit "...::usage=...".
Beispiel: Wir verwenden die oben definierte Funktion "pascal".
• Parfois on aimerait incorporer au système ses propres commentaires, qu'on pourrait de nouveau appeler. Cela est possible avec "...::usage=...".
Exemple: Nous employons la fonction "pascal" définie ci-dessus.
Clear[pascal];
pascal[n_Integer]:=Table[Binomial[n,i],{i,0,n}];?pascal
Wir fügen nun an:
• Nous ajoutons:
pascal::usage = "pascal[n] gibt die n-te Zeile
des Pascalschen Dreiecks aus - sort la ligne n
du triangle de Pascal."Abfragen: • Appeler:
?pascal??pascal
Gute Sache, nicht?
• C'est bon, n'est-ce pas?
Funktionen haben Attribute. Beispiel "Sinus":
• Les fonctions ont des attributs. Exemple "Sinus":
Attributes[Sin]??Attributes??Attributes
Die möglichen Attribute sind vom System vorgegeben. Einige Beispiele:
• Les attributs possibles sont donnés par le système. Quelques exemples:
??Constant?Flat?Hold*?HoldAll?HoldFirst?HoldRest?Listable?Locked?Orderless?Protected?ReadProtected
Folgende Reihenfolge ist im System voreingestellt: Zuerst Kopf des Ausdrucks abarbeiten. Dann Elemente (Teile) des Ausdrucks abarbeiten.
Wenn ein Element kein Atomarer Ausdruck ist: Teile des Elements abarbeiten etc.. Dieses Procedere wird rekursiv angewandt.
• L'ordre suivant est déjà réglé dans le système: Travailler d'abord l'en-tête de l'expression. Travailler ensuite les éléments (parties) de l'expression. Si un élément n'est pas une expression atomique: Procéder par parties etc.. Ce procédé est appliqué récursivement.
Wenn ein Element oder Ausdruck das Attribut HoldFirst, HoldAll, HoldRest hat oder die Funktion Evaluate aufruft, wird die Voreinstellung durchbrochen. Erkunde, wo solche Attribute vorkommen:
• Quand un élément en une expression a l'attribut HoldFirst, HoldAll, HoldRest ou appellent la fonction Evaluate, le règlement préalable est interrompu. Cherche où se trouvent de tels attributs:
??Sin??Plot??Table??Attributes??Evaluate
Vergleiche die Resultate bei Abänderung der Abarbeitungsreihenfolge und erkläre den Unterschied der Resultate:
• Compare les résultats lors des changements de l'ordre de travail et explique la différence des résultats:
Table[Random[], {5}]Table[Evaluate[Random[]], {5}]
Wieso kommt das so, wie es kommt?
• Pourquoi cela se déroule ainsi?
Ein Beispiel:
• Un exemple:
Clear[ungerade, t];
ungerade[x_?OddQ ] := (ungerade[x] = 1);
ungerade[x_?EvenQ] := (ungerade[x] = -1);
t = Table[ungerade[x], {x,1, 15}]ListPlot[t, PlotStyle -> PointSize[0.04]];?ListPlotRemove["Global`@*"]Definition: • Définition:
f[2] = 3 ;
f[u] := 2 u^2;
f[v_]:= 1/v ;
u = 2;
Was ist f[u] ?
• Qu'est-ce f[u] ?
f[u]
Was ist mit f passiert? Untersuche die möglichen Graphen!
Que s'est-il passé? Examine les graphes possibles!
Plot[f[x],{x,0.5,6}];Plot[f[u],{x,0.5,6}];f[2]
Was ist passiert?
• Que s'est-il passé?
Definition: • Définition:
Clear[f];
f[x_?OddQ] := (x+1)/2Ausprobieren: • Essayer:
f[3.2]f[3]f[2]Was ist passiert? • Que s'est-il passé?
Wende mit "Map" die Funktion an auf die Liste {{1, 1}, {2, 2}}.
• Applique par "Map" la fonction à la liste {{1, 1}, {2, 2}}.
Clear[verdoppelnY];
verdoppelnY[{x_, y_}]:={x, 2y}Map[verdoppelnY, {{1, 1},{2, 2}}]
Was macht "Map" hier?
• Que fait "Map" ici?
dreieck[x] ist gleich 1 - Abs[x] für x<1. Sonst ist der Funktionswert null.
Mache einen Plot!
• dreieck[x] est égal 1 - Abs[x] pour x<1. Autrement la valeur de la fonction est zéro. Fais un plot!
Clear[dreieck];
dreieck[x_/; (-1<=x && x<=1)]:= 1 - Abs[x];
dreieck[x_/; Abs[x]>1]:= 0;
Plot[dreieck[x],{x,-3,3},PlotStyle -> {{
Thickness[0.01],GrayLevel[0.5]}}];
signum[x] ist gleich 1 für x>0, -1 für x<0 und 0 für x=0. Mache einen Plot! (Definiere dazu signum für Floating-Point-Zahlen 0.0!) Schreibe einen Kommentar für die Dokumentation!
• signum[x] est égal 1 pour x>0, -1 pour x<0 et 0 pour x=0. Fais un plot. (Définis signum pour les nombres à virgule flottante 0.0!) Ecris un commentaire pour la documentation!
Clear[signum];
signum[0] = 0 ;
signum[x_/; x>0]:= 1 ;
signum[x_/; x<0]:= -1;
signum::usage="signum[x] ist gleich 1 für
positive x, -1 für negative x und 0 für
x = 0 - est égal 1 pour x positif, -1 pour
x négatif et 0 pour x = 0.";
Plot[signum[x],{x,-3,3},PlotStyle -> {{
Thickness[0.01],GrayLevel[0.5]}}];Clear[signum];
signum[0.] = 0. ; (*Geändert!*)
signum[x_/; x>0]:= 1 ;
signum[x_/; x<0]:= -1;
signum::usage="signum[x] ist gleich 1 für
positive x, -1 für negative x und 0 für
x = 0 - est égal 1 pour x positif, -1 pour
x négatif et 0 pour x = 0.";
Plot[signum[x],{x,-3,3},PlotStyle -> {{
Thickness[0.01],GrayLevel[0.5]}}];?signum??signum
myRange[x] gibt für ein positives Integer-Argument n die Zahlen von 0 bis n aus. Für zwei Argumente m und n mit "n < m" gibt die Funktion alle natürlichen Zahlen von n bis m aus. Für drei Argumente n, m und d gibt sie die Zahlen n, n+d, n+2d, ... , n+kd aus mit n+kd<m.
• myRange[x] sort pour un argument Integer positif n les nombres de 0 à n. Pour deux arguments m et n avec "n < m", la fonction sort tous les nombres naturels de n à m. Pour trois arguments n, m et d, elle sort les nombres n, n+d, n+2d, ... , n+kd avec n+kd<m.
Clear[myRange];
myRange[n_?Integer,m_?Integer,d_?Integer/;
{n>=0 && m>=n && d>=0}]:= Range[n,m,d];
myRange[n_?Integer,m_?Integer /;
{n>=0 && m>=n}]:= Range[n,m];
myRange[start_:0, n_?Integer /; n>=0]:=
Range[start,n];
Print[{6,Range[6]}];
Print[{-6,Range[-6]}];
Print[{0,Range[0]}];
Print[{{5,11},Range[{5,11}]}];
Print[{5,11,Range[5,11]}];
Print[{5,-3,Range[5,-3]}];
Print[{5,3,Range[5,3]}];
Print[{5,18,4,Range[5,18,4]}];
Beachte, dass die Regel "s[-x_] :> -s[x]" den Ausdruck "s[-a]" in "-s[a]" transformiert, "s[-3]" aber nicht transformiert. Was wird mit "s[1-x]" geschehen und wieso?
• Considère que la règle "s[-x_] :> -s[x]" transforme l'expression "s[-a]" en "-s[a]", mais ne transforme pas "s[-3]". Que se passe-t-il avec "s[1-x]" et pourquoi?
sRegel = s[-x_] :> -s[x]s[-a] /. sRegels[-3] /. sRegel
Wieso geschieht das? Beobachte, wie Mathematica -a und -3 interpretiert:
• Pourquoi cela arrive-t-il? Observe, comme Mathematica interprète -a et -3:
FullForm[-a]FullForm[-3]
Der Ausdruck -a ist mit dem Muster -(x_) verträglich, der Ausdruck -3 nicht.
• L'expression -a est compatible avec le patron -(x_) , l'expression -3 ne l'est pas.
FullForm[1-x]
Der Ausdruck (1-x) ist mit dem Muster -(x_) nicht verträglich:
• L'expression (1-x) n'est pas compatible avec le patron -(x_):
s[1-x] /. sRegel
Definiere die rekursive Funktion piDurchVier[n_] um approximativ Pi/4 zu berechnen wie folgt:
• Définis la fonction récursive piDurchVier[n_] pour calculer approximativement Pi/4 comme il suit:
Pi/4 ist etwa: • Pi/4 est environ:
2*4*4*6*6*8*8*10*10...2n / (3*3*5*5*7*7*9*9*...(2n+1)).
Entwickle: • Développe:
piDurchVier[1] = 2/3
piDurchVier[2] = 2*4*4/(3*3*5) = piDurchVier[1 ]*4*4/(3*5)
piDurchVier[3] = 2*4*4*6*6/(3*3*5*5*7)
= piDurchVier[2 ]*6*6/(5*7)
piDurchVier[4] = piDurchVier[3 ]*8*8/(7*9)
RemoveAll[piDurchVier];
piDurchVier[1] = 2/3;
piDurchVier[n_] :=
piDurchVier[n-1] (2n)^2 / ((2n-1)(2n+1));
??piDurchVierTable[piDurchVier[i],{i,5}]Table[piDurchVier[i],{i,5}] // NKontrolle: • Contrôle:
N[Pi/4,10]N[piDurchVier[200]]
Was hälst Du von der Sache?
• Qu'en penses-tu?
Bestimme die Funktionen, deren Namen mit den Buchstaben A - E beginnen und das Attribut "Listable" haben.
Hinweis: Was tun die Funktionen "Names", "MemberQ", "Attributes" und "Select"?
• Détermine les fonctions dont le nom commence par les lettres A - E et qui ont l'attribut "Listable".
Indication: Que font les fonctions "Names", "MembreQ", "Attributes" et "Select"?
??Names??MemberQ??Attributes??Select
Suche alle "Listablen" Funktionen:
• Cherche toutes les fonctions "Listables":
RemoveAll[listbareQ];
listbareQ[symbol_String]:=
MemberQ[Attributes[symbol], Listable]
Was tun die Teile?
• Qu'en font les parties?
Attributes["Cos"]MemberQ[Attributes["Cos"], Listable]listbareQ["Cos"]
Versuchen wir, die Funktionen zu bestimmen:
• Essayons de déterminer les fonctions:
Select[Names["A* B* C* D* E*"], listbareQ]Select[Names["A*"], listbareQ]Select[Names["B*"], listbareQ]Select[Names["F*S*"], listbareQ]sN[x_]:=Select[Names[x], listbareQ]sN["A*"]Union[sN["A*"],sN["B*"],sN["C*"],sN["D*"],
sN["E*"]]Remove["Global`@*"]
Mathematica stört es nicht, dass im folgenden Beispiel zweimal dieselbe globale Variable (hier "i") in verschiedenen Bedeutungen gebraucht wird:
• Cela ne dérange pas Mathematica que dans l'exemple suivant on emploie deux fois la même variable globale (ici "i") avec deux significations différentes:
f[n_]:=Table[g[i], {i,n}];
g[m_]:=Table[Log[i],{i,m}];f[3]??iZum Vergleich: • Pour comparer:
f[n_]:=Table[g[i], {i,n}];
g[m_]:=Table[Log[j],{j,m}];f[3]??Block
Betrachte das folgende Beispiel:
• Considère l'exemple suivant:
Clear[f,g];
f[n_] := Block[{i}, Table[ g[i], {i, n}]];
g[m_] := Block[{i}, Table[Log[i], {i, m}]]Ausprobieren: • Essayer:
i?ff[n]f[3]f[5]i
Was ist passiert? (Welcher Wert ist in "i" gespeichert?) Betrachte:
• Que s'est-il passé? (Quelle valeur est mémorisée dans "i"?) Considère:
Clear[f,];
Block[{i}, i]??Module
Vergleiche mit dem letzten Beispiel:
• Compare au dernier exemple:
Clear[f,];
Module[{i}, i]
Was bedeutet wohl die ausgegebene Zahl?
• Que signifie le nombre sorti?
Betrachte das folgende Beispiel:
• Considère l'exemple suivant:
Clear[f,g];
f[n_] := Module[{i}, Table[ g[i], {i, n}]];
g[m_] := Module[{i}, Table[Log[i], {i, m}]]Ausprobieren: • Essayer:
?ff[n]f[3]f[5]i
Was ist passiert? (Welcher Wert ist in "i" gespeichert?)
• Que s'est-il passé? (Quelle valeur est mémorisée dans "i"?)
Damit lassen sich Ausdrücke manipulieren:
• Par cela on peut manipuler des expressions:
?WithWith[{x=2, y=a, z=b^3}, y Log[x^z]]Clear[x,y,z,r,s];
Solve[{x+2==r-s,s+1==y+2z,2r+z==-4x},{x,r}]With[{z=4, s=Sin[z^2]},
Solve[{x+2==r-s,s+1==y+2z,2r+z==-4x},{x,r}]]
Mathematica erlaubt prozedurale Programmierung, d.h. Befehlssequenzen mit
Wiederholungen und Verzweigungen. Studiere die folgenden Befehle:
• Mathematica permet la programmation procédurale, c'est-à-dire des séquences d'ordres avec des répétitions et des ramifications. Etudier les ordres suivants:
??Do?For?While?If?Which?Switch
Studiere die folgenden Beispiele:
• Etudie les exemples suivants:
??++?+=?-=?*=?/=?DivideByi=1++iii++iii +=6i -=5i *=7i /=4
Studiere die folgenden Beispiele:
• Etudie les exemples suivants:
Do[Print[3 n^2], {n,7}]For[n=1, n<=7, ++n, Print[3 n^2]]n=1;
While[n<=7, (Print[3 n^2]; n++)]
Studiere die folgenden Befehle:
• Etudie les ordres suivants:
?&&?And?||?Or?!?Not?Xor
Studiere die folgenden Beispiele:
• Etudie les exemples suivants:
(1 < 2) || (4 > 5/0) (4 > 5/0) || (1 < 2)
Von wo her wird also geklammert?
• D'où viennent les parenthèses?
Ein Beispiel: Die folgende Aussageform soll untersucht werden:
• Un exemple: La forme propositionelle suivante soit examinée:
Clear[f];
f[x_:0, y_:0, z_:0, w_:0, u_:0, v_:0]:=
!(!x || (x && y)) || (x || ! y) && w;
AppendTo[Attributes[f], Listable]??f
Die nachstehende Funktion definiert den "Input" in die Wahrheitstabelle:
• La fonction ci-dessous définit l'"Input" dans le tableau de vérité:
Remove[tabteil,tabelle];
tabteil[n_, k_]:= Permutations[
Table[Ceiling[Floor[n/i]/k],
{i,1,k}]];
tabelle = {};
t[k_]:=(Do[AppendTo[tabelle,tabteil[n,k]],
{n,0,k}];
tabelle = Sort[Flatten[tabelle,1]];
(tabelleTF=tabelle /. {0->False,
1->True});
Print[MatrixForm[tabelle]];
MatrixForm[tabelleTF]);
t[3]Remove[tabteil,tabelle];
tabteil[n_, k_]:= Permutations[
Table[Ceiling[Floor[n/i]/k],
{i,1,k}]];
tabelle = {};
t[k_]:=(Do[AppendTo[tabelle,tabteil[n,k]],
{n,0,k}];
tabelle = Sort[Flatten[tabelle,1]];
(tabelleTF=tabelle /. {0->False,
1->True});
Print[MatrixForm[tabelle]];
MatrixForm[tabelleTF]);
t[4]
Und hier der "Output" in der entsprechenden Reihenfolge:
• Et voici l'"Output" dans l'ordre correspondant:
??Mapf @@ Transpose[tabelleTF]MatrixForm[Transpose[
Join[Transpose[tabelleTF],
{Table["|",{i,1,
Length[f @@ Transpose[tabelleTF]]}]},
{f @@ Transpose[tabelleTF]}]]]Remove[tabteil,tabelle];
tabteil[n_, k_]:= Permutations[
Table[Ceiling[Floor[n/i]/k],
{i,1,k}]];
tabelle = {};
t[k_]:=(Do[AppendTo[tabelle,tabteil[n,k]],
{n,0,k}];
tabelle = Sort[Flatten[tabelle,1]];
(tabelleTF=tabelle /. {0->False,
1->True});
MatrixForm[Transpose[
Join[Transpose[tabelleTF],
{Table["|",{i,1,
Length[f @@ Transpose[tabelleTF]]}]},
{f @@ Transpose[tabelleTF]}]]]);
(*Anwendung*)
t[5]
Probiere aus: • Essaie:
?If?PrintFormPrintForm[Print"gagag"]?HorizontalForm?Write?WriteString?SequenceFormClear[t];
Do[(t=Table[(If[Random[]>0.5,
SequenceForm["omumo"],SequenceForm["wvovw"],
SequenceForm["bubu"]]),{i,7}];
Print[t[[1]],t[[2]],t[[3]],t[[4]],t[[5]],
t[[6]],t[[7]]]),{k,25}]
Verzweigung je nach Mathematica-Version:
• Ramification selon la version de Mathematica:
If[$VersionNumber < 2.0,
Plot[E^(-x^2) Cos[20x],{x,-2,2},Framed->True],
Plot[E^(-x^2) Cos[20x],{x,-2,2},Frame ->True]];Mit Switch: • Avec Switch:
x=Random[Integer,{1,5}];
Print[x];
Switch[x^2,1,x,4,2x,9,3x,16,4x,25,-5x]x=Random[Integer,{1,5}];
Print[x];
Switch[x^2,1,x,4,2x,9,3x,16,4x,25,-5x]x=Random[Integer,{1,5}];
Print[x];
Switch[x^2,1,x,4,2x,9,3x,16,4x,25,-5x]Mit Which: • Avec Which:
signum[x_]:=Which[x<0.,-1,x==0.,0,x>0.,1]Plot[signum[x],{x,-3,3}];
Davon ist abzuraten!
• On le déconseille!
?Goto?Label?Throw?CatchDer Median: • La médiane:
median[liste_List]:=
Block[{
sl,
len
},
len = Length[liste];
sl = Sort[liste];
If[
OddQ[len],
sl[[(len+1)/2]],
(sl[[len/2]]+sl[[len/2+1]])/2
]
] median[{53,64,78,24,63,78}] // Nmedian[{76, 56, 23, 78, 34}]median[{0,1,2,3,4,5,6}]median[{1,2,3,4,5,6}] // Nmedian[{1,2,3,4,5,6,7}]
Was ist der Median?
• Qu'est-ce la médiane?
Remove["Global`@*"]
Starte mit dem Wert 2. Berechne die Wurzel mit der Formel x(i+1)=(x(i)+2/x(i))/2. Erkläre wie diese Formel entsteht. (Löse x^2 - 2 = 0 ...)
• Démarre avec la valeur 2. Calcule la racine par la formule x(i+1)=(x(i)+2/x(i))/2. Explique comment cette formule s'est formée. (Résous x^2 - 2 = 0 ...)
Clear[newtonMethode, counter, zahl, approx];
newtonMethode[x_]:=
Module[{
counter = 1,
zahl = N[x,30],
approx = N[x,40]
},
While[approx^2 != zahl,
Print[counter, ": ", N[approx,30]];
approx = (approx + 2/approx)/2;
++counter;
];
Print[counter, ": ", N[approx,30]];
]newtonMethode[2]Vergleich: • Comparaison:
N[Sqrt[2],30] Definition: • Définition:
Clear[f];
f[x_,y_,z_]:=
Module[{i,j,liste,min},
min=Min{x,y,z};
liste=Sort[{x,y,z}];
restQuadr=Rest[{x,y,z}]^2;
Print[Apply[Plus,restQuadr]]
]Ausprobieren: • Essayer:
{f[0,0,0],f[0,0,1],f[0,1,1],f[1,1,1],f[1,1,2],f[1,2,3]}f[3]
Was ist passiert?
• Que s'est-il passé?
Lösung von Nancy Blachman:
• Solution de Nancy Blachman:
Clear[makeFamily];
makeFamily[ ] :=
Module[{
children = {}
},
While[Random[Integer] == 0,
AppendTo[children, "girl"]
];
Append[children, "boy"]
]makeFamily::usage="makeFamily[ ] returns a list
of children."Clear[numChildren];
numChildren[n_Integer]:=
Module[{
allChildren
},
allChildren = Flatten[Table[
makeFamily[ ],{n}]];
{ avgChildren -> Length[
allChildren]/n,
avgBoys -> Count[allChildren,
"boy"]/n,
avgGirls -> Count[allChildren,
"girl"]/n
}
]numChildren::usage="numChildren[n] returns
statistics on the number of children
from n families."numChildren[1000]
Beim perfekten Mischen teilt der Spieler das Kartenspiel genau in der Mitte und mischt das Spiel im "Reissverschlussverfahren": Abwechslungsweise kommt von jeder Seite je eine Karte, wobei sicher sein muss, dass die erste Karte von der ersten Hälfte zuerst "hingelegt" wird (das Spiel wird umgekehrt gehalten). Z.B. wenn man ein Spiel mit 10 Karten hat, ursprünglich geordnet in der Reihenfolge {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, so ist es nach einmal perfektem Mischen in der Reihenfolge {1, 6, 2, 7, 3, 8, 4, 9, 5, 10}.
a) Schreibe eine Funktion "perfektMischen", die das perfekte Mischen einer geraden Anzahl von Karten simuliert.
b) Schreibe die Funktion "wiederOrdnung", die die Anzahl perfekter Mischungen berechnet um das Spiel wieder in die urspüngliche Ordnung zu bringen. Wieviel mal ist es bei 52 Karten?
•
Un joueur qui mélange les cartes à la perfection, divise le jeu de cartes exactement par la moitié et mélange les cartes par la méthode de la "fermeture éclair": De chaque côté il arrive une carte alternativement, mais on doit être sûr que la 1ère carte vient de la 1ère moitié (on tient le jeu à l'envers). P.ex. si on a un jeu de 10 cartes dans l'ordre d'origine {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, on obtient l'ordre suivant en mélangeant une fois {1, 6, 2, 7, 3, 8, 4, 9, 5, 10}.
a) Ecris une fonction "perfectMischen" qui simule un mélange parfait d'un nombre pair de cartes.
b) Ecris la fonction "wiederOrdnung" qui calcule le nombre de mélange parfaits pour remettre le jeu dans l'ordre d'origine. Combien de mélanges faut-il pour un jeu de 52 cartes?
Clear[mischen, perfektMischen, mischen1,
perfektMischen1];
mischen::usage="mischen[ ] erzeugt eine Liste
von perfekt gemischten Zahlen -- donne
une liste de nombres mélangés à la
perfection.";
mischen[n_]:=
Module[{matrix1,matrix2},
listeIn=Range[n];
matrix1=Partition[listeIn,n/2];
matrix2=Transpose[matrix1];
listeOut=Flatten[matrix2];
Print["Liste_In: ", listeIn, " ",
"Liste_Out: ", listeOut]
];
perfektMischen::usage="perfektMischen[ ] greift
auf den Modul mischen[ ] im Falle einer
eingegebenen geraden natuerlichen Zahl --
utilise le Modul mischen[ ] dans le cas
d-un nombre donné pair, naturel.";
perfektMischen[n_Integer]:=
Module[{listeIn},
If[(OddQ[n] || n <= 0),
Print["Bitte gerade, positive Zahl
eingeben -- S.v.p. entrer nombre positif
pair."], mischen[n],
Print["Bitte gerade, positive Zahl
eingeben -- S.v.p. entrer nombre positif
pair."]]
];
mischen1::usage="mischen1[ ] erzeugt eine Liste
von perfekt gemischten Zahlen ohne
Output -- donne une liste de nombres
mélangés à la perfection sans output.";
mischen1[n_]:=
Module[{matrix1,matrix2},
listeIn=Range[n];
matrix1=Partition[listeIn,n/2];
matrix2=Transpose[matrix1];
listeOut=Flatten[matrix2];
];
perfektMischen1::usage="perfektMischen1[ ]
greift auf den Modul mischen[ ]
im Falle einer eingegebenen geraden
natuerlichen Zahl. Im Unterschied zu
perfektMischen[ ]
wird hier die Ausgabe unterdruekt
-- utilise le Modul mischen[ ] dans le cas
d-un nombre donné pair, naturel. Par contre
à perfektMischen[ ] l-output est retenu.";
perfektMischen1[n_Integer]:=
Module[{},
If[(OddQ[n] || n <= 0),
Print["Bitte gerade, positive Zahl
eingeben -- S.v.p. entrer nombre positif
pair."], mischen1[n],
Print["Bitte gerade, positive Zahl
eingeben -- S.v.p. entrer nombre positif
pair."]]];perfektMischen[100]listeOutClear[mischenAnzahl];
mischenAnzahl::usage="mischenAnzahl[ ] greift auf
den Modul perfektMischen1[ ] und wendet
diesen an, bis die ursprüngliche
Reihenfolge wieder hergestellt ist. Ein
Zaehler zaehlt die Anzahl Mischablaeufe
-- utilise le Modul perfektMischen1[ ]
et l-utilise jusqu-à l-ordre original est
remis. Un compteur compte le nombre de
mélanges.";
mischenAnzahl[n_]:=
Module[{liste, counter=1, matrix1, matrix2},
mischen1[n];
liste =listeIn;
While[((listeOut != liste) &&
counter < 10000), Print[counter," ",
listeIn," ", listeOut];
matrix1=Partition[listeOut,n/2];
matrix2=Transpose[matrix1];
listeOut=Flatten[matrix2];
++counter;
]
Print[counter," ",listeIn," ", listeOut];
Print["Anzahl Mischungen --
Nombre de mélanges: ", counter];
]
perfektMischenAnzahl::usage="perfektMischenAnzahl[ ]
greift auf den Modul mischenAnzahl[ ] im
Falle einer eingegebenen geraden
natuerlichen Zahl --
utilise le Modul mischenAnzahl[ ] dans le
cas d-un nombre donné pair, naturel..";
perfektMischenAnzahl[n_Integer]:=
Module[{},
If[(OddQ[n] || n <= 0),
Print["Bitte gerade, positive Zahl
eingeben-- S.v.p. entrer nombre positif
pair."], mischenAnzahl[n],
Print["Bitte gerade, positive Zahl
eingeben-- S.v.p. entrer nombre positif
pair."]]]perfektMischenAnzahl[1]perfektMischenAnzahl[0]perfektMischenAnzahl[2]perfektMischenAnzahl[4]perfektMischenAnzahl[6]perfektMischenAnzahl[8]perfektMischenAnzahl[10]perfektMischenAnzahl[12]perfektMischenAnzahl[14]perfektMischenAnzahl[16]perfektMischenAnzahl[18](* perfektMischenAnzahl[20] *)(* perfektMischenAnzahl[52] *)
Betrachte die folgenden Beispiele. Sie sind bis auf die Anweisungen "Block" resp. "Module" identisch. Wieso gibt Mathematica verschiedene Resultate aus?
• Considère les exemples suivants. Ils sont identiques, sauf les directives "Block" resp. "Module". Pourquoi est-ce que Mathematica sort des résultats différents?
Clear[a, i];
a = i;
i = 3;
Block[{i},
Table[a, {i, 2}]
]Clear[a, i];
a = i;
i = 3;
Module[{i},
Table[a, {i, 2}]
]Remove["Global`@*"]
Bisher bekannte Variablen mit "_": Z.B. in f[x_]:=x wird bei der Anwendung f[y] x durch y ersetzt. Oder bei f[3] x durch 3. Oder bei f[x+2y-Sin[z]] wird x durch x+2y-Sin[z] ersetzt. Mathematica erkennt hier das "Muster" des zu ersetzenden Ausdrucks. Wie lässt sich damit z.B. der Mittelwert einer
beliebig grossen Zahlenmenge berechnen? Beispiel:
• Variables avec "_" déjà connues: P.ex. dans f[x_]:=x on remplace f[y] x par y à l'application.Ou dans f[3] x par 3. Ou dans f[x+2y-Sin[z]] on remplace x par x+2y-Sin[z]. Mathematica reconnaît ici le "patron" de l'expression à remplacer. Comment peut-on calculer p.ex. la valeur moyenne d'un ensemble d'une grandeur quelconque de nombres? Exemple:
mittel[a_]:= a;
mittel[a_, b_]:= (a+b)/2;
mittel[a_, b_, c_]:= (a+b+c)/3; (*etc. ....*)mittel[4,6]mittel[9]mittel[1,2,3]mittel[1,2,3,4]
Was tun? - Wir können auch das Symbol "__" (doppelter Unterstrich) verwenden resp. "___" (dreifach).
• Que faire? Nous pouvons employer aussi le symbole "__" (double sous-ligne) resp. "___" (triple).
??__?___Beispiel: • Exemple:
Remove[mittel];
mittel[x__] := Plus[x]/Length[{x}]mittel[1,2,3,4,5,6,7,8,9]mittel[a,b,c,d,e,f,g]mittel[{a,b,c,d,e,f,g}]
Um die Funktion auch auf eine Liste anwendbar zu machen, definieren wir:
• Pour rendre la fonction aussi applicable à une liste, nous définissons:
mittel[{x__}] := mittel[x]mittel[{a,b,c,d,e,f,g}]
Nun klappt es!
• Voilà, ça marche!
Probiere: • Essaie:
{a, b, c, d, e, f, g} /. {x_, y___} :> x
(* 3 Unterstriche! *)nimmErstes[{x_, y___}] := xAusprobieren: • Essayer:
nimmErstes[{a, b, c, d, e, f, g}] Probiere: • Essaie:
{a, b, c, d, e, f, g} /. {x___, y_} :> ynimmLetztes[{x___, y_}] := yAusprobieren: • Essayer:
nimmLetztes[{a, b, c, d, e, f, g}] Probiere: • Essaie:
{a, b, c, d, e, f, g} /. h_[x___] :> h
(* 3 Unterstriche! *)nimmKopf[h_[x___]] := hAusprobieren: • Essayer:
nimmKopf[{a, b, c, d, e, f, g}] Probiere: • Essaie:
{{1,3},{2,4},{3,5},{4,6}} /. {x_, y_} :> {y, x}
Gemeint sind da Definitionen, die ihre Form ändern je nach den Daten, auf die sie angewandt werden. Beispiel:
• Il s'agit ici de définitions qui changent leur forme selon les données auxquelles on les applique. Exemple:
Remove[pasc];
pasc[n_Integer] := Table[Binomial[n,i],
{i,0,n}];
pasc[n_Real ] := n!;pasc[5]pasc[5.5]Map[pasc,{1,1.2,1.4,1.6,1.8,2,2.2,2.4,2.6,2.8,
3,3.2}]Plot[n!,{n,0,3}];
Komplette Ausdrücke können mit Namen versehen werden. Beispiel:
• Les expressions complètes peuvent être pourvues de noms. Exemple:
2 + 3 Cos[x] /.
a:(x_ +y_ Cos[z_]) :>
{{"a", a},{"x", x},{"y",y},{"z",z}}
Identifiziere die Namen!
• Identifier les noms!
Probiere aus: • Essaie:
??CasesStudieren: • Etudier:
Cases[{1, 2.3, {a, b}, x^2 +7, x+y+z}, x_]
Einschränkung auf Integers oder Reals:
• Se limiter à des Integers ou Reals:
Cases[{1, 2.3, 3., {a, b}, x^2 +7, x+y+z},
x_Integer]Cases[{1, 2.3, 3., {a, b}, x^2 +7, x+y+z},
x_Real]?|
Einschränkung auf eine Alternative von Integers oder Reals:
• Se limiter à une alternative de Integers ou de Reals:
Cases[{1, 2.3, 3., {a, b}, x^2 +7, x+y+z},
(x_Integer | x_Real)]
Einschränkung auf Listen:
• Se limiter à des listes:
Cases[{1, 2.3, 3., {a, b}, x^2 +7, x+y+z},
x_List]
Einschränkung auf "Numbers":
• Se limiter à "Numbers":
Cases[{1, 2.3, 3., {a, b}, x^2 +7, x+y+z},
x_?NumberQ]
Nochmals die letzte Operation, aber mit "Select":
• Encore une fois la dernière opération, mais avec "Select":
Select[{1, 2.3, 3., {a, b}, x^2 +7, x+y+z},
NumberQ]
Z.B. stimmt der Ausdruck "a+b+c+d" überein mit dem Muster "x_ + y__":
• P.ex. l'expression "a+b+c+d" correspond au patron "x_ + y__":
Cases[{1, 2.3, 3., {a, b}, x^2 +7, x+y+z},
x_+y__]Oder: • Ou:
Cases[{1, a + I 5, 3., {a, b}, 2 - 3I, x+y+z},
x_+I y_]Cases[{1, a + 5I, 3., {a, b}, 2 - 3I, x+y+z},
x_+I y_]
Wieso hat das jetzt nicht "funktioniert"? - Studiere:
• Pourquoi cela n'a-t-il pas fonctionné? - Etudie:
FullForm[a + 5I]FullForm[a + I 5]
("Complex" ist atomar. Man kann also diesen "Head" suchen.)
• ("Complex" est atomique. On peut donc chercher ce "Head".)
Cases[{1, a + 5I, 3., {a, b}, 2 - 3I, x+y+z},
x_Complex]Cases[{1, a + 5I, 3., {a, b}, 2 - 3I, x+y+z},
Plus[x_Complex,y_]]
Studiere das folgende Beispiel:
• Etudie l'exemple suivant:
f[a_Integer, b_Complex, c_Real] := {a, b, c}f[5, 3-8I, 3.346]f[3-8I, 3.346, 5]
Offenbar spielt die Reihenfolge der Argumente eine Rolle. Das kann aber umgangen werden! Dazu muss allerdings für f das Attribut "Orderless" gesetzt und f neu definiert werden! Probiere aus:
• Evidemment l'ordre des arguments joue un rôle. Cependant on peut éviter cela! Pour cela il faut remplacer f par l'attribut "Orderless" et définir à nouveau f ! Essaie:
Attributes[f]ClearAll[f];
SetAttributes[f, Orderless];
f[a_Integer, b_Complex, c_Real] := {a, b, c}f[3-8I, 3.346, 5]
Achtung! Die Attribute Orderless, Flat, HoldAll, FoldFirst, HoldRest und Listable müssen vor der Definition der Funktion gesetzt werden!
• Attention! Les attributs Orderless, Flat, HoldAll, FoldFirst, HoldRest et Listable doivent être placés avant la définition de la fonction!
Es soll eine Funktion geschrieben werden, die es erlaubt, ausschliesslich nur die Terme auszumultiplizieren, die unter einer Logarithmus-Funktion stehen. Eine Lösung:
• Qu'on écrive une fonction qui permette de multiplier exclusivement les termes qui sont placés sous une fonction de logarithme. Voici une solution:
Clear[logAusmult];
logAusmult[x_] := x /. Log[y_] :> Log[Expand[y]]logAusmult[(4-3x)^5 Log[-(1-x)^3] /(x-1)^3]
Eine Liste von Listen soll in eine Liste verwandelt werden:
• Qu'on transforme une liste de listes en une liste:
{{a, b, c, d},{e, f, g}} /.
{{x__},{y__}} :> {x, y}{{a, b, c, d},{e, f, g}} /.
{x__} :> xRemove[f];
Map[f,{{a, b, c, d},{e, f, g}}]Map[f,{{a, b, c, d},{e, f, g}}] /.
f[{x__}] :> f[x]
Studiere das folgend Beispiel:
• Etudie l'exemple suivant:
fktMap[f_, {}] := {};
fktMap[f_, {a_, b___}] :=
Prepend[fktMap[f, {b}], f[a]];
fktMap[Sin,{a, 2, 3, 4, 5, 6, 7}]
Es soll die Frage beantwortet werden, ob es sechs aufeinanderfolgende Ziffern "9" gibt unter den ersten 1000 Dezimalstellen von Pi. Falls ja, so soll die Anzahl Dezimalstellen zwischen Komma und dieser Sechsergruppe ausgegeben werden. Studiere die Lösung:
• Il faut répondre à la question si le chiffre "9" apparaît 6 fois de suite parmi les 1000 premières unités décimales de Pi. Si cela est le cas, il faut sortir le nombre d'unités décimales situées entre la virgule et ce groupe de six "9". Etudie la situation:
Characters[ToString[1234567]]charListe = Characters[ToString[N[Pi, 10]]]
Ohne Output (1000....)!
Sans output (1000...)!
charListe = Characters[ToString[N[Pi, 1000]]];findeNeun[{"3", ".", x___,
"9","9","9","9","9","9",___}] :=
Length[{x}];findeNeun[charListe]Studiere: • Etudie
Needs["Graphics`Graphics`"]??GraphicsBeachte: • Observe:
Der zu verwendende Modul sieht etwa so aus
( - man sieht sofort, was übergeben werden kann...):
• Le module à utiliser a environ cet aspect
( - on voit tout de suite ce qui peut être transmis...):
LogLogPlot[f_, {x_, xmin_, xmax_}, opts___] :=
Module[{r,
g = ParametricPlot[{Log[10,x], Log[10,f]}, {x, xmin, xmax},
Ticks->{LogScale, LogScale},
FrameTicks -> {LogScale, LogScale,
LogScale, LogScale},
DisplayFunction -> Identity, opts]},
r = PlotRange[g];
Show[g, DisplayFunction -> $DisplayFunction,
PlotRange -> r, AxesOrigin -> Map[#[[1]]&,r]]]
LogLogPlot[x^2, {x, 0.2, 12},
PlotLabel -> "LogLogPlot von x^2",
Frame -> True];
Versuche dieses Beispiel mit anderen Optionen!
• Essaie cet exemple avec d'autres options!
Remove["Global`@*"]
Z.B. das geometrische Mittel von {a,b,c,d,e} ist (a b c d e)^(1/5).
• P.ex. la moyenne géométrique de {a,b,c,d,e} est (a b c d e)^(1/5).
Clear[geometrMittel];
geometrMittel[{x__}]:= Times[x]^(1/Length[{x}])geometrMittel[{1,1,1,1,1}]geometrMittel[{2,16,8,4,32}]geometrMittel[{2,3,5}]geometrMittel[{2,3,5}] // N
"Join" fuegt zwei Listen hintereinander im Gegensatz zur Mengenvereinigung, wo mehrfach vorkommende Elemente nur einmal aufgefuehrt werden.
• "Join" rassemble deux listes l'une après l'autre. Dans la réunion des ensembles par contre les éléments doubles, triples etc. n'apparaissent qu'une seule fois.
Clear[joinFkt];
joinFkt[{x__},{}]:= {x};
joinFkt[{},{x__}]:= {x};
joinFkt[{x__},{y__}]:= Flatten[{{x},{y}}]Ausprobieren: • Essayer:
joinFkt[{a,b,c,d},{e,f,g}]joinFkt[{a,b,c,d},{a,e,b,f,g}]joinFkt[{a,b,c,d},{}]joinFkt[{},{}]
Was ist passiert? Erweitere die Definition sinngemäss!
• Que s'est-il passé? Elargis la définition d'une façon sensée!
a) Implementiere wie nachstehend folgt. Beantworte dann die nachstehenden Fragen b), c), d) und vergleiche mit den implementierten Funktionen "Fold" resp. "FoldList".
• "Implement" comme il suit. Réponds aux questions suivantes b), c), d) et compare avec les fonctions "implémentées" "Fold" resp. "FoldList".
Clear[falte];
falte::usage = "falte[f, basis, liste] ergibt
--donne f[...[f[f[basis,x1]x2],...xn]
wobei --étant list = {x1,x2,...,xn}";
falte[f_,basis_,{}]:=basis;
falte[f_,basis_,{x1_,xrest___}]:=
falte[f,f[basis,x1],{xrest}];
b) Was macht "falte[Plus,0,liste]"? Z.B. liste={a,b,c}.
• Que fait "falte[Plus,0,liste]"? P.ex. liste={a,b,c}.
falte[Plus,0,{a,b,c}]falte[Plus,0,{1,2,3,4}]falte[Plus,5,{1,2,3,4}]
c) Was macht "falte[Max,-Infinity,liste]"? Z.B. liste={a,b,c}.
• Que fait "falte[Max,-Infinity,liste]"? P.ex. liste={a,b,c}.
falte[Max,-Infinity,{a,b,c}]falte[Max,-Infinity,{6,8,3}]falte[Max,9,{6,8,3}]
d) Vergleiche mit "Fold" und "FoldList":
• Compare avec "Fold" et "FoldList":
??Fold??FoldList
"L ? R" in APL wählt (streicht) aus dem "Range[r]" pseudo-zufällig L Zahlen aus, ohne sie in R zu ersetzen.
• "L ? R" dans APL choisit (biffe) dans le "Range[r]" d'une façon pseudo-aléatoire L nombres, sans les remplacer dans R.
a) Was ist "Range" - Wie erzeuge ich die "Zufallszahlen"?
• Qu'est "Range" - Comment génerér les "nombres aléatoires"?
??RangeRange[14]??Random
b) Die Beschreibung der Funktion "deal" in Mathematica:
• La description de la fonction "deal" dans Mathematica:
RemoveAll[deal];
deal::usage="deal[n,r] streicht zufällig n Integers
aus der Liste Range[r] ohne Ersetzung.
-- biffe de façon aléatoire n Integers
dans la liste Range[r] sans les
remplacer."
c) Hier eine mögliche Variante:
• Voici une variante possible:
Clear[deal];
deal[0,r_] :=Range[r];
deal[n_,r_]:=Sort[Rest[RotateLeft[deal[n-1,r],
Random[Integer,{1,r}]]]]
d) Ausprobieren:
• Essaier
deal[2,6]
e) Erklärungen:
• Explications:
??Rest??RotateLeftRotateLeft[{a,b,c},11]??Sort
Das Muster "x___List" als Argument in einer Funktion lässt eine variable Zahl von Listen zu. Wie kann man auf einen Schlag alle Längen einer Anzahl beteiligter Listen finden? Schreibe eine Funktion dafür!
• Le patron "x___List" comme argument dans une fonction permet un nombre variable de listes. Comment peut-on, d'un coup, trouver toutes les longueurs d'un nombre de listes faisant partie du problème? Ecris une fonction pour cela!
Clear[listenLaengen];
listenLaengen[x___List]:=Map[Length, {x}]Ausprobieren: • Essayer:
listenLaengen[{1,2,3}, {1,2,3,4,5}, {1,1,1,1},
{a,b,c,d,e,f,g}]
Konstruiere eine kurze Mathematica-Funktion, die die Häufigkeit der Elemente einer Liste zählt. Die Funktion "laufCod" soll eine Liste von Paaren {Listenelement, absolute Häufigkeit} ausgeben Beispiel:
liste = {e,b,a,b,e,c,c,d,e,a,a,d,u};
laufCod[liste] soll das Resultat {{a, 3}, {b, 2}, {c, 2}, {d, 2}, {e, 3}, {u, 1}} ergeben. Die Funktion "laufDeCod" soll aus dem Output von "laufCod" wieder die ursprüngliche Liste machen.
• Construis une fonction de Mathematica courte qui compte la fréquence des éléments d'une liste. La fonction "laufCod" doit sortir une liste de paires {élément de liste, fréquence absolue}. Exemple:
liste = {e,b,a,b,e,c,c,d,e,a,a,d,u};
laufCod[liste]doit donner le résultat
{{a, 3}, {b, 2}, {c, 2}, {d, 2}, {e, 3}, {u, 1}}. La fonction "laufDeCod" doit transformer l'output de "laufCod" de nouveau dans la liste d'origine.
laufCod[liste_List]:=Transpose[{Union[liste],
Table[Count[liste,Part[Union[liste]
,n]], {n,Length[Union[liste]]}]}]
(Hat Schweiss gekostet!) Aber jetzt ausprobieren:
• (Cela nous a fait transpirer!) Mais maintenant on essaie:
RemoveAll[liste];
liste = {1,1,2,2,2,3,3,3,3};
output = laufCod[liste]liste = {e,b,a,b,e,c,c,d,e,a,a,d,u};
output = laufCod[liste]laufDeCod[output_]:= If[MatrixQ[output],
output/.{x_,n_}:> Flatten[
Table[x,{n}]], Print["Bitte Matrix eingeben"],
Print["Bitte Matrix eingeben --
S.v.p. entrer la matrice"]] laufDeCod[{{1,2},{3,5},{4,3}}]laufDeCod[{{a,3},{b,5},{c,2},{d,4}}]RemoveAll[f];
f[liste_List]:=Module[{i},
i=0;
a=liste;
a//.{y___,x_,x_,z___}:>
{y,x,++i b,x,z}//.{y___,x_Integer,w_Integer,z___}:>
{y,x,d, c,w,z}/. {x___}:>{c, x, d}//.
{x___,y___ b,z___}:>{x,z}//. {x___,b,z___}:>{x,z}//.
{y___,c,x__,d,z___}:> {y,{x},z}
];
laufCod1[liste_List]:={Map[First,f[liste]],
Map[Length,f[liste]]}f[{1,1,1,2,2,2,2,2,3,3,3,3,4,5,5}]laufCod1[{1,1,1,2,2,2,2,2,3,3,3,3,4,5,5}]laufCod1[{0,0,0,1,1,2,2,2,3,3,3,3,4,4,4,5,5,6,6,6}]
Was ist los?
• Que se passe-t-il?
laufCod1[{a,a,a,1,b,b,b,2,2,2,3,3,3,3,4,4,4,5}]
d) Noch eine andere Variante:
• Encore une autre variante:
Attributes[mal]={Flat};
mal[{elem_,m_},{elem_,n_}]:=mal[{elem,m+n}];
laufCod2[liste_List]:= List @@ mal @@({#,1}& /@
liste)laufCod2[{1,1,1,2,2,2,2,2,3,3,3,3,4,5,5}]
Wie arbeitet dieses Programm?
• Comment ce programme travaille-t-il?
# steht für "anonyme Variable", & für "anonyme Funktion", /@ für "Map".
Durchlaufen wird die Liste.
• # signifie "variable anonyme", & signifie "fonction anonyme", /@ signifie "Map". La liste est parcourue.
out1=({#,1}& /@ {1,1,1,2,2,2,2,2,3,3,3,3,4,5,5})
@@ steht für "Apply".
• @@ signifie "Apply".
out2=mal @@out1 ??Listout3=List @@ out2
Probiere eigene Varianten aus!
• Essaie des variantes à toi!
![[Graphics:Images/AllFiles.HTML_gr_31.gif]](Images/AllFiles.HTML_gr_31.gif)
Remove["Global`@*"]
Anonyme Funktionen sind solche, die keinen Namen haben ....
Hier werden wir sehen, was es damit um sich hat!
• Les fonctions anonymes sont celles qui n'ont pas de nom...
Ici nous verrons ce qui en est d'elles!
Studiere: • Etudie:
??FunctionBeispiele: • Exemple:
Function[x, x^2][4]Function[x, x^2 - x][5]Function[x, x^2][{1, 2, 3, 4, 5, 6, 7}]Einfach, nicht? • Simple, n'est-ce pas?
Beispiel (erst Daten erzeugen, dann Funktion definieren, dann anwenden):
• Exemple (d'abord générer des données, ensuite définir la fonction, puis appliquer):
data = Table[Random[Integer, {0, 100}], {14}]groes45[x_] := x > 45Map[groes45,data]groes45[data]
Anwendung zur Selektion:
• Application à la sélection:
Select[data, groes45]
Beispiel (erst ausprobieren):
• Exemple (essayer d'abord):
Function[x, x > 45][68]Function[x, x > 45][24]
Anwendung zur Selektion:
• Application à la sélection:
Select[data, Function[x, x > 45]]Select[data, Function[# > 45]]Select[data, (# > 45)& ]
Das Beispiel:
• L'exemple:
nZwanzig[x_] := N[x, 20]$Post = nZwanzigSin[1]
Mit anonymer Funktion:
• Avec une fonction anonyme:
$Post := N[#, 40]& (* vierzig *)Sin[1]
Listen erzeugen:
• Générer des listes de paires:
list1 = {x1, x2, x3, x4, x5, x6};
list2 = {y1, y2, y3, y4, y5, y6};
Paarliste erzeugen:
Générer des listes de paires:
Transpose[{list1, list2}]
Anonyme Funktion (#[[1]] -> #[[2]])& auf die Liste setzen (mit "Map"):
• Appliquer des fonctions anonymes (#[[1]] -> #[[2]])& à des listes (avec "Map"):
Map[(#[[1]] -> #[[2]])&, Transpose[{list1,
list2}]]Beispiel: • Exemple:
Function[{x, y}, x > y][1, 2]Function[{x, y}, x > y][2, 1]Function[{x, y}, x > y][u, 2]
Was passiert, wenn die Anzahl der übergebenen Argumente nicht stimmt?
• Que se passe-t-il quand le nombre des arguments transmis n'est pas correct?
Function[{x, y}, x > y][1]Function[{x, y}, x > y][1, 2, 3]Function[{x, y}, x > y][a, b, c]
Bei der Kurzschreibweise mit "&" und "#" kommt nun das Problem der Identifikation der verschiedenen Variablen. Die Variablen können dabei nummeriert werden. Beispiel:
• Les abréviations "&" et "#" posent le problème de l'identification des différentes variables. On peut numéroter les variables. Exemple
??#?##??&?&&(#1 < #2)&[4, 6]
Die anonyme Funktion ist jetzt (#1 < #2)&.
• La fonction anonyme est maintenant (#1 < #2)&.
Ersetze eine Datenmenge nach einem "Filter" durch die Menge der gewichteten Mittelwerte je dreier sich folgender Elemente. Studiere dazu das folgende Beispiel!
• Remplace un ensemble de données après un "Filtre" par l'ensemble des moyennes pondérées de trois éléments qui se suivent. Etudie l'exemple suivant!
Zuerst Filter und Daten generieren:
• Générer d'abord le filtre et les données:
filter = {0.1, 0.8, 0.1};
datenF = Table[Random[Integer, {0, 100}]/10,
{10}]
Ordnen in Dreiergruppen, die dann gewichtet gemittelt werden können:
• Ordonner en groupes de trois dont on peut faire ensuite la moyenne pondérée:
matrix = Partition[datenF, Length[filter], 1] % // MatrixForm
Die Gewichtung geschieht, indem man die erste Zahl einer Dreiergruppe mit der ersten Zahl des Filters multipliziert, die zweite Zahl des Filters mit der zweiten der Dreiergruppe etc. und das jeweils addiert. Diese Multiplikation mit nachfolgender Addition ist jeweils ein Skalarprodukt entsprechender Vektoren:
• L pondération se fait en multipliant le 1er nombre d'un groupe de trois avec le 1er nombre du filtre, le 2e nombre du filtre avec le 2e nombre du groupe etc.. On en fait chaque fois l'addition. Cette multiplication suivie de l'addition est un produit scalaire des vecteurs correspondants:
Map[filter .#&, matrix]zusrollen[filterVar_List,
dataVar_List]:= Map[filterVar . #&,
Partition[dataVar, Length[filterVar], 1] ]zusrollen[filter, datenF]Remove["Global`@*"]
(a) Anonym: (#^3)&
• Anonyme: (#^3)&
{(#^3)&[0],(#^3)&[1],(#^3)&[2],(#^3)&[3],(#^3)&[4]} Benannt: • Dénommé:
f[x_]:=x^3;
{f[0],f[1],f[2],f[3],f[4]}
(b) Anonym: (#^#)&
• Anonyme: (#^#)&
{(#^#)&[0],(#^#)&[1],(#^#)&[2],(#^#)&[3],(#^#)&[4],
(#^#)&[5]}Benannt: • Dénommé:
Remove[f];
f[x_]:=x^x;
{f[0],f[1],f[2],f[3],f[4],f[5]}Benannt: • Dénommé:
f[x_]:=x^3;
{f[0],f[1],f[2],f[3],f[4]}
(c) Anonym: {#,#^2}&
• Anonyme: (#^#^2)&
{{#,#^2}&[0],{#,#^2}&[1],{#,#^2}&[2],{#,#^2}&[3],
{#,#^2}&[4],{#,#^2}&[5]}Benannt: • Dénommé:
Remove[f];
f[x_]:={x,x^2};
{f[0],f[1],f[2],f[3],f[4],f[5]}
(d) Anonym: If[#>0,#,-#]&
• Anonyme: If[#>0,#,-#]&
{If[#>0,#,-#]&[-2],If[#>0,#,-#]&[-1],If[#>0,#,
-#]&[0], If[#>0,#,-#]&[1],If[#>0,#,-#]&[2]}Benannt: • Dénommé:
Remove[f];
f[x_]:=Abs[x];
{f[-2],f[-1],f[0],f[1],f[2],f[3]}
(e) Anonym: (#/.x->y)&
• Anonyme: (#/.x->y)&
{(#/.x->y)&[-2],(#/.x->y)&[-1],(#/.x->y)&[0],
(#/.x->y)&[1],(#/.x->y)&[2],(#/.x->y)&[3],
(#/.x->y)&[x],(#/.x->y)&[y],(#/.x->y)&[z]}Benannt: • Dénommé:
Remove[f];
f[z_]:=z /. x->y;
{f[-2],f[-1],f[0],f[1],f[2],f[3],f[x],f[y],f[z]}
Zum Beispiel (#^3)&
• Par exemple (#^3)&
{(#^3)&[-3],(#^3)&[-2],(#^3)&[-1],(#^3)&[0],
(#^3)&[1],(#^3)&[2],(#^3)&[3]}
Ein Beispiel:
• Un exemple:
newList = {{1,2},{2,1},{3,1},{2,3},{6,4},{4,7}};
Select[newList,(#[[1]] > #[[2]])&]
Was ist "PlotLabel"?
• Qu'est "PlotLabel"?
??PlotLabel
Wie wird es eingesetzt?
• Comment l'applique-t-on?
??PlotEin Plot: • Un plot:
Plot[Sin[x],{x,-5,5}];Mit Label: • Avec Label:
Plot[Sin[x],{x,-5,5},PlotLabel->FontForm[
"1. Sinus,\n zwischen {-5,5}",
{"Courier-Bold",15}]];
Mit Hilfe einer anonymen Funktion:
• A l'aide d'une fonction anonyme:
(Plot[Sin[x],{x,-5,5},PlotLabel->#])&[FontForm[
"2. Sinus,\n zwischen {-5,5}",
{"Courier-Bold",15}]];(Plot[Sin[x],{x,-5,5},PlotLabel->#])&[FontForm[
"Sinus,\n zwischen {-5,5}",{"Courier-Bold",15}]];
Etwas geschraubter:
• Un peu plus sophistiqué:
Apply[Plot,{#[[1]],#[[2]],#[[3]]}]&[{Sin[x],
{x,-5,5},(PlotLabel->#)}&[FontForm["3.
Sinus,\n zwischen {-5,5}",{"Courier-Bold",15}]]];
Noch etwas geschraubter:
• Ecore plus sophistiqué:
Plot @@ {#[[1]],#[[2]],#[[3]]}&[{Sin[x],{x,-5,5},
(PlotLabel->#)}&[FontForm["4.
Sinus,\n zwischen {-5,5}",{"Courier-Bold",15}]]];
Ein Versuch, die Options zu ändern:
• Un essai de changer les options:
Options[Plot]Unprotect[Options[Plot]];
Drop[Options[Plot],{11}];
Options[Plot]=Union[Options[Plot],{PlotLabel->
FontForm["5. Neues Bild",{"Courier-Bold",15}],
Frame->True}];
(*Protect[Plot]*)Attributes[Plot] {HoldAll}
Options[Plot]Unprotect[Plot];
Drop[Options[Plot],{11}];
Options[Plot]=Union[Options[Plot],{PlotLabel->
FontForm["5. Neues Bild",{"Courier-Bold",15}],
Frame->True}];
(*Protect[Plot]*)Attributes[Plot]Options[Plot]
Was hat er nicht getan?
• Que n'a-t-il pas fait?
Plot[Sin[x],{x,-5,5}];
Wieso kam der Titel nicht?
• Pourquoi le titre n'est-il pas apparu?
Show[%];Uebungsfeld: • Terrain d'exercice:
Verwende Union, Count und Map.
• Utilise Union, Count et Map.
Diese Funktion zählt die Häufigkeit von verschiedenen Elementen
einer Liste:
• Cette fonction compte la fréquence de différents éléments d'une liste:
frequenz[x_List]:= Module[{elemente=Union[x]},
Map[{#,Count[x,#]}&,elemente]];
frequenz::usage="frequenz[x_List] gibt eine Liste \
von verschiedenen Elementen zusammen
mit ihrer Häufigkeit ---- \
donne une liste avec différents \
éléments avec leurs fréquences.";
testListe = Table[Random[Integer,{1,20}],{18}];
Sort[testListe]frequenz[testListe]??frequenz
Probiere eigene Listen!
• Essaie des listes à toi!
Eine Aufgabe in mehreren Schritten
• Un problème en plusieurs étapes
punkte = Partition[
Table[Random[Integer,{1,20}],{30}],3]grau = Table[Random[Real,{0,1}],{10}]grau1=Partition[grau,1]trans=Transpose[{punkte,grau1}];transRemoveAll[mix];
mix=Map[Join[#[[1]],#[[2]]]&,trans]menge=Map[({PointSize[0.03],GrayLevel[#[[4]]],
Point[{#[[1]],#[[2]],#[[3]]}]
})&,
mix];
mengeShow[Graphics3D[menge]];
Einige Erklärungen:
• Quelques explications:
??Show??Graphics3D??DefaultColor??GrayLevel{PlotStyle->GrayLevel[1]};
Show[Graphics3D[{PointSize[0.5],GrayLevel[0.5],
Point[{1,1,1}]
}]];??#
Hier geht es um die Analyse einer besondern Strategie zum Auffinden Deines "signifikanten Partners". Angenommen, da seinen n Personen des andern Geschlechts, die Du in Betracht ziehen willst. Du selbst bist noch ledig, jedoch heiratswillig. Jeder der n Personen ist ein unterscheidbarer Wert zugewiesen, den Du nicht kennst, bis Du das Individuum triffst. Jede Person kannst Du nur einmal treffen. Nach jedem Treffen musst Du entscheiden, ob das eben getroffene Individuum Dein "signifikanter Partner" ist und ihm dann einen Heiratsantrag stellen. Im Falle der Ablehnung gehst Du zm nächsten Treffen, wo dieselben Regeln gelten. Eine abgelehnte Person kannst Du nicht nochmals treffen, entsprechend den hier geltenden Gepflogenheiten.
Du sollst jetzt folgende Strategie analysieren: Du triffst (n/e) Partner als Testmenge, e = Eulersche Zahl. Nachdem Du jetzt einen Eindruck gewonnen hast, wählst Du den ersten Partner Deines Wunsches, der Dir besser gefällt als alle bisherigen Partner.
Wähle n = 30 und lasse eine Simulation 50 mal laufen. Bezeichne im voraus einen besten Partner. Ein Lauf sei positiv, wenn Du den vorher bezeichneten besten Partner durch das Verfahren auch findest.
•
Il s'agit ici d'une stratégie spéciale pour trouver ton "partenaire significatif". Supposons n personnes de l'autre sexe que tu veux considérer. Toi-même tu es encore célibataire, mais décidé de te marier. A chacune des n personnes est attribuée une valeur qu'on peut distinguer, que tu ne connais pas, jusqu'à ce que tu rencontres l'individu. Tu ne peux rencontrer chaque personne qu'une seule fois. après chaque rencontre tu dois décider si l'individu que tu viens de rencontrer est ton "partenaire significatif" et lui faire ensuite une proposition de mariage. En cas de refus tu te rends au prochain rendez-vous, où valent les mêmes règles. Une personne refusée tu ne peux plus la rencontrer, selon les us et coutumes en vigeur ici.
Analyse la stratégie suivante: Tu rencontres (n/e) partenaires comme ensemble de test, e = nombre d'Euler. Après cette première impression tu choisis le partenaire qui te plaît le mieux que tous les précédents. Choisis n = 30 et fais marcher la simulation 50 fois. Désigne à l'avance le meilleur partenaire. Un parcours soit positif si tu trouves le partenaire désigné à l'anvance par cette méthode.
Definiere zuerst eine Funktion "zufall", die eine Liste von Leuten in zufälliger Reihenfolge wieder ausgibt.
• Définis d'abord une fonction "hasard", qui sort une liste de personnes en ordre aléatoire.
Definiere zuerst die Funktion "zufall1". Diese Funktion stellt die Liste rekursiv zufällig um.
• Définis d'abord la fonction "zufall1" ("hasard"). Cette fonction redonne la liste de façon récursive aléatoire.
zufall1[{}]:={};
zufall1[personen_List]:=
Block[{n=Random[Integer,{1,Length[personen]}]},
Prepend[zufall1[Drop[personen,{n}]],
personen[[n]]]];
Einige Details zum Test:
• Quelques détails quant au test:
personen={a,b,c,d};
zufall1[personen]n=Random[Integer,{1,Length[personen]}]n=Random[Integer,{1,Length[personen]}];
Drop[personen,{n}]zufall1[Drop[{a,b,c,d},{2}]]
Oder definiere dann die Funktion "zufall2". Diese Funktion tut dasselbe wie "zufall1":
• Ou bien définis la fonction "zufall2". Cette fonction fait la même chose que "zufall2":
zufall2[{}]:={};
zufall2[personen_List]:=
Block[{n=Random[Integer,{0,Length[personen]-1}],
shifted},
shifted=RotateLeft[personen,n];
Prepend[zufall2[Drop[shifted,1]],
shifted[[1]]]];
Einige Details zum Test:
• Quelques détails quant au test:
personen={a,b,c,d};
zufall2[personen]n=Random[Integer,{0,Length[personen]-1}]n=Random[Integer,{0,Length[personen]-1}];
shifted=RotateLeft[personen,n]n=Random[Integer,{0,Length[personen]-1}];
shifted=RotateLeft[personen,n];
Drop[shifted,1]
Oder definiere dann die Funktion "zufall" mit Hilfe der Funktion "Sort".
Hier werden Paare {a,b} benützt, wobei a eine Zufallszahl und b die
Ordnungszahl der Person ist. Die Paare werden dann nach a geordnet. Diese Funktion tut dasselbe wie "zufall1":
• Ou bien définis la fonction "zufall" à l'aide de la fonction "Sort". Ici on emploie des paires {a,b}, a étant le nombre aléatoire, b le nombre ordinal de la personne. Les paires sont rangées selon a. Cette fonction fait la même chose que "zufall1":
zufall[{}]:={};
zufall[personen_List]:=
Map[Last,
Sort[Map[{Random[], #}&, personen],
(#1[[1]] > #2[[1]])&
]];
zufall::usage="zufall[list] gibt eine zufällige \
Permutation der Elemente der Liste \
--- donne une permutation aléatoire \
des éléments de la liste."
Einige Details zum Test:
• Quelques détails quant au test:
personen={a,b,c,d};
zufall[personen]{Random[], #}&[personen]Map[{Random[], #}&, personen]Sort[Map[{Random[], #}&, personen],
(#1[[1]] > #2[[1]])&]Map[Last, Sort[Map[{Random[], #}&, personen],
(#1[[1]] > #2[[1]])& ]]
Gib nun den Personen statt Namen Ordnungszahlen von 1 bis n. 1 bedeutet "am meisten bevorzugt" etc..
• Donne aux personnes au lieu de noms des nombres ordinaux de 1 jusqu'à n. 1 signifie "préféré le plus" etc..
n = 30;
personen = zufall[Range[n]]
Die Funktion "wahlVorzug" soll nun n Personen nehmen und diese in zufällige Reihenfolge bringen. Sie soll die ersten (n/e) (gerundet) Personen nehmen und den Wert der meist bevorzugten Person in dieser Menge in die Variable mmin speichern. Der Wert der ersten noch mehr bevorzugten Person, die dann folgt, soll in die Variable wahl gespeichert werden. Wenn wahl eine Zahl grösser gleich 1 enthält, soll wahlVorzug diese Zahl als Element einer Menge ausgeben. Andernfalls soll die leere Menge kommen.
• La fonction "wahlVorzug" prenne maintenant n personnes et les mette dans un ordre aléatoire. Qu'elle prenne les premières (n/e) (arrondi) personnes et qu'elle mémorise dans la variable mmin la valeur de la personne préférée de cet ensemble. La valeur de la personne préférée encore davantage, qui suit, doit être mémorisée dans la variable wahl. Si wahl contient un nombre plus grand ou égal 1, wahl doit sortir ce nombre comme élément d'un ensemble. Autrement doit apparaître l'ensemble vide.
wahlVorzug[n_Integer]:=
Module[{personen=zufall[Range[n]],
m=Round[N[n/E]],
mmin, wahl},
mmin=Min[Take[personen,m]];
wahl=Select[personen,(#<mmin)&];
If[Length[wahl]>0,First[wahl],{}]];
anzahlPersonen=30;
anzahlLauf=50;
resultat=Table[wahlVorzug[anzahlPersonen],
{anzahlLauf}]
Anzahl positive Simulationen mit Resultat 1, 2 oder 3:
• Nombre de simulations avec le résultat 1, 2 ou 3:
posSim1={Map[(N[Count[resultat,#]/anzahlLauf])&,
{1,2,3}]}
Kürzer mit Vergleich mit (1/e):
• Plus brièvement avec la comparaison avec (1/e):
posSim1={(N[Count[resultat,#]/anzahlLauf
])&/@{1,2,3},N[1/E]}
Studiert man den Output, so sieht man, dass meistens die Anzahl der Fälle, in denen die leere Menge herauskommt, sehr gering ist. Dann hat die Strategie keinen Erfolg. Falls die Strategie eine Zahl ergibt, so wollen wir von Erfolg insofern reden, dass dann eine kleine Nummer erwartet werden kann. Wir sagen dann, es hätte sich ein "signifikanter Partner" finden lassen. Wie oft kommt das prozentual vor?
• Si on étudie l'output, on voit que pour la plupart le nombre des cas où sort l'ensemble vide et très petit. Dans ces cas la stratégie n'a pas de succès. Si la stratégie donne un nombre, nous pouvons nous attendre à un nombre bas. Nous dirons qu'un "partenaire significatif" a pu être trouvé. Dans quel pourcentage cela arrive-t-il?
signifikant = 1- N[Count[resultat,{}]/50]
Wir berechnen, in wievielen Läufen prozentual die Simulation mit einer Person endete, die unter "den favorisierten 10%" einzureihen ist.
• Nous calculons dans combien de parcours la simulation s'est terminée par une personne qu'on a pu placer parmi les "10 % facorisés".
signifikant10Prozent =
N[Length[Select[resultat,
(#<=Round[N[anzahlPersonen 0.1]])&]]/50]anzahlLauf=50;
resultat=Table[wahlVorzug[anzahlPersonen],
{anzahlLauf}];
posSim1={Map[(N[Count[resultat,#]/anzahlLauf])&,
{1,2,3}]};
signifikant = 1- N[Count[resultat,{}]/50];
signifikant10Prozent =
N[Length[Select[resultat,
(#<=Round[N[anzahlPersonen 0.1]])&]]/50];
Print["resultat = ", resultat];
Print["posSim1 = ", posSim1];
Print["signifikant = ", signifikant];
Print["signifikant10Prozent = ",
signifikant10Prozent]Remove["Global`@*"]Beispiel: • Exemples:
1 + 2 = 3
Hier kommt eine Fehlermeldung. Die Fehlermeldungen sind im Technical Report Number 9 ff von Wolfram Research beschrieben. Achtung! Orthographische, syntaktische Fehler (programmlogische Fehler, Durchbrechung der Programmierregeln) können entdeckt werden, jedoch nicht semantische Fehler (falsche Interpretation der eigenen Absicht in der Niederschrift).
• Voici une annonce d'erreurr.(Les annonces d'erreurs sont décrites dans le Technical Report Number 9 ff de Wolfram Research.) Attention! Erreurs d'orthographe ou de syntaxe (erreurs concernant la logique de programmation ou les règles de programmation) peuvent être découvertes, tandis que les erreurs sémantiques (fausse interprétation de la propre intention dans le manscrit) ne le peuvent pas.
Beispiel: • Exemple:
2 - )5 + 7
Hinweis zum Notebook Front End: Mit (<Command>-B (B gross) --- NeXT) <Shift Control> B (B gross) ist eine Klammerüberprüfung möglich. Probiere das aus (setze den Cursor in die Lücke und verwende (<Command>-B (B gross) --- NeXT) <Shift Control> B (B gross) ):
• Indication au sujet de Notebook Front End: Avec (<Command>-B (B grand) --- NeXT) <Shift Control> B (B grand) il est possible de faire un examen des parenthèses. Essaie (met le cursor dans l'espace vide et emploie (<Command>-B (B grand) --- NeXT) <Shift Control> B (B grand) ):
((([ [cjklf]r]}}]Beispiel: • Exemple:
Wird einer Variablen ein Wert zugewiesen, so wird auf den Wert und nicht auf die Variable gegriffen:
• Quand une valeur est assignée à une variable, c'est la valeur qui est prise et non pas la variable:
t = 5;
Print["t = ", t];
Integrate[Sin[t], t]
Abhilfe: Z.B. mit lokalen Variablen arbeiten.
• Secours: P.ex. travailler avec des variables locales.
Studiere: • Etudie:
D[x^3]D[x^3, x]D[x^3, y]D[x^3, 1]D[x^3 Sin[y], x, y]
D[x^3] ergibt offenbar die 0-te Ableitung von x^3.
• D[x^3] donne apparemment la 0-ième dérivation de x^3.
Studiere: • Etudie:
Clear[f];
f[x_] := If[x > 0, x -x];
{f[5], f[-5]}
Mit Komma:
• Avec virgule:
Clear[f];
f[x_] := If[x > 0, x, -x];
{f[5], f[-5]}Studiere: • Etudie:
Clear[f];
f[x_, y_] := xy;
f[2, 3]Clear[f];
f[x_, y_] := x y;
f[2, 3]D[x^3 Sin[y], x, y]Beispiel: • Exemple:
Clear[g]g[0]g(0)g(a){a, b, c}.{e, f, g}{a, b, c}.{e, f, g, h}Uebersicht: • Vue d'ensemble:
{{a},{b},{c}} // MatrixFormTranspose[{{a},{b},{c}}] // MatrixForm
Diverse Produkte:
• Produits divers:
{{a},{b},{c}} . {{e},{f},{g}} // MatrixForm{{a},{b},{c}} . Transpose[{{e},{f},{g}}] //
MatrixFormTranspose[{{a},{b},{c}}] . {{e},{f},{g}} //
MatrixFormTranspose[{{a},{b},{c}}] .
Transpose[{{e},{f},{g}}] // MatrixFormGenerierung: • Génération:
Table[u[[i]] v[[j]], {i, Length[u]}, {j,
Length[v]}]
Was weiss man über u und v?
• Que sait-on de u et v?
a = 5
+ 7
+ 9aa = 5 +
7 +
9a
Was ist hier los?
• Que se passe-t-il ici?
(x^2)^(0.5)Sqrt[x^2]Integrate[Sqrt[1 - Cos[x]^2], {x, 0, Pi/2}]Integrate[Cos[x], {x, Pi, 2Pi}]Integrate[Sqrt[1 - Sin[x]^2], {x, Pi, 2Pi}]
Was ist hier los?
• Que se passe-t-il ici?
??SqrtSqrt[(-2)^2]Probiere: • Essaie:
s = 2 x /(5x - 7)Plot[s, {x, 0, 4}];Plot[Numerator[s], {x, 0, 4}];
Wieso der Fehler? Probiere:
• Pourquoi l'erreur? Essaie:
Plot[Evaluate[Numerator[s]], {x, 0, 4}];
Probiere und erkläre die Prioritäten! Beispiel:
• Essaie et explique les priorités!
Clear[f];
f[x_] := x^2;
f[y_] := y^3;{f[x],f[y]}??fBeispiel: • Exemple:
Clear[ung];
ung[x_?OddQ ] := (ung[x] = 1);
ung[x_?EvenQ] := (ung[x] = 0);
Table[ung[x], {x,10}]??ung??Protect??UnprotectProbiere: • Essaie:
Integrate[f[x_], x_] := F[x]Remove[f, F];
f/: Integrate[f[x_], x_] := F[x];
Integrate[f[x], x]Probiere: • Essaie:
Pi = 3.1416{Pi, Pi // N}Unprotect[Pi];
Pi = 3.1416;
PiProtect[Pi];
Pi // N??PiUnprotect[Pi];
Remove[Pi];
Pi // N??Pi
Beachte beim Programmieren:
Dokumentiere die eigenen Funktionen.
Beachte Gross- und Kleinschreibung.
Beachte Klammerung.
Beachte die Initialisierung von Variablen.
Beachte die Funktionennamen.
Teste die Statements.
Beachte die Argumente von Funktionen.
Beachte die Punktuation.
Kontrolliere, ob Befehle oder Zeichen vergessen worden sind.
Mache Tests in trivialen Fällen.
Teste den Code mit Testdaten.
Beachte das Zuladen von Packages.
Beachte die "Contexts" (Erklärung in Kap. 15.)
Schreibe die Programme so, dass ein anderer nicht viel Zeit benötigt, um sie zu lesen. Wer die eigenen Kriterien den andern aufzwingen will, ist nicht sehr teamfähig. Denke auch an die andern, obwohl Du ja für Dich alleine sicher sehr gescheit bist!
•
Considère en programmant:
Documente les propres fonctions.
Tiens compte des majuscules et minuscules.
Tiens compte des initiales des variables.
Tiens compte des noms et fonctions.
Examine et teste les statements.
Tiens compte des arguments de fonction.
Tiens compte de la ponctuation.
Contrôle si des ordres ou des signes ont été oubliés.
Fais des tests dans des cas triviaux.
Teste le code par des données aptes à cela.
Tiens compte des Packages utilisés.
Tiens compte des "Contexts". (Explication au chapitre 15.)
Ecris les programmes de façon qu'une autre personne ne perde pas beaucoup de temps à les lire. Qui veut imposer ses propres critères aux autres, n'est pas capable de travailler en groupe. Pense aux autres, bien que tu n'aies pas de problèmes en travaillant seul.
Studiere: • Etudie:
?On?Off?Print?Debug?Trace?Input?InterruptProbiere aus: • Essaie:
Remove[f, g];
f[x_]:= x^3 + g[x];
g[x_]:= x - 14On[f, g]f[4]Off[f, g]f[4]
Von 10.3.7:
• De 10.3.7:
median[liste_List]:=
Block[{
sl,
len
},
len = Length[liste];
Print["Länge der Liste: ", len];
sl = Sort[liste];
Print["Sortierte Liste: ", sl];
Print["Median: "];
If[
OddQ[len],
sl[[(len+1)/2]],
(sl[[len/2]]+sl[[len/2+1]])/2
]
];
median[{24, 32, 36, 47, 49, 52}] Beispiel: • Exemple:
?$Version?$VersionNumber$VersionNumber < 2If[$VersionNumber < 2,
Debug[For[n = 1, n < 4, ++n, Print[n^3]]],
Print["Achtung: Bei Debug ab Version 2:
Systemabsturz! \
Attention: Debug dès version 2:
système interrompu!"]]Studiere: • Etudie:
2 5 + 8 9Trace[2 5 + 8 9]Trace[2 5 + 8 9, TraceDepth -> 1]Trace[2 5 + 8 9, Plus]Trace[2 5 + 8 9, Times]Trace[2 5 + 8 9, x_ y_]Trace[2 5 + 8 9, TraceDepth -> 1]
Studiere (obiges Beispiel abgeändert):
Falls während der Rechnung plötzlich ein Fenster geöffnet wird so kannst Du eine Variable abfragen. Schreibe z.B. "?len" ins Fenster und beobachte, was passiert!
•
Etudie (Exemple ci-dessus changé):
Si pendant le calcul il s'ouvre tout à coup une fenêtre, tu peux demander le contenu d'une variable. Ecris p.ex. "?len" dans la fenêtre et observe ce qui se passe!
median[liste_List]:=
Block[{
sl,
len
},
len = Length[liste];
sl = Sort[liste];
Print[Input[]];
If[
OddQ[len],
sl[[(len+1)/2]],
(sl[[len/2]]+sl[[len/2+1]])/2
]
];
median[{24, 32, 36, 47, 49, 52}]
Beispiel: n! soll berechnet werden. Die Rechnung soll wegen der Rechnungszeit aber nur durchgeführt werden für n <= 1000.
• Exemple: n! doit être calculé, mais à cause du temps de calcul on ne le calculera que pour des n >= 1000.
Remove[f];
f::gross = "Eingegebene Zahl grösser tausend. \
Rechenzeit möglicherweise sehr lang.";
f[n_] := If[n <= 500, Print[n,"! = ", n!],
f::gross] f[10]f[100]f[500]f[501]Remove["Global`@*"]Remove["Global`@*"]3 Plus 4
(Ueberlege, wie "Plus" wirkt.)
• (Réfléchis aux effets de "Plus")
Plus[3, 4]mean[x_] := Add[x]/Length[x];
mean[{1,2,3}]
Schreibe den Code richtig!
• Ecris le Code correctement!
?PlusRemove[mean];
mean[{x__}] := Plus[x]/Length[{x}];
mean[{1,2,3}]
Wieso kommen keine Primzahlen?
• Pourquoi il n'apparaît pas de nombre premier?
Select[{2, 3, 7, 9, 11, 12}, PrimeQ[x_]]
Schreibe den Code richtig!
• Ecris le code correctement!
?SelectTrace[Select[{2, 3, 7, 9, 11, 12}, PrimeQ[x_]]]Select[{2, 3, 7, 9, 11, 12}, PrimeQ]
Berechne das Integral!
• Calcule l'intégral!
Integral[xCos(x), (x, 0, pi)]
Schreibe den Code richtig!
• Ecris le code correctement!
Integrate[x Cos[x], {x, 0, Pi}]
Mit der folgenden Funktion sollen 6 Lottozahlen ausgewählt werden. Wieso kommt nur eine?
• Avec la fonction suivante on choisit 6 nombres de loto. Pourquoi il n'en vient qu'un?
machLotto:=
Block[{
n = 1
},
While[n <= 6;
Print[
Random[Integer, {0, 49}]
];
n++
]
];
machLotto
Schreibe den Code richtig!
• Ecris le code correctement!
machLotto:=
Block[{
n = 1
},
While[n <= 6,
Print[
Random[Integer, {0, 49}]
];
n++
]
];
machLotto
Studiere die folgenden Funktionen:
• Etudie les fonctions suivantes:
Remove[aoi, eip];
aoi[f_[x_], min_, max_] := NIntegrate[f[x],
{x, min, max}];
eip[x_ ] := x^2 + 5 Exp[x];
aoi[eip[t], 5, 10]
Wieso kommt nicht ein numerischer Wert? Hier einige Studien und Lösungsmöglichkeiten:
• Pourquoi il n'apparaît pas une valeur numérique? Voici quelques études et quelques possibilités de solution:
?aoiOn[aoi, eip]aoi[eip[t], 5, 10]Remove[aoi, eip];
On[aoi, eip];
aoi[f_[x_], y_, min_, max_] := NIntegrate[f[x],
{y, min, max}];
eip[z_ ] := z^2 + 5 Exp[z];
aoi[eip[t], 5, 10]Remove[aoi, eip];
On[aoi, eip];
aoi[f_, y_, min_, max_] := NIntegrate[f,
{y, min, max}];
eip := x^2 + 5 Exp[x];
aoi[eip, t, 5, 10]aoi[eip, x, 5, 10]Remove[aoi, eip];
On[aoi, eip];
aoi[f_, x_, min_, max_] := NIntegrate[f,
{x, min, max}];
eip[y_ ] := y^2 + 5 Exp[y];
aoi[eip[t], t, 5, 10]
Schreibe die folgende Funktion kürzer und besser:
• Ecris la fonction suivante d'une daçon plus courte et meilleure:
Remove[f];
f[g_, x_List]:=
Block[{
l = {},
n = 1
},
Do[
l = Join[l, {g[x[[i]]]}],
{i, Length[x]}
];
l
];
f[g, {a, b, c}]Einfacher: • Plus simplement:
Clear[f];
f[g_, x_List] := Map[g, x];
f[g, {a, b, c}]Remove["Global`@*"]
Problem: Datenimport und Datenexport in und von Mathematica.
• Problème: Importation et exportation de données dans et de Mathematica.
Studiere: • Etudie:
?Input?InputString?BaseFormBaseForm[15,2]+BaseForm[17,2]benutzerInput = Input[
"Schreibe eine Zahl zwischen 1 und 10: \
Ecris un nombre entre 1 et 10:"]
Achtung: Das nachfolgende Programm bricht erst ab, wenn keine Integer-Zahl eingegeben wird! Probiere:
• Attention: Le programme suivant s'interrompt seulement si on n'entre pas le nombre Integer! Essaie:
dualUmwandlung:=
Module[{
benutzerInput},
While[
IntegerQ[
userInput = Input[
"Schreibe eine Zahl zwischen 1 und 10: \
Ecris un nombre entre 1 et 10:"]
],
Print[userInput, " = ",
BaseForm[userInput, 2]]
]
];
dualUmwandlung
Beispiel:
(Das File AAAdaten) befindet sich wahrscheinlich in Deinem Verzeichnis C:\Programme\WolframResearch\Mathematica\3.0 (win98). - Sonst musst Du Deinen mir nicht bekannten Pfad suchen!)
• Exemple:
(Le file AAAdanten.nb (aadaten.ma) se trouve probablement dans le directoire C:\Programme\WolframResearch\Mathematica\3.0 (win98). - Si non tu dois chercher ton "path" que je ne connais pas!)
Mathematica 3.02, Windows98
Beispiel: neues Verzeichnis erstellen:
• Faire un nouveau directoire:
![[Graphics:Images/AllFiles.HTML_gr_32.gif]](Images/AllFiles.HTML_gr_32.gif)
![[Graphics:Images/AllFiles.HTML_gr_33.gif]](Images/AllFiles.HTML_gr_33.gif)
![[Graphics:Images/AllFiles.HTML_gr_34.gif]](Images/AllFiles.HTML_gr_34.gif)
Beispiel: Erstelle ein Verzeichnis C:\work (falls nicht vorhanden).
(Das File AABDaten befindet sich in Deinem Verzeichnis "work" (win98), (aadaten.ma: "Mate" (win3.1, 95....), "WirzMathematicaFiles/Daten" (NeXT) usw.) . - Sonst musst Du Deinen mir nicht bekannten Pfad angeben!)
• Exemple: Ouvre un directoire C:\work (si cela n'existe pas encore).
(Le file AABDaten se trouve dans le directoire "work" (win98), (aadaten.ma: "Mate" (win3.1, 95....), "WirzMathematicaFiles/Daten" (NeXT) etc. ). - Si non tu dois m'indiquer ton "path" que je ne connais pas!)
Schreibe Daten ins File C:\work\AABDaten:
• Ecrire des données dans le fichier C:\work\AABDaten:
![[Graphics:Images/AllFiles.HTML_gr_35.gif]](Images/AllFiles.HTML_gr_35.gif)
![[Graphics:Images/AllFiles.HTML_gr_36.gif]](Images/AllFiles.HTML_gr_36.gif)
![[Graphics:Images/AllFiles.HTML_gr_37.gif]](Images/AllFiles.HTML_gr_37.gif)
Lese das File C:\work\AABDaten:
• Lire le fichier C:\work\AABDaten:
![[Graphics:Images/AllFiles.HTML_gr_38.gif]](Images/AllFiles.HTML_gr_38.gif)
![[Graphics:Images/AllFiles.HTML_gr_39.gif]](Images/AllFiles.HTML_gr_39.gif)
win98:
Erstelle nötigenfalles eine Textdatei "c:\work\AAEDaten.txt" mit Inhalt:
• Si nécessaire composer un fichier "c:\work\AAEDaten.txt" avec le contenu:
1 2 3 4 5 6 7
1.1 1.2 1.3 1.4
11 12 13 14 115
a b c d e f g
Sin[5]\\N hallo
"hallo"
Erstelle ebenso eine Textdatei "c:\work\AAFDaten.txt" mit Inhalt:
• Composer aussi un fichier "c:\work\AAEDaten.txt" avec le contenu:
1 2 3 4 5 6 7
1.1 1.2 1.3 1.4
11 12 13 14 115
Inhalt anschauen:
• Regarder le contenu:
![[Graphics:Images/AllFiles.HTML_gr_40.gif]](Images/AllFiles.HTML_gr_40.gif)
!!f:\Mathe/Daten/aadaten0 (* win3.1 etc. *)
File einlesen und ausführen:
• Lire le fichier et exécuter:
![[Graphics:Images/AllFiles.HTML_gr_41.gif]](Images/AllFiles.HTML_gr_41.gif)
<<f:\Mathe/Daten/aadaten1 (* win3.1 etc. *)
Was ist los gewesen? Schauen wir weiter:
• Que s'est-il passé? Continuons d'observer:
?<<?Get![[Graphics:Images/AllFiles.HTML_gr_42.gif]](Images/AllFiles.HTML_gr_42.gif)
!!f:\Mathe/Daten/aadaten1 (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_43.gif]](Images/AllFiles.HTML_gr_43.gif)
<<f:\Mathe/Daten/aadaten1 (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_44.gif]](Images/AllFiles.HTML_gr_44.gif)
Get["f:\Mathe/Daten/aadaten1"]
(* win3.1 etc. *)1 7 3 4 2 9 (*Produkt! *)
Spezifisch einlesen:
• Lire spécifiquement:
?ReadList![[Graphics:Images/AllFiles.HTML_gr_45.gif]](Images/AllFiles.HTML_gr_45.gif)
ReadList["f:\Mathe/Daten/aadaten0", Real]
(* win3.1 etc. *)?Real![[Graphics:Images/AllFiles.HTML_gr_46.gif]](Images/AllFiles.HTML_gr_46.gif)
ReadList["f:\Mathe/Daten/aadaten0", Number]
(* win3.1 etc. *)?Number![[Graphics:Images/AllFiles.HTML_gr_47.gif]](Images/AllFiles.HTML_gr_47.gif)
ReadList["f:\Mathe/Daten/aadaten0", Byte]
(* win3.1 etc. *)?Byte![[Graphics:Images/AllFiles.HTML_gr_48.gif]](Images/AllFiles.HTML_gr_48.gif)
ReadList["f:\Mathe/Daten/aadaten0",
Character] (* win3.1 etc. *)?Character![[Graphics:Images/AllFiles.HTML_gr_49.gif]](Images/AllFiles.HTML_gr_49.gif)
ReadList["f:\Mathe/Daten/aadaten0", String]
(* win3.1 etc. *)?String![[Graphics:Images/AllFiles.HTML_gr_50.gif]](Images/AllFiles.HTML_gr_50.gif)
ReadList["f:\Mathe/Daten/aadaten0", Record]
(* win3.1 etc. *)?Record![[Graphics:Images/AllFiles.HTML_gr_51.gif]](Images/AllFiles.HTML_gr_51.gif)
ReadList["f:\Mathe/Daten/aadaten0", Word]
(* win3.1 etc. *)?WordReadList["f:\Mathe/Daten/aadaten1", Real]
(* win3.1 etc. *)ReadList["f:\Mathe/Daten/aadaten1", Number]
(* win3.1 etc. *)ReadList["f:\Mathe/Daten/aadaten2", Number]
(* win3.1 etc. *)!!f:\Mathe/Daten/aadaten2 (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_52.gif]](Images/AllFiles.HTML_gr_52.gif)
ReadList["f:\Mathe/Daten/aadaten1",
{Number, Number}] (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_53.gif]](Images/AllFiles.HTML_gr_53.gif)
ReadList["f:\Mathe/Daten/aadaten1",
{Number, Number, Number, Number}]
(* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_54.gif]](Images/AllFiles.HTML_gr_54.gif)
ReadList["f:\Mathe/Daten/aadaten1",
Cos[Number]] (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_55.gif]](Images/AllFiles.HTML_gr_55.gif)
ReadList["f:\Mathe/Daten/aadaten1",
Cos[Number]] // N (* win3.1 etc. *) !!f:\Mathe/Daten/aadaten3 (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_56.gif]](Images/AllFiles.HTML_gr_56.gif)
ReadList["f:\Mathe/Daten/aadaten3",
{String, Number, Number}] (* win3.1 etc. *)!!f:\Mathe/Daten/aadaten4 (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_57.gif]](Images/AllFiles.HTML_gr_57.gif)
ReadList["f:\Mathe/Daten/aadaten4",
{Number, Number, String}] (* win3.1 etc. *)!!f:\Mathe/Daten/aadaten5 (* win3.1 etc. *)ReadList["f:\Mathe/Daten/aadaten5",
{Number, Number, String}] (* win3.1 etc. *)
Probiere eigene files!
• Essaie tes propres fichiers!
Studiere die "Befehle":
• Etudie les "ordres":
?*Record*?RecordLists?RecordSeparators?WordSeparators?NullRecords?NullWords?TokenWords
Studiere die Anwendungen:
• Etudie les applications:
![[Graphics:Images/AllFiles.HTML_gr_58.gif]](Images/AllFiles.HTML_gr_58.gif)
!!f:\Mathe/Daten/spsheet0 (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_59.gif]](Images/AllFiles.HTML_gr_59.gif)
ReadList["f:\Mathe/Daten/spsheet0",
{Number, Number, Number}](* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_60.gif]](Images/AllFiles.HTML_gr_60.gif)
ReadList["f:\Mathe/Daten/spsheet0",
Word, RecordLists ->True] (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_61.gif]](Images/AllFiles.HTML_gr_61.gif)
ReadList["f:\Mathe/Daten/spsheet0",
Word] (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_62.gif]](Images/AllFiles.HTML_gr_62.gif)
ReadList["f:\Mathe/Daten/spsheet0",
RecordLists ->True] (* win3.1 etc. *)Clear[x];
x = ReadList["f:\Mathe/Daten/spsheet0",
Word,
WordSeparators -> {"\t"},
RecordLists ->True] (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_63.gif]](Images/AllFiles.HTML_gr_63.gif)
ToExpression[x]?ToExpressionFullForm[x]ReadList["f:\Mathe/Daten/spsheet1",
{Word, Number, Number, Number},
WordSeparators -> {" "},
RecordLists ->True] (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_64.gif]](Images/AllFiles.HTML_gr_64.gif)
FullForm[%]
Zuerst definieren wir Funktionen. Damit kðnnen wir obigen Befehl "nachbilden":
• D'abord nous définissons des fonctions. Avec cela nous pouvons "imiter" l'ordre ci-dessus.
Clear[tabSeparate, tabSep];
tabSeparate[str_String]:= Apply[tabSep,
Characters[str]];
tabSep[x__String,"\t",y___String]:=
Flatten[{tabSep[x],tabSep[y]},1];
tabSep[x___String]:=
ToExpression[StringJoin[x]]/;
FreeQ[{x},"\t"];
ReadList["c:\work\AAGDaten.txt",
tabSeparate[String]]Clear[tabSeparate, tabSep];
tabSeparate[str_String]:=Apply[tabSep,
Characters[str]];
tabSep[x__String,"\t",y___String]:=
Flatten[{tabSep[x],tabSep[y]},1];
tabSep[x___String]:=
ToExpression[StringJoin[x]]/;
FreeQ[{x},"\t"];
ReadList["f:\Mathe/Daten/spsheet1",
tabSeparate[String]](* win3.1 etc. *)?Characters?FreeQ
Achtung! Mathematica ist nicht für Datamanagement und Datamanipulation gebaut. Man kann Daten in speziellen Datamanagement-Sprachen oder Programmen (low-level- Programmierung) viel schneller parsen (einlesen und interpretieren) sowie manipulieren. Dies ist bei grösseren Datenmengen wesentlich. Man denke z. B. an (1000 x 1000)- Matrizen in der Statistik, z.B. bei 1000 Beobachtungen von 1000 Variablen.
• Attention: Mathematica n'est pas conçu pour le "management" ni pour la manipulation des données. On peut lire et intérpréter ("parser") de même que manipuler beaucoup plus rapidement les données à l'aide de langages "datamanagement" ou programmes (programmation low-level). Cela est essentiel pour des quantités plus importantes de données. On pense p.ex. aux matrices (1000 x 1000) dans la statistique, p.ex. 1000 observations de 1000 variables.
Mit "!Kommando" kann ein externes Kommando ausgeführt werden. Leider haben wir auf NeXT keinen ModulaII-Compiler oder Java-Compiler, so dass wir selbst solche Kommandos bauen könnten. Eine andere Programmiersprache, die den Zweck erfüllen würde, wird an der Schule momentan nicht unterrichtet. Hier ist für NeXT das Programm "aa_ascii", das Umlaute in TeX-Format übersetzt. Studiere das Beispiel:
• Par "commandement !" on peut exécuter un commandement extérieur. Malheureusement nous n'avons pas de compilateur pour ModulaII ou Jave sur NeXT pour pouvoir construire de tels commandements. Une autre langue de programmation qui serve pour le même but n'est actuellement pas enseigné à cette école. Ici on utilise pour NeXT le programme "aa_ascii" qui transforme les "Umlaute" (métaphonie, voyelle infléchie) de l'allemand dans le format TeX. Etudie l'exemple:
!!f:\Mathe/Daten/spsheet2!f:\Mathe/Daten/aa_ascii
f:\Mathe/Daten/spsheet2
f:\Mathe/Daten/tex -tex;
ReadList["f:\Mathe/Daten/tex",
{Word, Number, Number, Number},
WordSeparators -> {" "},
RecordLists ->True]
Das "!Kommando" kann auch in ReadList stehen, falls es sich auf eine Operation auf einem File bezieht (und nicht zwei Files aufruft)! Folgendes geht nicht:
• Le "commandement !" peut se trouver aussi dans ReadList, s'il se rapporte à une opération sur un fichier (et n'appelle pas deux fichiers)! La chose suivante ne va pas:
ReadList["!f:\Mathe/Daten/aa_ascii
f:\Mathe/Daten/spsheet2
f:\Mathe/Daten/tex -tex ",
{Word, Number, Number, Number},
WordSeparators -> {" "},
RecordLists ->True]
Verwendung externer Programme für Datenmanipulationen von Mathematica aus mit Hilfe der Befehle "Install", "Links", "MLPut...",
"MLGet...", u.s.w. ...... .
Momentan sind keine Programme vorhanden, die problemlos auf irgendwelchen hier unbekannten Systemen laufen. Daher wird auf ein konkretes Beispiel verzichtet. Probiere daher mit eigenen Programmen.
• Utiliser des Programmes externes pour manipuler des données depuis Mathematica à l'aide des ordres "Install", "Links", "MLPut...",
"MLGet...", etc. .... .
Dans ce moment nous n'avons pas de programmes qui tournent sans problèmes sur n'importe quel système inconnu chez nous. C'est pourquoi nous renonçons à présenter un exemple concret. Essaie avec tes propres programmes.
Zuerst Daten erzeugen, die exportiert werden sollen:
• D'abord générer les données qui doivent être exportées:
Clear[daten];
daten = Table[Random[Integer,{1,9}],{2},{6}]
Studiere die Befehle:
• Etudie les ordres:
?>>?Put??WriteString?OpenWrite?Close?Scan?Rest
Zum Exportieren wollen wir eine Funktion definieren, die die Generierte in der Art Matrix "Zeilenvektor auf Zeile ... (Record) im File" schreibt:
• Nous allons définir une fonction pour exporter, qui écrit la générée dans la matrice dans le sens "vecteur de ligne sur ligne .... (Record) dans le fichier":
Remove[schreibMatrix];
Off[neufile];
schreibMatrix[fileName_String, data_List] :=
Block[{ neufile = OpenWrite[fileName]},
Scan[(WriteString[neufile,First[#]];
Scan[WriteString[neufile,
"\t",#]&,Rest[#]];
WriteString[neufile,"\n"])&,
data];
Close[neufile]];![[Graphics:Images/AllFiles.HTML_gr_65.gif]](Images/AllFiles.HTML_gr_65.gif)
![[Graphics:Images/AllFiles.HTML_gr_66.gif]](Images/AllFiles.HTML_gr_66.gif)
![[Graphics:Images/AllFiles.HTML_gr_67.gif]](Images/AllFiles.HTML_gr_67.gif)
!!f:\Mathe/Daten/neuDaten (* win3.1 etc. *) ?schreibMatrixStudiere: • Etudie:
?Save![[Graphics:Images/AllFiles.HTML_gr_68.gif]](Images/AllFiles.HTML_gr_68.gif)
f[x_] := Sin[x^2]/(E^(-x) Cos[x]);
Save["f:\Mathe/Daten/AAA_f", f]
(* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_69.gif]](Images/AllFiles.HTML_gr_69.gif)
!!f:\Mathe/Daten/AAA_f (* win3.1 etc. *)Studiere: • Etudie:
?>?>>?>>>?PutProbiere aus: • Essaie:
![[Graphics:Images/AllFiles.HTML_gr_70.gif]](Images/AllFiles.HTML_gr_70.gif)
Table[f[n], {n, 20}] >>
f:\Mathe/Daten/neuDaten (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_71.gif]](Images/AllFiles.HTML_gr_71.gif)
!!f:\Mathe/Daten/neuDaten (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_72.gif]](Images/AllFiles.HTML_gr_72.gif)
Put[Table[f[n], {n, 20}], Sin[x], "Hallo",
"f:\Mathe/Daten/neuDaten"] (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_73.gif]](Images/AllFiles.HTML_gr_73.gif)
!!f:\Mathe/Daten/neuDaten (* win3.1 etc. *)
Was ist mit den Daten von 14.2.3 passiert?
Aue s'est-il passé avec les données de 14.2.3?
2.^0.5 ![[Graphics:Images/AllFiles.HTML_gr_74.gif]](Images/AllFiles.HTML_gr_74.gif)
2.^0.5 >> f:\Mathe/Daten/neuDaten
(* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_75.gif]](Images/AllFiles.HTML_gr_75.gif)
!!f:\Mathe/Daten/neuDaten (* win3.1 etc. *)
Wieso ist das abgespeicherte Resultat genauer als das auf dem Schirm ausgegebene Resultat?
• Pourquoi le résultat mémorisé est-il plus exact que le résultat sorti sur l'écran?
Studiere die folgenden Befehle:
• Etudie les ordres suivants:
?Read?ReadList?OpenAppend?OpenRead?StringDrop?StringInsert?StringJoin?StringReplace?StringReverse?StringTake?StringLength?StringPosition?StringMatchQ?StringQ?StringToStream?WriteString?ToStringProbiere aus: • Essaie:
Table[StringJoin["daten.", ToString[i]],{i,6}]
Studiere die folgenden Befehle:
• Etudie les ordres suivants:
?InputForm?OutputFormBeispiele: • Exemples:
Clear[a];
a = x^5/x^2 y +x^y^5InputForm[a]OutputForm[a]![[Graphics:Images/AllFiles.HTML_gr_76.gif]](Images/AllFiles.HTML_gr_76.gif)
a >> f:\Mathe/Daten/neuDaten (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_77.gif]](Images/AllFiles.HTML_gr_77.gif)
!!f:\Mathe/Daten/neuDaten (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_78.gif]](Images/AllFiles.HTML_gr_78.gif)
Read["f:\Mathe/Daten/neuDaten"](* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_79.gif]](Images/AllFiles.HTML_gr_79.gif)
b = Read["f:\Mathe/Daten/neuDaten"]
(* win3.1 etc. *)b![[Graphics:Images/AllFiles.HTML_gr_80.gif]](Images/AllFiles.HTML_gr_80.gif)
!!f:\Mathe/Daten/neuDaten (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_81.gif]](Images/AllFiles.HTML_gr_81.gif)
Close["f:\Mathe/Daten/neuDaten"]
(* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_82.gif]](Images/AllFiles.HTML_gr_82.gif)
b = Read["f:\Mathe/Daten/neuDaten"]
(* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_83.gif]](Images/AllFiles.HTML_gr_83.gif)
Close["f:\Mathe/Daten/neuDaten"]
(* win3.1 etc. *)
Studiere die folgenden Befehle:
• Etudie les ordres suivants:
?CForm?FortranForm?TeXForm?SpliceBeispiele: • Exemple:
Clear[a];
a = x^5/z^2 y +x^y^5 +
( x^2 Sin[x^5/z^2 y +x^y^5]);CForm[a]FortranForm[a]TeXForm[a]
Im folgenden Beispiel wird gezeigt, wie in den Source-Code eines externen Programms (z.B. in C) direkt Mathematica-Ausdrücke eingesetzt und dann von Mathematica übersetzt werden kðnnen. Der externe Programmteil befindet sich im File AAA.mc. Das übersetzte Programm wird in AAA.c gespeichert!!!!!!!
• Dans l'exemple suivant on montre comme on peut mettre des expressions de Mathematica directement dans le Source-Code d'un autre programme extérieur (p.ex. dand C), ensuite ses expressions peuvent être traduites par Mathematica. La partie extérieur du programme se trouve dans le fichier AAA.mx resp. AAA.mc. Le programme traduit est mémorisé dans AAA.x resp. AAA.c !!!!!!!
![[Graphics:Images/AllFiles.HTML_gr_84.gif]](Images/AllFiles.HTML_gr_84.gif)
![[Graphics:Images/AllFiles.HTML_gr_85.gif]](Images/AllFiles.HTML_gr_85.gif)
!!f:\Mathe/Daten/AAA.mc (* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_86.gif]](Images/AllFiles.HTML_gr_86.gif)
Splice["f:\Mathe/Daten/AAA.mc"]
(* win3.1 etc. *)![[Graphics:Images/AllFiles.HTML_gr_87.gif]](Images/AllFiles.HTML_gr_87.gif)
!!f:\Mathe/Daten/AAA.c (* win3.1 etc. *)
Studiere die folgenden Befehle:
• Etudie les ordres suivants:
?Subscripted?Superscript?SequenceFormProbiere aus: • Etudie:
Subscripted[abc[145]]SequenceForm[uvw, Superscript[251]]Remove[a, n, m];
Format[a[n_, m_]] := Subscripted[a[n, m]];
Array[a, {2, 2}] // MatrixFormRemove["Global`@*"]
Studiere die nachfolgenden Beispiele und den Befehl Input:
• Etudie les exemples suivants et l'ordre Input
Remove[MeinReadList];
MeinReadList[fileName_String,
thing_:Expression]:=
Module[{file, expr, list = {}},
file = OpenRead[fileName];
If[ file === $Failed, Return[list] ];
While[ True,
expr = Read[file, thing];
If[ expr === EndOfFile, Break[] ];
AppendTo[list, expr]
];
Close[file];
list
];
![[Graphics:Images/AllFiles.HTML_gr_88.gif]](Images/AllFiles.HTML_gr_88.gif)
![[Graphics:Images/AllFiles.HTML_gr_89.gif]](Images/AllFiles.HTML_gr_89.gif)
Remove[MeinReadList];
MeinReadList[thing_:Expression] :=
Module[{file, fileName, expr, list = {}},
fileName = Input["Bitte einzulesende
Datei in Anführungszeichen angeben.
(Das File C:\work\AAFdaten.txt ...
sollte vorhanden sein.) -- S.v.p
enterer le fichier à lire entre
parenthèses.(Le fichier
C:\work\AAFdaten.txt doit exister.)"];
file = OpenRead[fileName];
If[ file === $Failed, Return[list] ];
While[ True,
expr = Read[file, thing];
If[ expr === EndOfFile, Break[] ];
AppendTo[list, expr]
];
Close[file];
list
];
MeinReadList[Number]
Schreibe eine Funktion, mit der sich das Multiplizieren der Zahlen von 1 bis 12 im Kopf trainieren und korrigieren lässt!
• Ecris une fonction par laquelle on peut exercer et corriger le calcul mental de la multiplication des nombres de 1 à 12 !
Remove[mult];
mult:=
Module[{faktor1, faktor2,
korrektur, resultat},
Clear[resultat];
resultat = ".";
While[ resultat != "y" || resultat !
= "Y" || resultat != "<y>" ||
resultat != "<Y>", faktor1 =
Random[Integer,{1,12}]; faktor2
= Random[Integer,{1,12}];
korrektur = faktor1 faktor2;
Print["Was gibt ",faktor1,
" mal ",faktor2,"?"];
resultat = Input[
"Bitte Resultat eingeben, oder beenden
mit dem Buchstaben y. -- S.V.P entrer le
résultat ou terminer à l'aide de y."];
If[ resultat == korrektur,
Print[resultat,
" ist richtig, bravo! ---
est juste, bravissimo!"],
Print[resultat,
"? - Richtig ist ---
résultat juste:",korrektur]
]
];
Print["Ende"]
];
multmult
Uebersetze die folgenden Ausdrücke mit Hilfe von Mathematica in C und in Fortran:
• Traduis les expressions suivantes à l'aide de Mathematica dans C et dans Fortran:
a) D[z Exp[z]
b) a^x
c) Sin[Pi/5]
Lösung: • Solution:
Map[{CForm[#], FortranForm[#]}&,
{D[z Exp[z], z], a^x, Sin[Pi/5]}]
Schreibe ein C-Programm, ein Fortran-Programm oder ein TeX-Programm, in dem Splice zur Anwendung kommt.
• Ecris un programme C, un programme Fortran ou un Programme TeX, dans lequel on applique Splice
Im folgenden Beispiel wird gezeigt, wie in den Source-Code eines externen Programms (hier in TeX) direkt Mathematica-Ausdrücke eingesetzt und dann von Mathematica übersetzt werden kðnnen. Der externe Programmteil befindet sich im File C:\work\AAATeX.txt. Das übersetzte Programm wird in C:\work\AAA.tex gespeichert !!!!!!!
• Dans l'exemple suivant on montre comme on peut mettre directement des expressions de Mathematica dans le sorce-code d'un programme extérieur (ici dans TeX), ensuite elles peuvent être traduites par Mathematica. La partie extérieure du programme se trouve dans le fichier C:\work\AAATeX.txt. Le programme traduit dans le fichier C:\work\AAA.tex !!!!!!!!
![[Graphics:Images/AllFiles.HTML_gr_90.gif]](Images/AllFiles.HTML_gr_90.gif)
!!C:\work\AAATeX.txt![[Graphics:Images/AllFiles.HTML_gr_91.gif]](Images/AllFiles.HTML_gr_91.gif)
![[Graphics:Images/AllFiles.HTML_gr_92.gif]](Images/AllFiles.HTML_gr_92.gif)
![[Graphics:Images/AllFiles.HTML_gr_93.gif]](Images/AllFiles.HTML_gr_93.gif)
![[Graphics:Images/AllFiles.HTML_gr_94.gif]](Images/AllFiles.HTML_gr_94.gif)
Splice["C:\work\AAATeX.mtex"]![[Graphics:Images/AllFiles.HTML_gr_95.gif]](Images/AllFiles.HTML_gr_95.gif)
![[Graphics:Images/AllFiles.HTML_gr_96.gif]](Images/AllFiles.HTML_gr_96.gif)
!!f:\Mathe/Daten/AAA.tex (*win31...*)
Gegeben sei b[c, d]. Schreibe einen Befehl, der c als Subscript und d als Superscript wiedergibt!
• Soit donné b[c, d]. Ecris un ordre qui rend c comme subscript et d comme superscript.
Eine Lðsung: • Une solution:
?FormatFormat[b[c_,d_]] :=
SequenceForm[Subscripted[b[c]],
Superscript[d]];
b[c, d]b[3, 5]c[3, 5]
Was ist passiert?
• Que s'est-il passé?
Schreibe eine Funktion zur Berechnung der Glieder der Fibonacci-Folge bis zum n-ten Glied und speichere die Glieder sowie die Funktion in ein File.
• Ecris une fonction pour calculer les membres de la suite de Fibonacci jusqu'au n-ième membre et mémorise les membres ainsi que la fonction dans un fichier.
Remove[fib];
fib[0] = 1;
fib[1] = 1;
fib[n_Integer] = fib[n-1]+fib[n-2];
fib[n_] = 0 ;
?fib{fib[0],fib[1],fib[2],fib[3],fib[4],fib[5],
"Test",fib[1.3]}fib[10]![[Graphics:Images/AllFiles.HTML_gr_97.gif]](Images/AllFiles.HTML_gr_97.gif)
![[Graphics:Images/AllFiles.HTML_gr_98.gif]](Images/AllFiles.HTML_gr_98.gif)
![[Graphics:Images/AllFiles.HTML_gr_99.gif]](Images/AllFiles.HTML_gr_99.gif)
Save["f:\Mathe/Daten/AAA_fib", fib];
!!f:\Mathe/Daten/AAA_fib (*win31...*)![[Graphics:Images/AllFiles.HTML_gr_100.gif]](Images/AllFiles.HTML_gr_100.gif)
![[Graphics:Images/AllFiles.HTML_gr_101.gif]](Images/AllFiles.HTML_gr_101.gif)
Table[fib[n], {n, 0, 10}] >>
"f:\Mathe/Daten/AAA_fib";
!!f:\Mathe/Daten/AAA_fib (*win31...*)Remove[schreibFib];
schreibFib[fileName_String, zahl_Integer] :=
Block[{ neufile = OpenWrite[fileName],
n = 0},
While[n<=zahl,
WriteString[neufile,fib[n]];
WriteString[neufile,"\t"];
n++];
(*WriteString[neufile,"\t"];*)
Close[neufile]];![[Graphics:Images/AllFiles.HTML_gr_102.gif]](Images/AllFiles.HTML_gr_102.gif)
![[Graphics:Images/AllFiles.HTML_gr_103.gif]](Images/AllFiles.HTML_gr_103.gif)
![[Graphics:Images/AllFiles.HTML_gr_104.gif]](Images/AllFiles.HTML_gr_104.gif)
![[Graphics:Images/AllFiles.HTML_gr_105.gif]](Images/AllFiles.HTML_gr_105.gif)
Remove["Global`@*"]
Problem: Externe Programme und Programmpackete schreiben.
Mathematica selbst ist in C geschrieben. Externe Programme, sogenannte Packages, sind aber in Mathematica selbst geschrieben. Bsp.: "Calculus`DSolveIntegrals`"
• Problème: Ecris les programmes extérieurs et des paquets de programmes. Mathematica est écrit en C. Les programmes extérieurs, les dits Packages, sont écrits dans Mathematica même. Ex.:
"Calculus`DSolveIntegrals`"
Es ist klar, dass man häufig gebrauchte Funktionen oder Prozeduren etc. nicht immer wieder neu schreibt. Andere möchten auch gerne profitieren. So schreibt man eben externe Programme, die nach Bedarf zuladbar sind.
• Il est clair qu'on n'écrit pas chaque fois à nouveau des fonctions ou des procédures ets. fréquentes. Les autres aimeraient aussi en profiter. Ainsi on écrit des programmes extérieurs qu'on peut ajouter quand on en a besoin.
Die mitgelieferten Packages sieht man unter (Info, Open Function Browser, Packages) neu Help, Add-ons, Standard Packages, .... . Nach dem Anklicken (Evaluate Template und dann Loaded Packages, Update Packages kann man im Browser das geladene Package anklicken und sieht die darin enthaltenen Funktionen) neu COPY-PASTE.
• Les Packages livrés se trouvent sous (Info, Open Function Browser, Packages) nouveau Help, Add-ons, Standard Packages, .... . Après avoir marqué à la souris (Evaluate Template et ensuite Loaded Packages, Update Packages on peut marquer à la souris le Package chargé dans le Browser, on y voit les fonctions qui y sont contenues. ) nouveau COPY-PASTE.
Lade das nachfolgende Package und schaue im Browser nach, welche Funktionen darin enthalten sind (Browser: Loaded Packages, Update Packages, anklicken etc.) neu Help, Add-ons, Standard Packages, ....
• Charge le Package suivant et regarde dans le Browser quelles fonctions y sont contenues. (Browser: Loaded Packages, Update Packages, marquer à la souris etc.) nouveau Help, Add-ons, Standard Packages, ....
Needs["Statistics`DescriptiveStatistics`"]![[Graphics:Images/AllFiles.HTML_gr_106.gif]](Images/AllFiles.HTML_gr_106.gif)
Ein Context ist vergleichbar mit einem Directory (Verzeichnis) oder einem Subdirectory (Folder). An die Namen der Variablen oder Symbolen wird dort der Contextname angehängt, so dass es sich dann um lokale Objekte handelt. Das verhindert Namenkollision. Contexte können geschachtelt sein. Bisher haben wir immer im globalen Context gearbeitet. Probiere aus:
• Un contexte est comparable à un directoire (index) ou à un sous-directoire (Subdirectory, Folder). On y ajoute le nom du contexte aux noms des variables ou des symboles, de façon qu'il s'agisse ensuite d'objets locaux. Cela évite des collisions de noms. Les contextes peuvent être emboîtés. Jusqu'à présent nous avons toujours travaillé dans le contexte global. Essaie:
?$Path$Path
Studiere die Befehle:
• Etudie les ordres:
?Context?$Context?$ContextPath?*Context*?Dir*?DirectoryProbiere aus: • Essaie:
$ContextPathContext[ParametricPlot]Context[Integrate]Studiere: • Etudie:
x = 2;
Remove[a];
{Context[x], Context[a], Context[Tuten]}
In welchem Context sind die geschaffenen Symbole?
• Dans quel contexte se trouvent les symboles crées?
Benzin = 50 Liter;
Auto`Benzin =
"Interessiert den Umweltschutz. --
Interessant pour la protection naturelle.";?Benzin?*`Benzin ?Auto`Benzin
Wird der Context "Global" angegeben bei einer Abfrage?
Teste das aus:
• Est-ce que le contexte "Global" est iniqué lors d'une interrogation? Fais un test:
`StudentError`Hoppla =
"Das war wohl nicht so gemeint!
Ce n'est certainement pas l'intention!";`StudentError`HopplaGlobal`StudentError`Hoppla
Dies ist möglich mit der Variable $Context. Studiere:
• Cela est possible avec la variable $Context. Etudie:
Benzin$Context = "Auto`"Benzin$Context$Context = "Global`"Benzin
Mit den Befehlen Begin, BeginPackage, End, EndPackage wird der Context gewechselt. Studiere:
• Par les ordres Begin, BeginPackage, End, EndPackage on change de contexte. Etudie:
?Begin?BeginPackage?End?EndPackageProbiere aus: • Essaie:
$Context$ContextPathBegin["Versuch`"]$Context$ContextPath
Nun führen wir eine Variable ein:
• Nous introduisons une variable:
dumm = "frech und beschränkt --
mal poli et borné"Context[dumm]End[ ]$Context$ContextPath?dumm?Versuch`dumm
In welchem Context sind wir jetzt und wie ist der Pfad gesetzt?
• Dans quel contexte somme-nous maintenant et comment le chemin est-il posé?
Probiere aus: • Essaie:
BeginPackage["HalloWach`"]$Context$ContextPath
Was ist der Unterschied zwischen Begin und BeginPackage?
Probiere jetzt früher definierte Variablen aus:
• Quelle est la différence entre Begin et BeginPackage?
Essaie maintenant des variables définies il y a un certain temps:
?Benzin?Global`Benzindummdumm =
"blöd und lieb zur Hälfte und beides
zusammen -- idiot et aimable à moitié
ou toutes les deux ensembles"EndPackage[]$Context$ContextPathdummContext[dumm]{Versuch`dumm, dumm}
Zur Verfügung stehen die Befehle <<, Get und Needs.
Studiere die Befehle:
• Les ordres suivants sont à disposition: <<, Get et Needs.
Etudie les ordres:
?<<?Get?Needs?$Path$Path
Hinweis: Die Variable $Path wird im File init.m gesetzt! (C:\Programme\Wolfram Research\Mathematica\3.0\Configuration\Kernel.) Dieses File kann von einem selbst modifiziert werden. (NeXT: Es soll sich bei privaten Installationen im eigenen Root befinden.) Beim Start von Mathematica wird es gelesen.
• Retenir: La variable $Path est mise dans le fichier init.m! (C:\Programme\Wolfram Research\Mathematica\3.0\Configuration\Kernel.) On peut modifier soi-même ce fichier. (NeXT: Il doit se trouver dans le propre Root quant il s'agit d'installations privées.) Il est lu quand on démarre Mathematica.
Bemerkung: "Packages" befindet sich in $Path! Führe die folgenden Befehle nacheinander aus:
• Remarque: "Packages" se trouve dans $Path! Exécute les ordres suivants l'un après l'autre:
![[Graphics:Images/AllFiles.HTML_gr_107.gif]](Images/AllFiles.HTML_gr_107.gif)
?HelixRemove[Helix]<< Graphics/Shapes.m;
?Helix$ContextPath<< Graphics`Shapes`;
?Helix<< Graphics/Shapes.m;
?HelixNeeds["Graphics`Shapes`"]$ContextPath
Was ist der Unterschied gewesen zwischen Get und Needs?
• Quelle était la différence entre Get et Needs?
Get["Graphics`Shapes`"]Needs["Graphics`Shapes`"]Versuche: • Essaie:
BeginPackage["Graphics`Shapes`",
"Geometry`Rotations`"]$ContextPathVersuche: • Essaie:
?Rotate2D?Geometry`Rotations`Rotate2D?Graphics`Shapes`Helix (*Old Vers.*)?Geometry`Rotations`*?Graphics`Shapes`* (*Old Vers.*)?Geometry`*`*
Achtung: private bedeutet "zugriffgeschützt"! Es wird keine spezifische Information abgegeben. Beispiel:
• Attention: Privé signifie "ne peut pas être saisi"! On ne donne pas d'information spécifique. Exemple:
?Geometry`Rotations`private`phi (*Old Vers.*)?Geometry`Rotations`private`* (*Old Vers.*)?Geometry`Rotations`private`vec (*Old Vers.*)
Welche Packages sind da? Wir suchen z.B. ein Objekt, in dessen Namen hinter dem "`" ein "a" vorkommt:
• Quels Packages y a-t-il? Nous cherchons p.ex. un objet, dans le nom duquel il y a un "`" suivi d'un "a" :
?*`a*
Studiere die folgenden Beispiele konsequent durch!
• Fais une étudie approfondie des exemples suivants!
(*********************************************************************
Adapted from
Roman E. Maeder: Programming in Mathematica,
Second Edition, Addison-Wesley, 1991.
Wichtig: Gute Dokumentation! • Important: Bonne documentation!
*********************************************************************)
BeginPackage["Graphics`ArgColors`"]
(* Wichtig: $Context und $ContextPath wechseln! *)
(*• Important: Changer $Context et $ContextPath ! *)
(* Wichtig: Die hier definierten Funktionen, z.B. ArgColor, sind *)
(* nach aussen sichtbar. Die Symbole dafür werden in diesem *)
(* Context kreiert. *)
(* • Important: Les fonctions définies ici, p.ex. ArgColor, sont *)
(* visibles à l'extérieur. Les symboles en sont crées dans ce *)
(* contexte. *)
ArgColor::usage = "ArgColor[z] gives a color value whose hue is proportional
to the argument of the complex number z."
ArgShade::usage = "ArgShade[z] gives a gray level proportional
to the argument of the complex number z."
ColorCircle::usage = "ColorCircle[r, (light:1)] gives a color value whose hue
is proportional to r (mod 2Pi) with lightness light."
(* Wichtig: usage-Statement für alle aussen sichtbaren Funktionen *)
(* • Important: usage-Statement visibles pour toutes les fonctions *)
(* visibles à l'extérieur. *)
Begin["`Private`"]
(* Wichtig: $Context wechselt auf `Private`, *)
(* • Important: $Context devient `Private`, *)
(* $ContextPath bleibt • reste. *)
(* Wichtig: Hier neu definierte Funktionen sind aussen unsichtbar! *)
(* • Important: Les fonctions définies ici nouvellement ne sont pas*)
(* visibles à l'extérieur! *)
HelperFunction[z_] := Print["Mich siehst Du von aussen nicht", z]
ArgColor[z_] := RGBColor[1, 1, 1] /; z == 0.0
ArgColor[z_] := ColorCircle[ Arg[z] ] /; NumberQ[N[arg]]
ArgShade[z_] := GrayLevel[1] /; z == 0.0
ArgShade[z_] := GrayLevel[N[(Pi + Arg[z])/(2Pi)] ] /; NumberQ[N[Arg[z]]]
ColorCircle[arg_, light_:1.0] := Hue[ N[arg/2/Pi], 1, light] /; NumberQ[N[arg]]
End[ ]
(* Wichtig: $Context wechselt zurück *)
(* auf den Wert vor dem Aufruf von `Private` *)
(* • Important: $Context reprend la forme d'origine *)
(* sur la valeur d'avant l'apppel de `Private` *)
Protect[ArgColor, ArgShade, ColorCircle]
(* Wichtig: Die aussen sichtbaren Funktionen werden geschützt. *)
(* • Important: Les fonctions visibles à l'extérieur sont protégées. *)
EndPackage[ ]
(* Wichtig: $Context wird zurückgewechselt auf den alten Wert. *)
(* Wichtig: Zu $ContextPath wird der Name *)
(* "Graphics`ArgColors`" hinzugefügt. *)
(* • Important: $Context reprend la valeur d'origine. *)
(* • Important: On ajoute à $ContextPath le nom *)
(* "Graphics`ArgColors`" . *)
(*********************************************************************
Adapted from
Roman E. Maeder: Programming in Mathematica,
Second Edition, Addison-Wesley, 1991.
(Obige Kopie aus der Library etwas abgeändert,
so dass sie auf NeXT... lauffähig ist.
• La copie de Libary ci cessus un peu changée,
de façon qu'elle puisse fonctionner sur NeXT
.....)
*********************************************************************)
BeginPackage["Test`"];
argColor1::usage =
"ArgColor[z] gives a color value whose hue is
proportional;
to the argument of the complex number z."
argShade1::usage =
"ArgShade[z] gives a gray level proportional
to the argument of the complex number z.";
colorCircle1::usage =
"ColorCircle[r, (light:1)] gives a color value
whose hue is proportional to r (mod 2Pi)
with lightness light.";
Begin["`Private`"];
argColor1[z_] := RGBColor[1, 1, 1] /;
z == 0.0 ;
argColor1[z_] := ColorCircle[ Arg[z] ] /;
NumberQ[N[Arg]] ;
argShade1[z_] := GrayLevel[1] /; z == 0.0
argShade1[z_] := GrayLevel[N[(Pi +
Arg[z])/(2Pi)] ] /;
NumberQ[N[Arg[z]]] ;
colorCircle1[arg_, light_:1.0] :=
Hue[ N[arg/2/Pi], 1, light] /;
NumberQ[N[Arg]] ;
End[];
Protect[argColor1, argShade1, colorCircle1]
EndPackage[];
(*********************************************************************
Adapted from
Roman E. Maeder: Programming in Mathematica,
Second Edition, Addison-Wesley, 1991.
(Obige Kopie aus der Library etwas abgeändert,
so dass sie auf NeXT.. lauffähig ist, jetzt mit
Abfrage der Context-Variablen und des Context-
Pfades.
• La copie de Libary ci cessus un peu changée,
de façon qu'elle puisse fonctionner sur NeXT
.., maintenant avec interrogation (appel) des
variables du contexte et du chemin du
contexte.)
*********************************************************************)
Print["1. Abfrage: $ContextPath = ",
$ContextPath, " $Context = ", $Context];
BeginPackage["Test`"];
Print["2. Abfrage: $ContextPath = ",
$ContextPath, " $Context = ", $Context];
argColor1::usage =
"ArgColor[z] gives a color value whose hue is
proportional;
to the argument of the complex number z."
argShade1::usage =
"ArgShade[z] gives a gray level proportional
to the argument of the complex number z.";
colorCircle1::usage = "ColorCircle[r,
(light:1)] gives a color value
whose hue is proportional to r (mod 2Pi)
with lightness light.";
Begin["`Private`"];
Print["3. Abfrage: $ContextPath = ",
$ContextPath, " $Context = ", $Context];
argColor1[z_] := RGBColor[1, 1, 1] /;
z == 0.0 ;
argColor1[z_] := ColorCircle[ Arg[z] ] /;
NumberQ[N[Arg]] ;
argShade1[z_] := GrayLevel[1] /;
z == 0.0
argShade1[z_] := GrayLevel[N[(Pi +
Arg[z])/(2Pi)] ] /;
NumberQ[N[Arg[z]]] ;
colorCircle1[arg_, light_:1.0] :=
Hue[ N[arg/2/Pi], 1, light] /;
NumberQ[N[Arg]] ;
End[];
Print["4. Abfrage: $ContextPath = ",
$ContextPath, " $Context = ", $Context];
Protect[argColor1, argShade1, colorCircle1]
EndPackage[];
Print["5. Abfrage: $ContextPath = ",
$ContextPath, " $Context = ", $Context];
(*********************************************************************
Copyright 1991 by Roman E. Maeder
Adapted from
Roman E. Maeder: Programming in Mathematica,
Second Edition, Addison-Wesley, 1991.
Permission is hereby granted to make copies of this file for
any purpose other than direct profit, or as part of a
commercial product, provided this copyright notice is left
intact. Sale, other than for the cost of media, is prohibited.
Permission is hereby granted to reproduce part or all of
this file, provided that the source is acknowledged.
*********************************************************************)
(* Enclosed with Mathematica by permission *)
BeginPackage["Examples`Collatz`"]
Collatz::usage =
"Collatz[n] gives a list of the iterates in the 3n+1 problem,
starting from n. The conjecture is that this sequence always
terminates."
StoppingTime::usage = "StoppingTime[n] finds the total stopping time
of the integer n. This is the length of the Collatz sequence
before hitting 1."
FindMaxima::usage = "FindMaxima[from] reports successive maxima of the
total stopping time starting the search with the integer from."
Begin["`Private`"]
Collatz[n_Integer] := AppendCollatz[{}, n]
AppendCollatz[sofar_, 1] := Flatten[{sofar, 1}]
AppendCollatz[sofar_, n_Integer] :=
AppendCollatz[{sofar, n}, 3 n + 1] /; OddQ[n]
AppendCollatz[sofar_, n_Integer] :=
AppendCollatz[{sofar, n}, n / 2] /; EvenQ[n] && n != 0
StoppingTime[n_Integer?Positive] :=
Module[{i=1, m=n}, While[m != 1, m = If[OddQ[m], 3m+1, m/2]; i++];i ]
FindMaxima[low_] :=
Module[{m=0, n=0, i=low, j},
While[ True,
j = StoppingTime[i];
If[j > m, m = j; n = i;
Print["StoppingTime[", n, "] = ", m] ];
i++;
If[ Mod[i, 100] == 0, Print["i = ", i] ]
]
]
End[]
Protect[ Collatz, StoppingTime, FindMaxima ]
EndPackage[ ]
Studiere die folgende Abfolge:
• Etudier la suite suivante:
LaplaceTransform[(1+4t+5t^2) Exp[-3t], t, s]
Die gerufene Funktion war noch unbekannt. Das Symbol LaplaceTransform ist aber jetzt kreiert worden, allerdings ohne konkreten Inhalt.
• La fonction appelée était encore inconnue. Le symbole LaplaceTransform a été crée maintenant, cependant sans contenu concret.
?LaplaceTransform
Laden des Packages:
• Charger le Package:
Needs["Calculus`LaplaceTransform`"]?LaplaceTransform
Die in Global` vorher kreierte Funktion überschattet immer noch die in einem "Unter-Context" zugeladene Funktion mit demselben Namen.
• La fonction créée auparavant dans Global` recouvre encore la fonction du même nom qui se trouve dans un sous-contexte.
Remove[LaplaceTransform]
Die in Global` existierende Funktion wird eliminiert. Die darunter liegende zeigt sich jetzt.
• La fonction existant dans un Global` est élininée. Celle qui se trouve dessous devient visible.
?LaplaceTransform
Nun kann man sie auch verwenden:
• Maintenant on peut aussi l'utiliser:
LaplaceTransform[(1+4t+5t^2) Exp[-3t], t, s]
Was gibt es sonst noch im geladenen Package?
• Qu'y a-t-il encore dans le Package chargé?
?Calculus`LaplaceTransform`*
Im Folgenden wird ein Prototyp eines Packages demonstriert, das ursprünglich von Henry Cejtin und Theo Gray stammen soll:
• Dans ce qui suit on démontre un prototype d'un Package qui a été créé, soit-disant, par Henry Cejtin et Theo Gray.
![[Graphics:Images/AllFiles.HTML_gr_108.gif]](Images/AllFiles.HTML_gr_108.gif)
![[Graphics:Images/AllFiles.HTML_gr_109.gif]](Images/AllFiles.HTML_gr_109.gif)
OpenWrite[
"AAKurs15.m"];
WriteString[
"AAKurs15.m",
"\n",
"!!!!!!
Du sollst das Package von Hand in das File",
"\n","AAKurs15.m kopieren."
"Il faut copier le Package à la main dans le
File", "\n","AAKurs15.m kopieren." ];
(* End WriteString *)
Close["AAKurs15.m"];
(*
* AAKurs15.m
*
* This package demonstrates the recommended
* package style.
*
*)
(*
* Prepend the context ProtoNotebook` to
* $ContextPath.
* Then Needs will be able to determine when
* the package
* has been loaded.
*)
BeginPackage["AAKurs15`"];
EndPackage[];
(*
* Now the usage statements.
*)
ExamplePlot::usage = "ExamplePlot[n,m] draws \
n starbursts and m spirals. \
ExamplePlot[n] draws n starbursts and
no spirals.";
SamplePlot::usage =
"SamplePlot is Vaporware. It \
does nothing.";
(*
* Now the global objects.
*)
ExamplePlot;
SamplePlot;
(*
* Now the private context. The objects here
* are not \
* intended to be accessed by the user.
*)
Begin["AAKurs15`Private`"];
(*
* Local objects.
*)
`starBurst;
`spiral;
(*
* Define starBurst and spiral.
*)
starBurst[center_, radius_, n_] :=
Block[
{ `r },
Table[
Line[{center,
center + radius {Cos[r],
Sin[r]}
}],
{r, 0, 2Pi - 2Pi/n, 2Pi/n}
]
];
spiral[center_, radius_, loops_] :=
Block[
{ `t },
Line[
Table[center +
radius t {Cos[t], Sin[t]}/(2Pi
loops),
{t, 0, 2Pi loops, 2Pi/30}
]
]
];
ExamplePlot[stars_] :=
Show[
Graphics[
Table[
starBurst[
4 {Random[], Random[]},
0.3 + Random[],
20
],
{stars}
]
],
AspectRatio -> Automatic
];
ExamplePlot[stars_, spins_] :=
Show[
Graphics[{
Table[
starBurst[
4 {Random[], Random[]},
0.3 + Random[],
20
],
{stars}
],
Table[
spiral[
4 {Random[], Random[]},
0.3 + Random[],
Random[Integer, {2, 5}]
],
{spins}
]
}],
AspectRatio -> Automatic
];
(*
* Protect now the function and lock the private
* functions.
*)
Protect[ExamplePlot, SamplePlot];
Append[Attributes[ExamplePlot], Locked];
Append[Attributes[SamplePlot], Locked];
End[];
Schaue ins File • Regarde le fichier
C:\Programme\Wolfram Research\Mathematica\3.0\AAKurs15.nb !!!!!!!!!!!!
Needs["AAKurs15`"]![[Graphics:Images/AllFiles.HTML_gr_110.gif]](Images/AllFiles.HTML_gr_110.gif)
![[Graphics:Images/AllFiles.HTML_gr_111.gif]](Images/AllFiles.HTML_gr_111.gif)
![[Graphics:Images/AllFiles.HTML_gr_112.gif]](Images/AllFiles.HTML_gr_112.gif)
Needs["AAKurs15`"]?SamplePlot?ExamplePlotExamplePlot[4, 3]ExamplePlot[5]SamplePlot[5]
Im folgenden Beispiel wird gezeigt, wie ProtoNotbook` in den Context PlottingExamples` eingelesen wird. Probiere die verschiedenen Situationen durch:
• Dans l'exemple suivant on montre comme ProtoNotbook` est mis dans
le contexte PlottingExamples`. Essaie les différentes situations:
?SymbolicSumRemove["Global`@*"]End[]?*SamplePlot$ContextBegin["PlottingExamples`"];
$Context$ContextPath?SymbolicSum?*SamplePlotNeeds["Algebra`SymbolicSum`"]?Algebra`SymbolicSum`*$Context$ContextPatha = 1aEnd[]a$Context$ContextPath?Algebra`SymbolicSum`*
Dieses File hier ist ein Notebook. In solchen Notebooks oder allgemein bei der interaktiven Benützung von Mathematica mit einem Front-End, das mit Zellen arbeitet, können Probleme mit dem Context auftreten, wenn man nicht aufpasst. Studiere das folgende Beispiel:
• Le fichier est un Notebook. Dans des Notebooks de ce genre ou plus généralement quand on utilise interactivement Mathematica avec un Front-End qui travaille avec des cellules, il peut y avoir des problèmes avec le contexte quand on ne fait pas attention. Etudie l'exemple suivant:
Remove["Global`@*"]esel = "Dummes menschliches Individuum,
Anwesende immer ausgeschlosen. --- Etre humain
bête, personnes présents exclus." Context[esel]BeginPackage["Zoologie"];
esel = "Säugetier im Dienste des Menschen.
--- Mammifèr au service des hommes";eselContext[esel]Global`eselZoologie`eselEndPackage[]esel
Wo ist der eingangs eingegebene "Wert" der Variablen "esel" geblieben?
• Où a disparu la "valeur" de la variable "esel" entrée au début?
Remove["Global`@*"]
Lade das Package "Colors.m" aus "Graphics". Liste alle Farben auf.
• Charger le Package "Colors.m" de "Graphics". Fais une liste des couleurs.
Needs["Graphics`Colors`"]?Graphics`Colors`*
Schreibe ein Mathematica-Package, das den Mittelwert (mean) und den Median einer Liste berechnet. In der folgenden Lösung wird die Standard-Lösung aus den mitgelieferten Packages kopiert und präsentiert.
• Ecris un Package de Mathematica, qui calcule la valeur moyenne et la médiane d'une liste. Dans la solution suivante, la solution standard est copiée et présentée dans les Packages livrées.
Standard-Package einlesen:
• Lire le Package standard:
Needs["Statististics`DescriptiveStatistics`"]?Median?Mean
Standard-Package anschauen:
• Regarde le Package standard:
!!Statistics`DescriptiveStatistics`?ReadListOptions[Put]?NullRecordsreadIn = ReadList[
"Statistics`DescriptiveStatistics`",
Record,RecordSeparators -> {"\n","\t"}];
readIn >> f:\Mathe/Daten/DataRec;
readIn >> f:\Mathe/Daten/DataRec.ma;
readIn = ReadList[
"Statistics`DescriptiveStatistics`",
String];
readIn >> f:\Mathe/Daten/DataOutS;
readIn >> f:\Mathe/Daten/DataOutS.ma;
Diese Files können nun editiert und von Hand manipuliert werden. Z.B. wie folgt:
• Ces fichiers peuvent être édités maintenant et manipulés à la main. P. ex. de la façon suivante:
OpenWrite["Statisti.m"];
WriteString["Statisti.m",
"\n",
"Du sollst das Package von Hand in das File","\n",
"Statisti.m kopieren."
]; (* End WriteString *)
Close["Statisti.m"];
(* Author: Student Heimlich Fileklau *)
(* History: Original version ... 1989. *)
(*Revised 1995. *)
(* Summary: This package computes descriptive *)
(* statistics *)
(* Keywords: mean, median *)
BeginPackage["AAAStatistics`"];
EndPackage[ ];
mean::usage =
"mean[list] gives the mean of the entries \
in list.";
median::usage =
"median[list] gives the median of the \
entries in list.";
Begin["`Private`"];
mean[list_] := Apply[Plus, list]/Length[list] /;
VectorQ[list] && Length[list] > 0;
median[list_] := Sort[list][[
(Length[list]+1)/2]] /;
VectorQ[list] &&
OddQ[Length[list]];
median[list_] := Block[{s, n},
s =Sort[list] ;
n = Length[list] ;
(s[[n/2]] + s[[n/2 + 1]]) / 2] /;
VectorQ[list] && EvenQ[Length[list]];
End[ ];
(* Protect[mean, median];
SetAttributes[ mean, ReadProtected];
SetAttributes[ median,ReadProtected]; *)
Needs["AAAStatistics`"]?AAAStatistics`*?mean?medianmean[{1,2,3,4,5,6,7,8,9}]mean[{1,2,3,4,5,6,7,8}]median[{1,2,3,4,5,6,7,8}]median[{1,2,3,4,5,6,7,8,9}]
Zum Beispielprogramm: Funktioniert es immer gut und somit tadellos? - Wenn nicht, so korrigiere es! Wenn Du Erfolg hast und es besser machen kannst, so hast Du ein grosses Ziel erreicht!
• Quant au programme exemple: Fonctionne-t-il toujours bien et donc sans erreurs? - Si non, corrige-le. Si tu as du succès et que tu peux le faire mieux, tu as atteint un grand but!
Remove["Global`@*"]
1) Inhaltsverzeichnis
• Table des matières EINST_00.nb
2) Einführung
• Introcuction EINST_01.nb - EINST_11.nb
3) Kurs
• Cours KURS_01.nb - KURS_15.nb
4) Uebungen
• Excercises UEB_00.nb - UEB_15.nb
5) Alles in einem File
• Tout dans un fichier AllFiles.nb
Mathematica 3.02, Windows98
Neues Verzeichnis erstellen:
• Faire un nouveau directoire:
Gehe mit dem Cursor in die Zelle und drücke "Eingabe"("Enter"):
• Va avec le curseur dans la cellule et presse "Entrer":
![[Graphics:Images/AllFiles.HTML_gr_113.gif]](Images/AllFiles.HTML_gr_113.gif)
Schreibe Daten ins File C:\work\AAADaten.txt:
• Ecrire des données dans le fichier C:\work\AABDaten.txt:
![[Graphics:Images/AllFiles.HTML_gr_114.gif]](Images/AllFiles.HTML_gr_114.gif)
Oder: • ou:
![[Graphics:Images/AllFiles.HTML_gr_115.gif]](Images/AllFiles.HTML_gr_115.gif)
Oder: • ou:
![[Graphics:Images/AllFiles.HTML_gr_116.gif]](Images/AllFiles.HTML_gr_116.gif)
Kontrolliere mit einem Editor die Files!
• Contrôle les fichiers à l'aide d'un éditeur!
Schreibe Daten ins File AAADaten.txt im aktuellenArbeitsverzeichnis:
• Ecrire des données dans le fichier AABDaten.txt dans le directoire actuel du travail:
![[Graphics:Images/AllFiles.HTML_gr_117.gif]](Images/AllFiles.HTML_gr_117.gif)
Kontrolle: • Contrôle:
![[Graphics:Images/AllFiles.HTML_gr_118.gif]](Images/AllFiles.HTML_gr_118.gif)