Demo Graphik  Graphiques

Einige Graphiken  Quelques Graphiques

Sollte mit Version 4.0, 4.1, 4.2, 5.0, WIN etc. laufen 
 Devrait fonctionner avec version  4.0, 4.1, 4.2, 5.0, WIN etc.

WIR03 // Copyright Rolf Wirz

Achtung für Architekten: Einige Themen sind für Anfänger - andere jedoch nicht. Jeder muss selbst merken, wo er steht und daher mit dem arbeiten, das er verstehen kann!

Inhalt  Index:

0.  Einleitungsbeispiel: Die Lady des Herrn Senti   Exemple comme introduction: La dame de Monsieur Senti
1.  Zweidimensionale Plots   Plots à deux dimensions
2.  Options   Options
3.  Mehrere Graphen in einem Bild   Plusieurs graphes en une image
4.  Parametrisierte Kurven   Courbes paramétrisées
5.  Weitere Optionen und Färbung   Autres options et couleurs, colorer
6.  Plots von Flächen im Raum   Plots de surfaces dans l'espace 
7.  Options für Farben, Beleuchtung, ....   Options pour couleurs, éclairage, ....
8.  Arbeiten mit Daten  (Für Fortgeschrittene....)   Travailler avec des données
9.  Eingebaute Graphikelemente oder Blðcke   Eléments ou blocs graphiques incorporés
10.  Beschriftung von Graphiken (Labels)   Doter des graphiques d'inscriptions (Labels)
11.  Graphik-Pakete   Paquets de graphiques
12. Animationen   Animations
13. PostScript-Code   PostScript-Code
14. Experimentieren mit Animationen    Expérimenter les animations
15. Probiere eigene Beispiele aus!  Essaie de propres exemples!  <======  !!!!!!!!
16. Export von Graphiken, weiterbearbeiten mir Graphik-Programmen  Exporter de graphiques, les traiter avec des autres programmes graphiques  
17.  Ringgraphiken  Graphiques en forme d'anneaux
18. Generieren von Namen  Générer des noms 
19. Möbius  Moebius

0.  Einleitungsbeispiel: Die Lady des Herrn Senti   Exemple comme introduction: La dame de Monsieur Senti

(Ob er sie selbst kreiert oder nur kopiert hat, hat er nicht mitgeteilt... - Il nous a jamais fait savoir, s'il l'a crée soi-même ou s'il l'a seulement copiée...)

f[x_] := Re[Sqrt[44^2 - x^2]/2]; 
    g[x_, y_] := 
      Re[Sqrt[44^2 - 
              4 ( x - 22)^2 - (y + 44)^2] (y/
                88)^2];
h[x_, y_] := 
        Re[Sqrt[44^2 - 
                4 ( x + 22)^2 - (y + 44)^2] (y/
                  88)^2];
k[x_, y_] := 
      Re[Sqrt[30 -  ( x - 22)^2 - (y + 74)^2] /5  + 
          Sqrt[10 - (x - 22)^2 - (y + 74)^2]]; 
    l[x_, y_] := 
      Re[Sqrt[30 -  ( x + 22)^2 - (y + 74)^2] /5  + 
          Sqrt[10 - (x + 22)^2 - (y + 
                    74)^2]];
z[x_, y_] := 
        f[x] + g[x, y] + h[x, y] + k[x, y] + 
          l[x, y];
Plot3D[z[x, y], {x, -44, 44}, {y, -95, 0}, 
        PlotPoints -> 100, ViewVertical -> {0, 1, 0}, 
        ViewPoint -> {1.5, -2, 1.5}, Axes -> False, 
        Boxed -> False];

1.  Zweidimensionale Plots
     Plots à deux dimensions

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}];

Funktionen definieren, ploten
  Définir des fonctions, dessigneroutput.

f[x_] :=  x^2;  g[x_] := Sin[x];  h[x_] := E^x;  
    r[x_] := Log[x];
Plot[{f[x], g[x], h[x], r[x]}, {x, 0.5, 2}];

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}];

rechteck[x_ /; (-1 ≤ x && x ≤ 1)] := 
        2;
