Definiere Methode/Algorithmus < Mathematica < Mathe-Software < Mathe < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 01:07 Mi 26.10.2011 | | Autor: | ThomasTT |
He,
und zwar würde ich gerne etwas machen wie folgt: Ich rufe eine Funktion g auf mit einem Parameter a auf, etwa g[a], wobei ich a vorher mit z.B. a=3; festgelegt habe. g[3] soll dann folgende Zeilen ausführen:
For[i = 0, i < 4, i++, a=a*2;]
a=a+4;
Und letzlich gibt g[3] dann 52 zurück. Wie kann ich sowas in Mathematica definieren?
In einer normalen Programmiersprache würde das ja in etwa so aussehen:
Function g (a as integer) as integer{
For(i = 0, i < 4, i++){
a = a * 2;
}
a = a + 4;
return a;
}
Gruß
Thomas
|
|
| |
|
Warum denn nicht gleich
[mm] $a=a\cdot 2^4+4$?
[/mm]
Und das dann analog zu
http://reference.wolfram.com/mathematica/ref/Function.html
|
|
|
| |
|
Ok. Dann nehmen wir an die For Schleife wäre komplizierter und es würden noch Variablen nebenher mit Solve[...] o. Ä. berechnet werden. Das kann man dann nicht mehr als simple Gleichung aufschreiben. Wie kann ich das nun umgehen?
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 14:20 Fr 28.10.2011 | | Autor: | matux |
$MATUXTEXT(ueberfaellige_frage)
|
|
|
| |
|
> Ich rufe
> eine Funktion g auf mit einem Parameter a auf, etwa g[a],
> wobei ich a vorher mit z.B. a=3; festgelegt habe. g[3] soll
> dann folgende Zeilen ausführen:
>
> For[i = 0, i < 4, i++, a=a*2;]
> a=a+4;
>
> Und letzlich gibt g[3] dann 52 zurück. Wie kann ich sowas
> in Mathematica definieren?
Hallo Thomas,
Programme in "gewöhnlicher" (prozeduraler) Manier in
Mathematica zu "übersetzen" entspricht zwar nicht ganz
dem Grundkonzept von Mathematica, ist aber immerhin
auch möglich.
Ich würde es etwa so machen:
g[a_] := Block[{b = a},
Do[b = b*2, {i, 1, 4}];
b = b + 4;
Return[b]]
Die Funktionsvariable selbst (also a) im Block, der die
Funktion selbst definieren soll, als interne Variable zu
verwenden, ist wirklich nicht schön - deshalb nehme
ich zu diesem Zweck eine wirklich für den Block lokale
Variable b.
Ferner scheint mir der Do-Befehl in Mathematica
handlicher als das hässliche, von C++ "inspirierte"
For.
LG Al-Chw.
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 15:18 Mi 26.10.2011 | | Autor: | ThomasTT |
Genau das hatte ich gesucht. Danke!
|
|
|
| |
|
> Genau das hatte ich gesucht. Danke!
Das höre ich gerne. Ich kämpfe auch noch manchmal
mit der genauen Syntax von Mathematica, bin aber
auch immer wieder überrascht davon, wie einfach
gewisse Prozesse sich darin zum Schluss darstellen
lassen. Übrigens kann man die angegebene Funktions-
definition
g[a_] := Block [{b = a},
Do[b = b*2, {i, 1, 4}];
b = b + 4;
Return[b]]
noch verkürzen zu:
g[a_] := Block [{b = a},
Do[b = b*2, {4}];
b = b + 4;
Return[b]]
LG Al-Chw.
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 17:03 Mi 26.10.2011 | | Autor: | Peter_Pein |
einen hab ich noch ![[aufgemerkt]](/images/smileys/aufgemerkt.gif "[aufgemerkt]")
f[a_] := Nest[2 # &, a, 4] + 4;
und statt "2#&" kann natürlich auch besagte Folge von Anweisungen in einer funktion
Function[a, "Solve" dieses, "ReplaceAll" jenes...] stehen.
Gruß,
Peter
|
|
|
| |
|
> einen hab ich noch
> f[a_] := Nest[2 # &, a, 4] + 4;
> und statt "2#&" kann natürlich auch besagte Folge von
> Anweisungen in einer funktion
> | 1: | Function[a, "Solve" dieses, "ReplaceAll"
| | 2: | > jenes...] |
stehen.
> Gruß,
> Peter
Schön !
Aber das ist dann schon wieder so hochprozentiges
Mathematica, das wenigstens mir nicht mehr gut tut ...
LG Al-Chw.
|
|
|
| |
|
> einen hab ich noch
> f[a_] := Nest[2 # &, a, 4] + 4;
>
> und statt "2#&" kann natürlich auch besagte Folge von
> Anweisungen in einer funktion
> | 1: | Function[a, "Solve" dieses, "ReplaceAll"
| | 2: | > jenes...] |
stehen.
>
> Gruß,
> Peter
Hallo Peter,
darf ich dich (als "Experte" in Mathematica) noch fragen,
wie man die Rolle der Symbole "#" und "&" in der Zeile
f[a_] := Nest[2 # &, a, 4] + 4;
sinngemäß verstehen kann ?
LG Al-Chw.
|
|
|
| |
|
aber gerne.
Niemand, der/die bei Sinnen ist, würde eine Multiplikation mit 2 in eine Funktion packen, es sei denn, die Umstände erfordern es. Der Umstand besteht in der Verwendung von NestList, das eine Funktion als ersten Parameter erwartet.
Das ![[]](/images/popup.gif) "&" macht aus einem Ausdruck, wie z.B.: x^2-1 eine Funktion. x^2-1& macht jedoch nur eingeschränkt Sinn, da dies eine konstante Funktion ist, die unabhängig vom Argument [mm]x^2 - 1[/mm] ergibt.
Um Parameter in den Funktionsrumpf "einwerfen" zu können, gibt es den sog. "Slot (#)", der als Platzhalter für eine Variable verwendet wird. Bei mehreren Funktionsargumenten kann #1, #2, etc. verwendet werden.
Die beiden Hauptgründe warum diese Schreibweise statt des übersichtlichen Function[x, 2x] gerne verwendet wird, sind
1.) weniger Tipperei
2.) es sieht so schön esoterisch aus.
Meist wird diese Form verwendet, wenn man die Funktion nur einmal braucht, da sie im Gegensatz zu mul2[x_]=2 x; spätestens bei der nächsten Garbage Collection im Datennirwana landet.
Beispiel:
Hat man eine Liste lst = {{0, 1}, {1, 1/2}, {3, 1/4}} und hegt den Verdacht, dass der jeweils zweite Wert [mm]\frac{1}{1+\text{erster Wert}}[/mm] sein mag, lässt sich das per 1 / (1 + #1) == #2 & @@@ lst recht schnell verifizieren (zu "@@@" siehe bitte Apply !).
Falls es mit der englischen Doku Schwierigkeiten gibt, so findet sich per Suchmaschine früher oder später auch ein brauchbares deutschsprachiges Dokument. In diesem Fall etwa hier von der FU Berlin (~ ab Seite 10).
Gruß,
Peter
|
|
|
| |
|
Vielen Dank, Peter !
meine Schritte in Mathematica sind immer noch eher
tapsig - und in diesem Stadium können einem kleine
Hilfen oft sehr viel nützen !
LG Al
|
|
|
|
