Kurs  Cours

7. Probleme zum Thema "Zuordnungen und Regeln"
 Problèmes au sujet des "applications et règles"

Die Gliederung dieses Kurses folgt in groben Zügen dem Buch von Nancy Blachman: A Practical Approach.... 
Hinweis: Kapitel 7 lesen!
Run mit WIN+Mathematica Version 5.2

 L'articulation de ce cours correspond à peu près à celle du livre de Nancy Blachman: A Practical Approach.... 
Indication: Lire le chapitre 7.
Testé avec Mathematica version 5.2+WIN

WIR94/98/99/2000/2007 // Copyright Rolf Wirz

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.

7.1. Zuordnungen
     Applications

7.1.1. Allgemeines
       Généralités

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 = 5

a + 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 + y

1/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

7.1.2. Unmittelbare und verzögerte Zuordnungen
       Applications immédiates et retardées

"=" oder "Set" bewirkt eine sofortige Zuordnung. Probiere aus:
  "=" ou "Set" produisent une application immédiate. Essaie:

?Set

?=

Set[a, 33444]

a

random1 = 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:

?:=

?SetDelayed

random2 := 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

7.1.3. Mehrfache Zuordnungen
       Applications multiples

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}

7.1.4. Einschub für 7.4.1. 
         (dort nicht anwendbar, wegen zu grossem Output)
        Insertion pour 7.4.1. 
          (ne peut pas être appliqué à cause du trop grand output)

??Out

7.1.5. Rekursive Zuordnungen
       Application récursive

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

?fac

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

7.2. Löschen der Wertzuweisung
     Effacer l'assignation des valeurs

7.2.1. Missing value einsetzen:
       Appliquer missing value

Beispiel:    Exemple:

Remove[x] ; x = 1 ; Print["1)   ", x] ; 
x = . ; Print["2)   ",x]

??x

x = 1 ; Print["1)   ", x]

??x

x = . ; Print["2)   ",x]

??x

7.2.2. Funktion löschen:
       Effacer la fonction

?fak

fak[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

?kubus

Clear[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))

7.2.3. Probleme mit Packages:
       Problèmes de Packages:

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],PointSize[0.3], 
		Point[{0,0}]}]];

Needs["Graphics`Colors`"]

?CMYColor

Remove[CMYColor]

?CMYColor

Show[
        Graphics[{CMYColor[0.6, 0.5, 0.4], PointSize[0.3], 
            Point[{0, 0}]}]];

7.2.4. Löschen aller eigenen Variablen und Funktionen:
        Effacer toutes les propres variables et fonctions:

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".

?fak

Remove["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["@*"] old, Remove["Global`*"] new   *)

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...".

7.3. Regeln
     Règles

7.3.1. Allgemeines
       Généralités

?/.

?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 + 7y

x + 7y /. x->4

x + 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.

7.3.2. Verzögerte Ausführung der Regel
        Exécution retardée de la règle

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.

x

Table[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.

7.3.3. Wiederholte Ersetzung
        Remplacement répété:

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]

7.3.4. Ersetzung bei graphischen Optionen
       Remplacement lors d'options graphiques

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]

7.3.5. Eine Anwendung: Labels bei Plots
       Une application: "Labels" des "Plots"

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

?SetOptions

SetOptions[Plot,PlotLabel :> StringJoin[
			"In[", ToString[$Line], "] :> ",
			InString[$Line]
			]];
Plot[Sin[x],{x, 0, 2 Pi}];

Plot[Cos[x],{x, 0, 2 Pi}];

7.3.6. Vereinfachung von trigonometrischen Ausdrücken
       Simplification d'expressions trigonométriques

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

?Trig*

(* ??TrigReduceRel Old *)

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).

7.3.7. Wertelisten, Extraktion von Werten aus 
         Zuweisungsregeln
       Listes de valeurs, extraction de valeurs de règles   
         d'assignation

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

x1

7.3.8. Weiterrechnen mit Werten aus Output in Form von
         Ersetzungsregeln
        Continuer de calculer avec des valeurs de l'output en
          forme de règles de remplacement

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

Simplify[%]

Oder:    Ou:

x /. wurzeln[[1]]

Die erste Regel wurde extrahiert! Oder:
  Cette règle a été extraite! Ou:

2x + 13 /. wurzeln[[1]]

7.4. Gleichheit
     Egalité

7.4.1. Allgemeines
       Généralités

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:

?Out

Out = 1

Attributes[Out]

Achtung: Das gibt viel Output...... Vgl. 7.1.4.
  Attention: Cela fait beaucoup d'output....  Compare 7.1.4.

(*  ??Out   *)

?Unprotect

Unprotect[Out]

Out = 2

Clear[Out]; Protect[Out]

Wieviel Output ist es noch?
  Combien d'output cela fait-il encore?

Out = 3

7.4.2. Konvertierung von Gleichheiten in Zuweisungsregeln
       Convertir des églaités en règles d'assignation

Studiere:    Etudie:

?ToRules

NRoots[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[%]

7.4.2. Weitere Probleme mit "Gleichheit"
        Autres problèmes avec "églaité"

Probiere aus:    Essaie:

?=

?==

?===

?!=

?=!=

?Set

?Equal

?SameQ

?Unequal

?UnsameQ

Studiere:    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 != 2

Das 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 =!= y

x === y

"Putzmaschine" einsetzen
 Employer la "machine de nettoyage"

(* Old Form: Remove["Global`@*"] *)

Remove["Global`*"]