rechteck[x_ /; Abs[x] > 1] := 0;
Plot[rechteck[x], {x, -3, 3}];

Plot[rechteck[x], {x, -3, 3}, 
        PlotStyle -> {{Thickness[0.01], GrayLevel[0.4]}}];

funkt[x_] := 
        Which[x ≤ Pi, -2 Sin[x], 
          x > Pi, (x^1.3 - Pi^1.3) Cos[x]];
Plot[funkt[x], {x, -2 Pi, 3  Pi}];

Remove[funkt];
funkt[x_] := 
        Which[x ≤ Pi, 2 Sin[x], 
          x > Pi, (x^1.3 - Pi^1.3) Cos[x]];
Plot[funkt[x], {x, -2 Pi, 3  Pi}];

2.  Options
     Options

2.1. Allgemeines
       En général

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:

??Plot

Options[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];

2.2. Die Voreinstellung von Mathematica kann abgefragt werden:
       La mise au point préalable de Mathematica peut être interrogée:

Options[Plot]

AspectRatio /. Options[Plot]

Plot[x^3, {x, 0, 1.5}, 
        PlotRange -> All]; 
Plot[x^3, {x, 0, 1.5}, AspectRatio -> Automatic, 
        PlotRange -> All];

??AspectRatio

PlotPoints /. 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

??Nest

Nest[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];

2.3. Probleme mit den Plot-Punkten:
       Problèmes avec les points-"plot":

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}]

2.4. Wechsel des Plot-Stils:
       Changement du style "plot":

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

??Graphics

PlotStyle /. Options[Plot]

Probiere aus:    Essayer:

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}]}}];

3.  Mehrere Graphen in einem Bild
     Plusieurs graphes en une image

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!

4.  Parametrisierte Kurven 
    Courbes paramétrisées

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];

5.  Weitere Optionen
     Autres options

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];

Füllungen, färben:
  Couleurs:

?*Fill*

Plot3D[Sin[x y], {x, 0, π}, {y, 0, π}, 
        PlotRange -> {-0.5, 0.5}, 
        ClipFill -> {GrayLevel[1], GrayLevel[0]}];

?Color*

?*Color*

Options[Plot]

?PlotStyle

Plot[BesselJ[2, x], {x, 0, 10}, 
      PlotStyle -> {{Thickness[0.02], GrayLevel[0.5]}}]

Plot[Sin[Sin[x]], {x, 0, 10}, 
      Background -> GrayLevel[0.6]]

Show[%, DefaultColor -> GrayLevel[1]]

Table[{AbsoluteThickness[n], Line[{{0, 0}, {n, 1}}]}, {n, 
        4}]

Show[Graphics[%]]

Show[
      Graphics[{Dashing[{0.05, 0.05}], 
          Line[{{-1, -1}, {1, 1}}]}]]

Show[
      Graphics[{Dashing[{0.01, 0.05, 0.05, 0.05}], 
          Line[{{-1, -1}, {1, 1}}]}]]

<< Graphics`FilledPlot`

?Fills

FilledPlot[{x^2/18, Cos[x], Sin[x], Cos[x - 1]}, {x, 0, 2 Pi}, 
        Curves -> Front];

FilledPlot[{x^2/18, Cos[x], Sin[x], Cos[x - 1]}, {x, 0, 2 Pi}, 
        Fills -> {{{1, Axis}, GrayLevel[ .8]}, {{2, 3}, 
              GrayLevel[ .3]}}, Curves -> Front];

FilledPlot[{x^2/18, Cos[x], Sin[x], Cos[x - 1], 5/(x + 1)}, {x, 
          0, 2 Pi}, 
        Fills -> {{{1, Axis}, GrayLevel[ .1]}, {{2, 3}, 
              GrayLevel[ .5]}, {{3, 4}, Hue[ .5]}, {{4, 5}, Hue[-2]}}, 
        Curves -> Front];

6.  Plots von Flächen im Raum
     Plots de surfaces dans l'espace

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!

7.  Options für Farben, Beleuchtung, ....
     Options pour couleurs, éclairage, ....

Probiere aus:    Essaie!

Options[Plot3D]

