Re: (2')Basisfragen zu Korrespondenzen der Fourier-Transformation

[Udo und Susanne Krause <su.krause@XXXXXXX.ch>]

Guten Abend Gunter,

Das ist eine Frage eher zur funktionalen Programmierung als zur 
Fouriertransformation.

> Nach einer Fourier-Transformation ( oder nach einer inversen
> Fouriertransformation ) moechte ich das berechnete Ergebnis _in der
> Ergebnisebene_ durch eine MMa-Funktion weiter verarbeiten :
>
>  - Operation Verschiebung auf der Zeitachse
>  - Operation Verschiebung auf der Frequenzachse
>  - Operation Verschiebung auf der Zeit- _und_ auf der Frequenzachse 
>
>  - Operation ...  .
>
> Das soll geschehen, _ohne_ dass man die vorhergehende Fouriertransformation
> ( oder die inverse Fouriertransformation ) wiederholen muss.
>
> Es sollte also etwa eine folgende MMa-Funktion geben :
>
>    FourierOperatorFunction[ InputFunction, Domain, TransferRule ] ,
>
> mit folgenden Vereinbarungen :
>
>    InputFunction :  Ein Ergebnis einer Fouriertransformation 
>
>                     oder einer inversen Fouriertransformation
>
>    Domain        :  Angabe, ob die InputFunction im Frequenzbereich oder
> im Zeitbereich gilt,
>
>                     sofern das sachlich noetig ist
>
>    TransferRule  :  Die Angabe der anzuwendenen Transformation,
>
>                     z.B.  t  ->  t - t_0
>
>                           f  ->  f + f_0
>
>                           ....
>  
Wenn das das Design ist, kann man das folgende Skelett eines Moduls 
verwenden:

In[11]:= Clear[woyschFOP];
woyschFOP[f_, s_String, par_List:{}] :=
Module[{},
Which[s == "fiction0",
 If[Length[par] != 0,
     Print["Error: ", s, " does not take parameters!"];
   Return[$Failed],
     f[t]
 ],
     s == "fiction1",
 If[Length[par] != 1,
   Print["Error: ", s, " takes exactly one parameter!"];
   Return[$Failed],
   t0 = par[[1]];
   f[t + t0]
 ],
   s == "fiction2",
 If[Length[par] != 2,
   Print["Error ", s, " takes exactly two parameters!"];
   Return[$Failed],
   t0 = par[[1]];
   t1 = par[[2]];
   f[t] + t0 f[t + t1]
 ],
   True,
   Print["Error: No operation defined for ", s];
   Return[$Failed]
]
]                   

In[14]:= woyschFOP[weihnachtsmann, "fiction2", {a, b}]
Out[14]= weihnachtsmann[t]+a weihnachtsmann[b+t]

In[15]:= woyschFOP[weihnachtsmann, "osterhase", {a, b, c, d, e, f, g}]
From In[15]:=
Error: No operation defined for osterhase
Out[15]= $Failed

Nun definiert man die Funktion weihnachtsmann durch das, was er 
allenfalls bringen mag:

In[16]:= weihnachtsmann[x_] := PowerPoint[x] + KraftPunkt[-x]

und sieht sich den output nocheinmal an:

In[17]:= woyschFOP[weihnachtsmann, "fiction2", {a, b}]
Out[17]= KraftPunkt[-t]+PowerPoint[t]+a (KraftPunkt[-b-t]+PowerPoint[b+t])

oder etwas vernuenftiger an der Stelle:

In[35]:= g[o_] := Evaluate[FourierTransform[UnitStep[t], t, o]]
In[36]:= woyschFOP[g, "fiction1", {g0}]
Out[36]= I/(Sqrt[2*Pi]*(g0 + t)) + Sqrt[Pi/2]*DiracDelta[g0 + t]

Die Probleme liegen nicht darin, mit Mma Module zu schreiben, die 
Funktionen als Argumente annehmen,
sondern darin, den Input dieser Module zu checken. Es sollte also z.B. 
woyschFOP nur Symbole f annehmen, die Funktionen eines reellen Arguments 
sind (im folgenden Fall sollte man eine Fehlermeldung bekommen statt 
einer neuen Funktion nikolaus)

In[18]:= nikolaus[x_, y_] := Sin[x y]
In[23]:= woyschFOP[nikolaus, "fiction0"]
Out[23]= nikolaus[t]

die Parameter sollten nicht mit dem intern verwendeten Argument (t) 
uebereinstimmen, die Parameter unterliegen allenfalls selbst Regeln oder 
sind gar selber Funktionen mit Parametern; in dem Fall muss man viel 
mehr tun - insbesondere, wenn der Modul in der Lehre Verwendung finden 
soll - aber das Grundprinzip ist recht einfach: Sie tragen die Formeln 
aus Ihrer Liste unter dem richtigen Namen in das Skelett ein und geben 
die noetigen Parameter mit.

Gruss
Udo.