Programmierung (Verfahren)

Copyright

Copyright 1994,  Claudia Funke und Markus Herold
TU-Berlin, FB 13, Fachgebiet Ökonometrie und Statistik
Dieses Notebook darf ausschließlich als Unterrichtsmaterial und für private Zwecke verwendet und nicht ohne Zustimmung der Autoren verändert werden.

Prozedurale Programmierung

Verändern von Variablenwerten

Die Veränderung der Variablenwerte kann elegant durch verkürzte Operatoren erfolgen:

++i  ->  erst i um 1 erhöhen, dann Wert zurückgeben
i++  ->  Wert zurückgeben, dann i um 1 erhöhen
--i  ->  analog
i--  ->  analog

Schleifenkonstrukte

Do[ Ausdruck, {n} ]

Der Ausdruck  wird  n-mal ausgeführt.

Do[Print[i^2], {i, 3}]

For[ Start, Abfrage, Schrittweite, Funktionskörper ]

For[i=1, i <= 3, ++i, Print[i^2]]

While[ Abfrage, Funktionskörper ]

i = 1;

While[i <= 3, {Print[i^2]; i++}]

Logische Abfragen

!	  ->  NOT
&&	  ->  AND
||	  ->  OR
Xor[...]  ->  Exklusives OR

(3 > 2) || (1/0 > 5)

(1/0 > 5) || (3 > 2)

Konstrukte für die konditionale Abarbeitung von Programmcode

If[ Abfrage, Wahr-Funktionskörper, Falsch-Funktionskörper, 
     KeinesvonBeiden-Funktionskörper  
   ]

If[$VersionNumber > 2.0,
   Plot[Exp[-x^2] Cos[20 x], {x, -2, 2}, Frame -> True],
   Plot[Exp[-x^2] Cos[20 x], {x, -2, 2}, Framed -> True]
  ]

?Framed

Which[ Abfrage1, Wert1, Abfrage2, Wert2, ... ]

sign[x_] := Which[ x <  0., -1,
                   x == 0., 0, 
                   x >  0., 1
            ]

sign[3]

sign[-3]

PureFunction

Wenn man mit Mathematica-Befehlen arbeitet, die als Argumente auch 
Funktionen besitzen (wie z.B. der Map[ ]-Befehl ), mußte man bisher 
die Funktion zuvor definieren und griff mit ihrem Namen auf sie zu. 
Dies kann, insbesondere bei einfachen Funktionen, recht umständlich 
sein. Mathematica bietet daher die Möglichkeit, die Funktion erst dort 
zu definieren (z.B. im Argument des Map-Befehls), wo sie auch benutzt 
wird. Dies geschieht über  pure functions.

Eine   pure function   ist in Mathematica eine Funktion, der kein Name 
zugeordnet ist. Diese wird wie folgt definiert:

Function[ Var, Funktionskörper ]

Das erste Argument definiert die formalen Parameter, das zweite 
Argument den Funktionskörper.

Function[x, x^2]

Natürlich braucht die Funktion noch ein Argument, das ausgewertet werden soll. Dies wird in eckigen Klammern hinter die Funktionsdefinition geschrieben und gleich ausgewertet.

Function[x, x^2] [5]

Function[x, x^2] [{1, 2, 3}]

Im folgenden soll zum Vergleich eine Funktion über einen Namen und 
durch eine pure function definiert werden.

greater50[x_] := x > 50

data = {23, 34, 86, 43, 90}

Select[data, greater50]

Die Funktion  greater50  wird nun durch eine pure function ersetzt.

Function[x, x > 50] [60]

Select[data, Function[x, x > 50]]

In pure functions können formale Parameter durch    #n    ersetzt 
werden. #n   steht für das n-te Argument, welches ersetzt werden soll.   
#  alleine steht für das erste Argument.

Select[data, Function[# > 50]]

Durch die Verwendung von   &   als Alias für eine    Function[ ]   kann 
eine pure function noch kompakter geschrieben werden.

Select[data, (# > 50)&]

Als ein weiteres Beispiel für die Anwendung von pure functions soll ein 
gleitender Mittelwert berechnet werden.

(* Gewichte *)
meinFilter = {.1, .8, .1}; 
(* Datensatz *)
meineDaten = 
{3.1, 3.3, 4.2, 3.7, 1.7, 3.5, 3.3, 6.7};    
Partition[meineDaten, Length[meinFilter], 1]

MatrixForm[%]

Map[meinFilter . #&,
    Partition[meineDaten, Length[meinFilter], 1]
   ]

Für den gleitenden Mittelwert kann nun eine Funktion geschrieben 
werden, die nur noch den Filter und den Datensatz als Argumente hat.

gleitMittelwert[filter_List, data_List] :=
   Map[filter . #&,
       Partition[data, Length[filter], 1]
   ]

gleitMittelwert[meinFilter, meineDaten]