LightSources /. Options[Plot3D]

Lighting /. Options[Plot3D]

Probiere aus:    Essaie!

??SetOptions

SetOptions[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!

?ClipFill

Plot3D[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}];

8.  Arbeiten mit Daten
     Travailler avec des données

8.1. Allgemeines
       Notions générales

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:

??InterpolatingPolynomial

InterpolatingPolynomial[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];

8.2. "Regressionskurven"
        "Courbes de régression"

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, trentplot1, 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];

8.3. Unterdrückung des Graphik-Outputs (Zeit sparen!)
       Supprimer la sortie des graphes (économie de temps!)

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:

??$DisplayFunction

Show[plot1, plot2, plot3, 
	DisplayFunction -> $DisplayFunction];

??->

??:>

8.4. Plot von 3-dimensionalen Daten
       Plot de données à 3 dimensions

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];

9.  Eingebaute Graphikelemente oder Blðcke
     Eléments ou blocs graphiques incorporés

9.1. Allgemeines
       Notions générales

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:

??Map

graphicPts = 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];

9.2. Umwandlung von graphischen Objekten:
        Transformation d'objets graphiques:

Mit Hilfe welcher Graphic-Objekte wird ein Plot ausgeführt?
  A l'aide de quels objets graphiques exécute-t-on un plot?

??InputForm

basicPlot = 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
		];

9.2. Diverses    Des choses différentes

<<Graphics`Arrow`

Show[Graphics[{Arrow[{0, 0},{1, 1}],
    Hue[0], Arrow[{.75, .25},{.25, .75}], Hue[0.7], Arrow[{1.75, 1.25},{-1.25, 1.75}]}]];

{Arrow[{0, 0}, {1, 1}], Hue[0], Arrow[{ .75,  .25}, { .25,  .75}], 
      Hue[0.7], Arrow[{1.75, 1.25}, {-1.25, 1.75}]}

fla = 
      Flatten[Table[{Arrow[{n, 0}, {n + 1/2, 1}], Hue[n/10]}, {n, 0, 3, 
            1/10}]]

Show[Graphics[fla]];

Remove["Global`*"]

<< Graphics`FilledPlot`

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

FilledPlot[{Sin[x], Cos[x]}, {x, 0, 2 Pi}];

FilledPlot[{Sin[x], Cos[x]}, {x, 0, 2 Pi}];

FilledPlot[{Sin[x], Cos[x], x^2/18}, {x, 0, 2 Pi}];

FilledPlot[{x^2/18, Cos[x], Sin[x]},
 {x, 0, 2 Pi},
 Fills -> {{{1, Axis}, GrayLevel[.8]},
 {{2, 3}, GrayLevel[.3]}},
 Curves -> Front];

FilledListPlot[ {1,3,2,5,2},
  {{1.1, 2}, {2.5, 1}, {4.5, 3}, {5.2, 4.2}}
]

FilledPlot[{Cos[x], Sqrt[x^2 - 1]},
    {x, -1.5, 1.5},
    AspectRatio -> Automatic];

10.  Beschriftung von Graphiken (Labels)
        Doter des graphiques d'inscriptions (Labels)

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:

??Ticks

Plot3D[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:

??Text

Show[Graphics[{Circle[{0,0},1],
	Text["Circle",{0,0.05}]}],
	AspectRatio -> Automatic];

11.  Graphik-Pakete
        Paquets de graphiques

Zum Beispiel Rotationskörper:
  Par exemple corps de révolution:

Package laden:    Charger Package:

<< Graphics/Shapes.m

Beispiele:   Exemples:

Show[Graphics3D[Torus[]]];

Show[RotateShape[Graphics3D[Torus[]], 
		0, 5 Pi/6, 0]];

12. Animationen
       Animations

Auf dem Buchdeckel von Nancy Blachmans Buch:
  De la couverture du livre de Nancy Blachman:

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}]

Vorgehen zum Animieren:
 Procédé d'animation:

New: ===>Go to Cell,Animate Selectet Graphics (Ctrl+Y)
Old:  ===>
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.

Eine verkleinerte Darstellung:
 Une représentation rapetissée:

