Kurs  Cours

11. Problemsammlung zur Musterentsprechung
(Mustererkennen, musterkonformes Abarbeiten)
 Collection de problèmes concernant les correspondances et patrons (reconnaître les patrons, travailler conformement aux patrons)

Die Gliederung dieses Kurses folgt in groben Zügen dem Buch von Nancy Blachman: A Practical Approach.... 
Hinweis: Kapitel 11 lesen!
 L'articulation de ce cours correspond à peu près à celle du livre de Nancy Blachman: A Practical Approach.... Indication: 
Lire le chapitre 11.
WIR94/98/99 // Copyright Rolf Wirz

11.1. Mustererkennung bei einer Sequenz
       Reconnaître un patron lors d'une séquence

Ein Beispiel
 Un exemple

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!

11.2. Nachbau von Funktionen 
       Copier (imiter) des fonctions

11.2.1. "First" (herauspicken des 1. Elements einer Liste)
         "First" (choisir le 1er élément d'une liste)

"Von Hand":
 "A la main":

Probiere:    Essaie:

{a, b, c, d, e, f, g} /. {x_, y___} :> x  
(* 3 Unterstriche! *)

Definition einer Funktion:
  Définition d'une fonction:

nimmErstes[{x_, y___}] := x

Ausprobieren:    Essayer:

nimmErstes[{a, b, c, d, e, f, g}]

11.2.2. "Last" (herauspicken des letzten Elements einer 
                        Liste)
         "Last" (choisir le dernier élément d'une liste)

"Von Hand":
 "A la main":

Probiere:    Essaie:

{a, b, c, d, e, f, g} /. {x___, y_} :> y

Definition einer Funktion:
  Définition d'une fonction:

nimmLetztes[{x___, y_}] := y

Ausprobieren:    Essayer:

nimmLetztes[{a, b, c, d, e, f, g}]

11.2.3. "Head"
         "Head"

"Von Hand":
 "A la main":

Probiere:    Essaie:

{a, b, c, d, e, f, g} /. h_[x___] :> h  
(* 3 Unterstriche! *)

Definition einer Funktion:
  Définition d'une fonction:

nimmKopf[h_[x___]] := h

Ausprobieren:    Essayer:

nimmKopf[{a, b, c, d, e, f, g}]

11.2.4. Neuordnung von Elementen
         Mettre des éléments dans un nouvel ordre

Zum Beispiel Vertauschung der Reihenfolge
 Par exemple renverser l'ordre

Probiere:    Essaie:

{{1,3},{2,4},{3,5},{4,6}} /. {x_, y_} :> {y, x}

11.3. "Polymorphe" Definitionen
         Définitions "polymorphes"

Hier geht es um datenabhängige Definitionen!
 Il s'agit ici de définitions dépendantes de données!

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

11.4. Benennung von Ausdrücken
        Nommer des expressions

Das Muster "x:Muster"
 Le patron "x:Patron"

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!

11.5. Ausdrücke auffinden, die mit Mustern 
          übereinstimmen
        Chercher des expressions qui 
          correspondent à des patrons

11.5.1. Beispiele mit "Cases"
         Exemples avec "Cases"

Probiere aus:    Essaie:

??Cases

Studieren:    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]

11.5.2. Beispiel mit "Select"
         Exemple avec "Select"

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]

11.5.3. Zusammengesetzte Muster
         Patrons composés

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

11.6. Das Attribut "Orderless"
       L'attribut "Orderless"

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!

11.7. Beispiele mit Mustererkennung
       Exemples avec reconnaissance de patron

11.7.1. Selektives Ausmultiplizieren
         Multiplications sélectives

Beispiel
  Exemple

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]

11.7.2. Manipulation von Klammern
         Manipulation de parenthèses

Beispiele
 Exemples

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__} :> x

Remove[f];
Map[f,{{a, b, c, d},{e, f, g}}]

Map[f,{{a, b, c, d},{e, f, g}}] /. 
				f[{x__}] :> f[x]

11.7.3. Eine eigene Definition von "Map"
         Une propre définition de "Map"

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

11.7.4. Ziffern zählen
        Compter des Chiffres

Beispiel
 Exemple

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]

11.7.5. Uebergabe von Optionen (Options)
         Transmission d'options

Beispiel
 Exemple

Studiere:    Etudie

Needs["Graphics`Graphics`"]

??Graphics

Beachte:    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!

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

Remove["Global`@*"]