??GraphicsArray

??GraphicsSpacing

Show[GraphicsArray[cover], 
GraphicsSpacing -> 0.2];

13. PostScript
         PostScript

Erzeugen, ablegen, einlesen und betrachten von PostScript-Code
 Générer, déposer, lire et observer le code PostScript

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 (Achtung Front-End!):
  On peut relire le fichier (Attention Front-End!):

??Get

?? !!

?? <<

Get["c:\work\postsc_1.nb",exp1]

Get["c:\work\postsc_1.nb"]; exp1

Get["c:\work\postsc_1.nb"]; Show[exp1]

Get["c:\\work\\postsc_1.nb", exp1]

?exp1

Show[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"

Get["c:\work\postscri.ps"]

Get["c:\work\postscri.ps"] // FullForm

Get["c:\\work\\postscri.ps"]

Get["c:\\work\\postscri.ps"] // FullForm

Get["c:\\work\\postsc_1.nb"]

Get["c:\\work\\postsc_1.ps"]

Get["c:\\work\\postsc_1.ps"] // FullForm

Get["c:\work\postscri.ma"]

Get["c:\work\postscri.ma"] // FullForm

Get["c:\work\postscri.nb"]

exp1

14. Experimentieren mit Animationen
        Expérimenter les animations

14.1. Nachfolgend zwei Beispiele zu Animationen (Bsp. von U.Altmann)
         Ensuite deux exemples d'animations (exemple pris  de U.Altmann)

Achtung! Die Rechnungen dauern vielleicht etwas Zeit! Vorschlag: Erst am Schluss der Arbeit ausführen!

Attention! Il faut du temps aux calculs! Proposition: Executer à la fin du travail!

Package laden:
  Charger Package:

?ImplicitPlot

Remove[ImplicitPlot]

<<  Graphics`ImplicitPlot`

(* Old: *)
(* 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!

14.2. Noch ein Beispiel (Simulation einer Welle)
         Encore un exemple (simulation d'une onde)

Erst rechnen, dann animieren!
 D'abord calculer, 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?

15. Probiere eigene Beispiele aus!
       Essaie de propres exemples!

Beispiele a)   Exemples  a)

Remove[tabNew]

tabNew[x_] :=  Table[n Sin[x - n] + n, {n, 0, 20}]; 
    tabNew[x]

Plot[Evaluate[tabNew[x]], {x, -5, 5}];

Remove[r, vecNew]

r[s_] := 6  Cos[3 s  + 5] + 2 Cos[10  s  + 5];   r[s]

vecNew[s_] :=  r[s]*{Cos[s], Sin[s]}

ParametricPlot[vecNew[t], {t, 0, 20}]

vecNew[s_, u_] :=  r[s]*{Cos[s*u], Sin[s*u]};  
    vecNew[s, u]

paramP[u_] := 
      ParametricPlot[Evaluate[vecNew[t, u]], {t, 0, 20}]

paramP[2];

Table[paramP[u], {u, 1, 5}];

Table[paramP[u], {u, 5, 15}];

Beispiele b)   Exemples  b)

a

Plot[ArcSin[Sin[x]],{x,0,12}];

Plot3D[ArcSin[Sin[x+y]],{x,0,12},{y,0,12}];

b

Plot[ArcSin[Sin[x]^2],{x,0,12}];

Plot3D[ArcSin[Sin[x y]^2],{x,0,4},{y,0,4},PlotPoints->50];

c

Plot[ArcTan[Tan[x]],{x,0,12}];

Plot3D[ArcTan[Tan[x y]],{x,-2,2},{y,-2,2},PlotPoints->50];

d

Plot[Sqrt[Cos[x]],{x,0,12}];

Plot3D[Sqrt[Cos[x - y]],{x,0,12},{y,0,12},PlotPoints->50];

e

Plot[Sin[E^(x-x^2)],{x,-2,4}];

Plot3D[Sin[E^(x-y^2)],{x,-2,4},{y,-2,4},PlotPoints->50];

f

Plot[1/(1-Cos[x]^2),{x,-2,4}];

Plot3D[1/(1-Cos[x]Cos[y]),{x,-2,4},{y,-2,4},PlotPoints->50];

g

Plot3D[(1 - Sin[x]) (2 - Cos[3 y]), {x, -2, 2}, {y, -2, 2}];

Plot3D[(2 + Sin[x]) (1 + Cos[2 y]), {x, -2, 2}, {y, -2, 2}];

Show[%, %%];

c

a

grad[f_,x_,y_]:= {D[f,x],D[f,y]}

b

f[x_,y_]:=1-x^2-y^2;
grad[f[x,y],x,y]

c

f[x_,y_]:=E^(Cos[1-x^2-y^2]);
grad[f[x,y],x,y]

<<Graphics`PlotField`

p1=PlotVectorField[Evaluate[grad[f[x,y],x,y]],
             {x, 0, Pi}, {y, 0, Pi}];

p2=Plot3D[f[x,y],{x, 0, Pi}, {y, 0, Pi}];

p3=ContourPlot[f[x,y],{x, 0, Pi}, {y, 0, Pi},PlotPoints->45];

<<Graphics`PlotField3D`

p4=PlotVectorField3D[Evaluate[Append[grad[f[x,y],x,y],0](1-Sign[z]^2)], {x, -Pi/2,Pi/2}, {y, -Pi/2,Pi/2}, {z, -1,1}];

Show[p2,p4];

p2=Plot3D[f[x,y],{x, 0, Pi}, {y, 0, Pi},HiddenSurface->False];

Show[p2,p4];

p2=Plot3D[f[x,y],{x, 0, Pi}, {y, 0, Pi},
Shading->False];

Show[p2,p4];

d Richtungsableitung im letzten Beispiel

grad[f[x,y],x,y]/.{x->1,y->1}//N

RichtungsAbleitung = 1/Sqrt[2] {1,1} . %

r[t_]:=1/Sqrt[2] {1,1}.grad[f[x,y],x,y]/.{x->t,y->t}

Evaluate[r[1]]

%//N

Plot[Evaluate[r[t]],{t,-2,2}];

16. Export von Graphiken,weiterbearbeiten mir Graphik-Programmen  Exporter de graphiques,lestraiter avec des autres programmes graphiques

Beispiel  Exemple

Remove["Global`*"]

<< Graphics`FilledPlot`

FilledPlot[{x^2/18, Cos[x], Sin[x], Cos[x - 1], 5/(x + 1)}, {x, 
          0, 2 Pi}, 
        Fills -> {{{1, Axis}, GrayLevel[ .1]}, {{2, 3}, 
              GrayLevel[ .5]}, {{3, 4}, Hue[ .5]}, {{4, 5}, Hue[-2]}}, 
        Curves -> Front];

1. Klicke in die Graphik (Output).   Cliquer dans la graphique.
2. Klicke in der Kommando-Leiste oben auf "Edit".   Cliquer dans la ligne de commandement en haut sur "Edit".
3. Klicke dort auf "Save Selection as"   Y cliquer sur "Save Selection as".
4. Klicke z.B. auf "Bitmap (BMP)" oder "EPS" (encapsulated Postscript) u.s.w..   Puis cliquer p.es. sur  "Bitmap (BMP)" ou "EPS" (encapsulated Postscript) etc..
5. Jetzt erscheint ein Fenster, in dem Du den Dir genehmen File-Name sowie das Verzeichnis eingeben kannst, in dem die Graphik gespeichert werden soll.    Maintenant une fenêtre va s'ouvrir. Là il faut écrire le nom du fîchier qu'on aime et le directoire où il faut mémoriser la graphique.
6. Jetzt kannst Du die gespeicherte Graphik mit einem andern Graphik-Programm öffnen und bearbeiten.    Maintenant on peut ouvrir la graphique à l'aide d'un autre programme pout la traiter.
7. Beispiel siehe:    Exemple voire: 
http://www.hta-bi.bfh.ch/~wir/MathemDF/DATEN/OutputBsp.bmp   <====

17.  Ringgraphiken  Graphiques en forme d'anneaux

(Konzept von  Concept de  Rolf Wirz)

Remove["Global`*"]

f[x_ /; x < 1/3] := x;
f[x_ /; x ≥ 1/3  &&  x <  2/3] := 
        1/3;
f[x_ /;  x >=  2/3] := -x + 1;
Plot[f[x], {x, 0, 1}];

g[x_] := f[x - Floor[x]];
Plot[3 g[x], {x, -3, 5}, 
        AspectRatio -> Automatic];

g[x_] := f[x - Floor[x]];
Plot[3 g[x 2/Pi], {x, 0, 2  Pi}, 
        AspectRatio -> Automatic];

r[x_] := 
        10 {Cos[x], Sin[x]} g[x 2  Pi 20]/4;
p3 = 
        ParametricPlot[r[x ], {x, 0, 2  Pi}, 
          AspectRatio -> Automatic,  Axes -> False];

r[
          x_] := {Cos[x], 
            Sin[x]} (1 +  g[x/Pi 20]/4);
ParametricPlot[r[x ], {x, 0, 2  Pi}, AspectRatio -> Automatic, 
        PlotPoints -> 100,  Axes -> False];

r[
          x_] := {Cos[x], 
            Sin[x]} (1 +  2 g[x/Pi 6]/4);
ParametricPlot[r[x ], {x, 0, 2  Pi}, AspectRatio -> Automatic, 
        PlotPoints -> 100,  Axes -> False];

r[
          x_] := {Cos[x], 
            Sin[x]} (1 +  
              g[x 2  Pi 6]/4);
ParametricPlot[r[x ], {x, 0, 2  Pi}, AspectRatio -> Automatic, 
        PlotPoints -> 100,  Axes -> False];

h[x_ /; x < 1/3] := 0;
h[x_ /; x ≥ 1/3  &&  x < 1/2] := 
        30 (x - 1/3)^2;
h[x_ /; x ≥ 1/2  &&  x <  2/3] := 
        30 (x - 2/3)^2;
h[x_ /;  x >=  2/3] := 0;
f1[x_] := f[x] + h[x];
g1[x_] := f1[x - Floor[x]]
Plot[g1[x], {x, 0, 1}];

r2[
          x_] := {Cos[x], 
            Sin[x]} (1 +  
              g1[x 2  Pi 6]/4);
p1 = 
        ParametricPlot[r2[x ], {x, 0, 2  Pi}, AspectRatio -> Automatic, 
          PlotPoints -> 100,  Axes -> False];

r2[
          x_] := {Cos[x], 
            Sin[x]} (1 +  
              2 g1[x/Pi 6]/4);
p2 = 
        ParametricPlot[r2[x ], {x, 0, 2  Pi}, AspectRatio -> Automatic, 
          PlotPoints -> 100,  Axes -> False];

Show[p1, p2, p3];

Remove[p, k, ta, s, res];
p[k_] := {Cos[k 2  Pi /24], Sin[k 2  Pi /24]}; 
    ta1[s_] := Union[{Hue[(s - 3)/8]}, 
        Table[Line[{p[k], p[k + s]}], {k, 1, 
            24}]];
res1 = N[Flatten[Table[ta1[s], {s, 3, 11}]]]; 
    q1 = Show[Graphics[res1], 
        AspectRatio -> Automatic];
ta2[s_] := 
        Union[{Hue[1 - (s - 3)/8]}, 
          Table[Line[{p[k], p[k + s]}], {k, 1, 
              24}]];
res2 = 
        N[Flatten[Table[ta2[s], {s, 3, 11}]]];
q2 = 
        Show[Graphics[res2], 
          AspectRatio -> Automatic];
ta3[s_] := 
        Union[Table[
            Line[{p[k], p[k + s]}], {k, 1, 
              24}]];
res3 = 
        N[Flatten[Table[ta3[s], {s, 3, 11}]]];
q3 = 
        Show[Graphics[res3], 
          AspectRatio -> Automatic];
Show[GraphicsArray[{q1, q3, q2}] ];

18. Generierung von Namen

Remove[f];

f[x_, y_] := 1/E^x^2 Cos[x/5] (1 - y^2/5)

Plot[f[x, 0], {x, -5, 5}, PlotRange -> {0, 1}];

Remove[f];
f[x_, y_] := 
        1/E^x^2 Cos[
            x/5] (2 - (y - 3)^2 /2);
g[x_, y_] := 1 - 1/E^(x^2) Cos[x/5]; 
    nPlot = Plot3D[-f[x, 0] (1 + Cos[x + y]) (Cos[y] + 
                f[y/2, 0]) +  
          4  g[(x - 0.3), 0] + (x/4)^2, {x, -5, 5}, {y, -5, 
          5}, PlotRange -> {6, -6}, Axes -> False,  
        Boxed -> False, PlotPoints -> 50];

19. Möbius

Anwendung bei Riementrieben

x[r_, α_] := 
        Cos[α] (1 + 
              r/2 Cos[α/2]);
y[r_, α_] := 
        Sin[α] (1 + 
              r/2 Cos[α/2]);
z[r_, α_] := 
        r/2 Sin[α/2];
ParametricPlot3D[{x[r, α], y[r, α], 
          z[r, α]}, {α, 0, 2 Pi}, {r, -1, 
          1}];

ParametricPlot3D[{x[r, α], y[r, α], 
          z[r, α]}, {α, 0, 2 Pi}, {r, -0.5, 
          0.5}];

ParametricPlot3D[{x[r, α], y[r, α], 
          z[r, α]}, {α, 0, 2 Pi}, {r, 0, 1}];

20 Flächenbeispiele, Tangentialebene

Remove["Global`*"]

1

v[u_, w_] := {Cos[u] Cos[w], Cos[u] Sin[w], 
          Sin[u]};
v[u, w]

kugel = 
        ParametricPlot3D[v[u, w], {u, 0, 2  Pi}, {w, 0, Pi}];

u0 = Pi/8;  w0 = Pi/3;
vu[u_, w_] := D[v[u, w], u];
vu[u, w]

vw[u_, w_] := D[v[u, w], w];
vw[u, w]

vu0[u0, w0] = vu[u, w] /. {u -> u0, w -> w0}

vw0[u0, w0] = vw[u, w] /. {u -> u0, w -> w0}

Φ[λ_, μ_] := 
        v[u0, w0] + λ vu0[u0, w0] + μ vw0[u0, 
              w0];
ebene = 
        ParametricPlot3D[Φ[λ, μ], {λ, -1/
              2, 1/2}, {μ, -1/2, 1/2}];

Show[kugel, ebene];

Show[kugel, ebene, 
        ViewPoint -> {1.202,  -0.852,  0.438}];

Show[kugel, ebene, 
        ViewPoint -> {1.351,  0.560,  0.349}];

2

v[u_, w_] := {Cos[u] Cos[w], Cos[u] Sin[w], 
          Sin[w]};
v[u, w]

ParametricPlot3D[v[u, w], {u, 0, 2  Pi}, {w, 0, Pi}]

3

v[u_, w_] := {2 Cos[u] Cos[w], 3 Cos[u] Sin[w], 
          Sin[u]};
v[u, w]
{Cos[u] Cos[w], Cos[u] Sin[w], Sin[u]}
ParametricPlot3D[v[u, w], {u, 0, 2  Pi}, {w, 0, Pi}]

4

v[u_, w_] := {2 Cos[u] Cos[w], 3 Cos[u] Sin[w^2], 
          Sin[u]};
v[u, w];
{Cos[u] Cos[w], Cos[u] Sin[w], Sin[u]};
ParametricPlot3D[v[u, w], {u, 0, 2  Pi}, {w, 0, Pi}];

5

v[u_, w_] := {u, w, u^2 + w^2};
ParametricPlot3D[
        v[u, w], {u, -2, 2}, {w, -2, 2}];

v[r_, φ_] := {r Cos[φ], r Sin[φ], 
          r^2};
ParametricPlot3D[
        v[r, φ], {r, 0, 2}, {φ, 0, 2  Pi}];

6

v[u_, w_] := {u^2 - w, u + w^2, 1/(u + w + 5)};
ParametricPlot3D[
        v[u, w], {u, -2, 2}, {w, -2, 2}];