@c -----------------------------------------------------------------------------
@c File        : Numerical.de.texi
@c License     : GNU General Public License (GPL)
@c Language    : German
@c Original    : Numerical.texi revision 14.03.2011
@c Translation : Dr. Dieter Kaiser
@c Date        : 13.11.2010
@c Revision    : 28.05.2011
@c 
@c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
@c -----------------------------------------------------------------------------

@menu
* Einf@"uhrung in die schnelle Fourier-Transformation::
* Funktionen und Variablen f@"ur die schnelle Fourier-Transformation::
* Einf@"uhrung in Fourierreihen::
* Funktionen und Variablen f@"ur Fourierreihen::
@end menu

@c -----------------------------------------------------------------------------
@node Einf@"uhrung in die schnelle Fourier-Transformation, Funktionen und Variablen f@"ur die schnelle Fourier-Transformation, Fourier-Transformationen, Fourier-Transformationen
@section Einf@"uhrung in die schnelle Fourier-Transformation
@c -----------------------------------------------------------------------------

@c The @code{fft} package comprises functions for the numerical (not symbolic)
@c computation of the fast Fourier transform.

Das Paket @code{fft} enth@"alt Funktionen f@"ur die numerische Berechnung der
schnellen Fourier Transformation (FFT - "Fast Fourier Transform").

@c -----------------------------------------------------------------------------
@node Funktionen und Variablen f@"ur die schnelle Fourier-Transformation, Einf@"uhrung in Fourierreihen, Einf@"uhrung in die schnelle Fourier-Transformation, Fourier-Transformationen
@section Funktionen und Variablen f@"ur die schnelle Fourier-Transformation
@c -----------------------------------------------------------------------------

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{polartorect}
@deffn {Funktion} polartorect (@var{r}, @var{t})

@c Translates complex values of the form @code{r %e^(%i t)} to the form
@c @code{a + b %i}, where @var{r} is the magnitude and @var{t} is the phase.
@c @var{r} and @var{t} are 1-dimensional arrays of the same size.
@c The array size need not be a power of 2.

Transformiert komplexe Zahlen der Form @code{r %e^(%i t)} in die Standardform
@code{a + b %i}.  @var{r} ist der Betrag der komplexen Zahl und @var{t} die
Phase.  Die Argumente @var{r} und @var{t} sind eindimensionale Arrays derselben
Gr@"o@ss{}e.  Die Gr@"o@ss{}e der Arrays muss eine Potenz von 2 sein.

@c The original values of the input arrays are replaced by the real and
@c imaginary parts, @code{a} and @code{b}, on return.  The outputs are
@c calculated as
@c @example
@c a = r cos(t)
@c b = r sin(t)
@c @end example

Die Werte der originalen Arrays werden durch den Realteil @code{a = r cos(t)}
und den Imagin@"arteil @code{b = r sin(t)} ersetzt.

@c @code{polartorect} is the inverse function of @code{recttopolar}.
@c @code{load(fft)} loads this function.  See also @code{fft}.

@code{polartorect} ist die inverse Funktion zu @mrefdot{recttopolar}
Das Kommando @code{load(fft)} l@"adt die Funktion.
@end deffn

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{recttopolar}
@deffn {Funktion} recttopolar (@var{a}, @var{b})

@c Translates complex values of the form @code{a + b %i} to the form
@c @code{r %e^(%i t)}, where @var{a} is the real part and @var{b} is the
@c imaginary part.  @var{a} and @var{b} are 1-dimensional arrays of the same
@c size.  The array size need not be a power of 2.

Transformiert komplexe Zahlen der Form @code{a + b %i} in die Polarform
@code{r %e^(%i t)}.  @var{a} ist der Realteil und @var{b} der Imagin@"arteil der
komplexen Zahl.  Die Argumente @var{a} und @var{b} sind eindimensionale Arrays
derselben Gr@"o@ss{}e.  Die Gr@"o@ss{}e der Arrays muss eine Potenz von 2 sein.

@c The original values of the input arrays are replaced by the magnitude and
@c angle, @code{r} and @code{t}, on return. The outputs are calculated as
@c @example
@c r = sqrt(a^2 + b^2)
@c t = atan2(b, a)
@c @end example
@c The computed angle is in the range @code{-%pi} to @code{%pi}.

Die Werte der originalen Arrays werden durch den Betrag
@code{r = sqrt(a^2 + b^2} und die Phase @code{t = atan2(b, a)} ersetzt.  Die
Phase ist ein Winkel in dem Bereich @code{-%pi} bis @code{%pi}.

@c @code{recttopolar} is the inverse function of @code{polartorect}.
@c @code{load(fft)} loads this function.  See also @code{fft}.

@code{recttoploar} ist die inverse Funktion zu @mrefdot{polartorect}
Das Kommando @code{load(fft)} l@"adt die Funktion.
@end deffn

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{inverse_fft}
@deffn {Funktion} inverse_fft (@var{y})

@c Computes the inverse complex fast Fourier transform.  @var{y} is a list or
@c array (named or unnamed) which contains the data to transform.  The number of
@c elements must be a power of 2.  The elements must be literal numbers
@c (integers, rationals, floats, or bigfloats) or symbolic constants, or
@c expressions @code{a + b*%i} where @code{a} and @code{b} are literal numbers
@c or symbolic constants.

Berechnet die inverse schnelle Fourier-Transformation.  Das Argument @var{y} ist
eine Liste oder ein Array mit den Daten, die zu transformieren sind.  Die Anzahl
der Daten muss eine Potenz von 2 sein.  Die Elemente m@"ussen Zahlen (ganze,
rationale, Gleitkommazahlen oder gro@ss{}e Gleitkommazahlen) oder numerische
Konstanten sein.  Weiterhin k@"onnen die Elemente komplexe Zahlen
@code{a + b*%i} sein, wobei der Realteil und der Imagin@"arteil wiederum Zahlen
oder numerische Konstanten sein m@"ussen.

@c @code{inverse_fft} returns a new object of the same type as @var{y}, which is
@c not modified.  Results are always computed as floats or expressions
@c @code{a + b*%i} where @code{a} and @code{b} are floats.

@code{inverse_fft} gibt ein neues Objekt vom selben Typ wie @var{y} zur@"uck.
Die Ergebnisse sind immer Gleitkommazahlen oder komplexe Zahlen
@code{a + %i*b}, wobei @code{a} und @code{b} Gleitkommazahlen sind.

@c The inverse discrete Fourier transform is defined as follows.
@c Let @code{x} be the output of the inverse transform.
@c Then for @code{j} from 0 through @code{n - 1},
@c @example
@c x[j] = sum(y[k] exp(+2 %i %pi j k / n), k, 0, n - 1)
@c @end example

Die inverse diskrete Fourier-Transformation ist wie folgt definiert.  Wenn
@code{x} das Ergebnis der inversen Fourier-Transformation ist, dann gilt f@"ur
@code{j} von 0 bis @code{n-1}

@ifnottex
@example
x[j] = sum(y[k] exp(2 %i %pi j k / n), k, 0, n - 1)
@end example
@end ifnottex
@tex
$$x_{j}=\sum_{k=0}^{n-1}{y_{k}\,e^{{{2\,i\,\pi\,j\,k}\over{n}}}}$$
@end tex

@c @code{load(fft)} loads this function.
@c See also @code{fft} (forward transform), @code{recttopolar}, and 
@c @code{polartorect}.

Mit dem Kommando @code{load(fft)} wird die Funktion geladen.  Siehe auch 
@mref{fft} f@"ur die schnelle Fourier-Transformation.

Beispiele:

@c Real data.

Reelle Daten.

@example
(%i1) load (fft) $
(%i2) fpprintprec : 4 $
(%i3) L : [1, 2, 3, 4, -1, -2, -3, -4] $
(%i4) L1 : inverse_fft (L);
(%o4) [0.0, 14.49 %i - .8284, 0.0, 2.485 %i + 4.828, 0.0, 
                       4.828 - 2.485 %i, 0.0, - 14.49 %i - .8284]
(%i5) L2 : fft (L1);
(%o5) [1.0, 2.0 - 2.168L-19 %i, 3.0 - 7.525L-20 %i, 
4.0 - 4.256L-19 %i, - 1.0, 2.168L-19 %i - 2.0, 
7.525L-20 %i - 3.0, 4.256L-19 %i - 4.0]
(%i6) lmax (abs (L2 - L));
(%o6)                       3.545L-16
@end example

@c Complex data.

Komplexe Daten.

@example
(%i1) load (fft) $
(%i2) fpprintprec : 4 $                 
(%i3) L : [1, 1 + %i, 1 - %i, -1, -1, 1 - %i, 1 + %i, 1] $
(%i4) L1 : inverse_fft (L);
(%o4) [4.0, 2.711L-19 %i + 4.0, 2.0 %i - 2.0, 
- 2.828 %i - 2.828, 0.0, 5.421L-20 %i + 4.0, - 2.0 %i - 2.0, 
2.828 %i + 2.828]
(%i5) L2 : fft (L1);
(%o5) [4.066E-20 %i + 1.0, 1.0 %i + 1.0, 1.0 - 1.0 %i, 
1.55L-19 %i - 1.0, - 4.066E-20 %i - 1.0, 1.0 - 1.0 %i, 
1.0 %i + 1.0, 1.0 - 7.368L-20 %i]
(%i6) lmax (abs (L2 - L));                    
(%o6)                       6.841L-17
@end example
@end deffn

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{fft}
@deffn {Funktion} fft (@var{x})

@c Computes the complex fast Fourier transform.  @var{x} is a list or array 
@c (named or unnamed) which contains the data to transform.  The number of 
@c elements must be a power of 2.  The elements must be literal numbers
@c (integers, rationals, floats, or bigfloats) or symbolic constants, or
@c expressions @code{a + b*%i} where @code{a} and @code{b} are literal numbers
@c or symbolic constants.

Berechnet die schnelle Fourier-Transformation.  Das Argument @var{x} ist eine
Liste oder ein Array mit den Daten, die zu transformieren sind.  Die Anzahl der
Elemente muss eine Potenz von 2 sein.  Die Elemente m@"ussen Zahlen (ganze,
rationale, Gleitkommazahlen oder gro@ss{}e Gleitkommazahlen) oder numerische
Konstanten sein.  Weiterhin k@"onnen die Elemente komplexe Zahlen
@code{a + b*%i} sein, wobei der Realteil und der Imagin@"arteil wiederum Zahlen
oder numerische Konstanten sein m@"ussen.

@c @code{fft} returns a new object of the same type as @var{x}, which is not
@c modified.  Results are always computed as floats or expressions
@c @code{a + b*%i} where @code{a} and @code{b} are floats.

@code{inverse_fft} gibt ein neues Objekt vom selben Typ wie @var{x} zur@"uck.
Die Ergebnisse sind immer Gleitkommazahlen oder komplexe Zahlen
@code{a + %i*b}, wobei @code{a} und @code{b} Gleitkommazahlen sind.

@c The discrete Fourier transform is defined as follows.
@c Let @code{y} be the output of the transform.
@c Then for @code{k} from 0 through @code{n - 1},
@c @example
@c y[k] = (1/n) sum(x[j] exp(-2 %i %pi j k / n), j, 0, n - 1)
@c @end example

Die diskrete Fourier-Transformation ist wie folgt definiert.  Wenn @code{y} das
Ergebnis der Fourier-Transformation ist, dann gilt f@"ur @code{k} von 0 bis
@code{n-1}

@ifnottex
@example
y[k] = (1/n) sum(x[j] exp(-2 %i %pi j k / n), j, 0, n - 1)
@end example
@end ifnottex
@tex
$$y_{k}={{1}\over{n}}
        \sum_{j=0}^{n-1}{x_{j}\,e^ {- {{2\,i\,\pi\,j\,k}\over{n}} }}$$
@end tex

@c When the data @var{x} are real,
@c real coefficients @code{a} and @code{b} can be computed such that

Sind die Daten @var{x} reelle Zahlen, dann werden die reellen Koeffizienten
@var{a} und @var{b} so berechnet, dass gilt

@ifnottex
@example
x[j] = sum (a[k] * cos (2*%pi*j*k / n) 
          + b[k] * sin (2*%pi*j*k / n), k, 0, n/2)
@end example
@end ifnottex
@tex
$$x_{j}=\sum_{k=0}^{{{n}\over{2}}}{\left(b_{k}\,\sin \left({{2\,\pi\,
 j\,k}\over{n}}\right)+a_{k}\,\cos \left({{2\,\pi\,j\,k}\over{n}}
 \right)\right)}$$
@end tex

wobei

@ifnottex
@example
a[0] = realpart (y[0])
b[0] = 0
@end example
@end ifnottex
@tex
$$a_{0}={\it realpart}\left(y_{0}\right)$$
$$b_{0}=0$$
@end tex

@c and, for k from 1 through n/2 - 1,

und f@"ur @var{k} von 1 bis @code{n/2-1}

@ifnottex
@example
a[k] = realpart (y[k] + y[n - k])
b[k] = imagpart (y[n - k] - y[k])
@end example
@end ifnottex
@tex
$$a_{k}={\it realpart}\left(y_{n-k}+y_{k}\right)$$
$$b_{k}={\it imagpart}\left(y_{n-k}-y_{k}\right)$$
@end tex

sowie

@ifnottex
@example
a[n/2] = realpart (y[n/2])
b[n/2] = 0
@end example
@end ifnottex
@tex
$$a_{{{n}\over{2}}}={\it realpart}\left(y_{{{n}\over{2}}}\right)$$
$$b_{{{n}\over{2}}}=0$$
@end tex

@c @code{load(fft)} loads this function.
@c See also @code{inverse_fft} (inverse transform), @code{recttopolar}, and 
@c @code{polartorect}.

Das Kommando @code{load(fft)} l@"adt die Funktion.
Siehe auch @mref{inverse_fft} f@"ur die inverse schnelle Fourier-Transformation.

Beispiele:

Reelle Daten.

@example
(%i1) load (fft) $
(%i2) fpprintprec : 4 $
(%i3) L : [1, 2, 3, 4, -1, -2, -3, -4] $
(%i4) L1 : fft (L);
(%o4) [0.0, - 1.811 %i - .1036, 0.0, .6036 - .3107 %i, 0.0, 
                         .3107 %i + .6036, 0.0, 1.811 %i - .1036]
(%i5) L2 : inverse_fft (L1);
(%o5) [1.0, 2.168L-19 %i + 2.0, 7.525L-20 %i + 3.0, 
4.256L-19 %i + 4.0, - 1.0, - 2.168L-19 %i - 2.0, 
- 7.525L-20 %i - 3.0, - 4.256L-19 %i - 4.0]
(%i6) lmax (abs (L2 - L));
(%o6)                       3.545L-16
@end example

Komplexe Daten.

@example
(%i1) load (fft) $
(%i2) fpprintprec : 4 $
(%i3) L : [1, 1 + %i, 1 - %i, -1, -1, 1 - %i, 1 + %i, 1] $
(%i4) L1 : fft (L);
@group
(%o4) [0.5, .3536 %i + .3536, - 0.25 %i - 0.25, 
0.5 - 6.776L-21 %i, 0.0, - .3536 %i - .3536, 0.25 %i - 0.25, 
0.5 - 3.388L-20 %i]
@end group
(%i5) L2 : inverse_fft (L1);
(%o5) [1.0 - 4.066E-20 %i, 1.0 %i + 1.0, 1.0 - 1.0 %i, 
- 1.008L-19 %i - 1.0, 4.066E-20 %i - 1.0, 1.0 - 1.0 %i, 
1.0 %i + 1.0, 1.947L-20 %i + 1.0]
(%i6) lmax (abs (L2 - L));
(%o6)                       6.83L-17
@end example

@c Computation of sine and cosine coefficients.

Berechnung der Sinus- und Kosinus-Koeffizienten.

@example
(%i1) load (fft) $
(%i2) fpprintprec : 4 $
(%i3) L : [1, 2, 3, 4, 5, 6, 7, 8] $
(%i4) n : length (L) $
(%i5) x : make_array (any, n) $
(%i6) fillarray (x, L) $
(%i7) y : fft (x) $
(%i8) a : make_array (any, n/2 + 1) $
(%i9) b : make_array (any, n/2 + 1) $
(%i10) a[0] : realpart (y[0]) $
(%i11) b[0] : 0 $
(%i12) for k : 1 thru n/2 - 1 do
   (a[k] : realpart (y[k] + y[n - k]),
    b[k] : imagpart (y[n - k] - y[k]));
(%o12)                        done
(%i13) a[n/2] : y[n/2] $
(%i14) b[n/2] : 0 $
(%i15) listarray (a);
(%o15)          [4.5, - 1.0, - 1.0, - 1.0, - 0.5]
(%i16) listarray (b);
(%o16)           [0, - 2.414, - 1.0, - .4142, 0]
(%i17) f(j) := sum (a[k] * cos (2*%pi*j*k / n) + b[k] 
                         * sin (2*%pi*j*k / n), k, 0, n/2) $
(%i18) makelist (float (f (j)), j, 0, n - 1);
(%o18)      [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]
@end example
@end deffn

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{horner}
@deffn  {Funktion} horner (@var{expr}, @var{x})
@deffnx {Funktion} horner (@var{expr})

@c Returns a rearranged representation of @var{expr} as in Horner's rule, using
@c @var{x} as the main variable if it is specified.  @code{x} may be omitted in
@c which case the main variable of the canonical rational expression form of
@c @var{expr} is used.

Formt ein Polynom @var{expr} in das Horner-Schema um.  Mit @var{x} wird die
Variable angegeben, f@"ur die das Horner-Schema zu bilden ist.  Wird das
Argument @var{x} nicht angegeben, wird die Hauptvariable des kanonischen
Ausdrucks @var{expr} f@"ur die Bildung des Horner-Schemas genutzt.

@c @code{horner} sometimes improves stability if @code{expr} is
@c to be numerically evaluated.  It is also useful if Maxima is used to
@c generate programs to be run in Fortran.  See also @code{stringout}.

Das Horner-Schema kann die Stabilit@"at der numerischen Berechnung eines
Ausdrucks verbessern.

Beispiel:

@example
(%i1) expr: 1e-155*x^2 - 5.5*x + 5.2e155;
                           2
(%o1)            1.0E-155 x  - 5.5 x + 5.2E+155
(%i2) expr2: horner (%, x), keepfloat: true;
(%o2)            (1.0E-155 x - 5.5) x + 5.2E+155
(%i3) ev (expr, x=1e155);
Maxima encountered a Lisp error:

 floating point overflow

Automatically continuing.
To reenable the Lisp debugger set *debugger-hook* to nil.
(%i4) ev (expr2, x=1e155);
(%o4)                       7.0E+154
@end example
@end deffn

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{find_root}
@anchor{find_root_error}
@anchor{find_root_abs}
@anchor{find_root_rel}
@deffn  {Funktion} find_root (@var{expr}, @var{x}, @var{a}, @var{b})
@deffnx {Funktion} find_root (@var{f}, @var{a}, @var{b})
@deffnx {Optionsvariable} find_root_error
@deffnx {Optionsvariable} find_root_abs
@deffnx {Optionsvariable} find_root_rel

@c Finds a root of the expression @var{expr} or the function @var{f} over the 
@c closed interval @math{[@var{a}, @var{b}]}.  The expression @var{expr} may be
@c an equation, in which case @code{find_root} seeks a root of 
@c @code{lhs(@var{expr}) - rhs(@var{expr})}.

Findet die Nullstellen eines Ausdrucks @var{expr} oder einer Funktion @var{f}
in dem Intervall @code{[@var{a}, @var{b}]}.  Der Ausdruck @var{expr} kann eine
Gleichung sein.  In diesem Fall sucht die Funktion @code{find_root} die 
Nullstellen f@"ur den Ausdruck @code{lhs(@var{expr}) - rhs(@var{expr})}.

@c Given that Maxima can evaluate @var{expr} or @var{f} over 
@c @math{[@var{a}, @var{b}]} and that @var{expr} or @var{f} is continuous,
@c @code{find_root} is guaranteed to find the root, or one of the roots if there
@c is more than one.

Kann Maxima den Ausdruck @var{expr} oder die Funktion @var{f} in dem Intervall
@code{[@var{a}, @var{b}]} f@"ur alle Werte auswerten und ist der Ausdruck
@var{expr} oder die Funktion @var{f} in dem Intervall stetig, dann ist sicher,
dass @code{find_root} die Nullstelle oder zumindest eine Nullstelle findet,
wenn mehrere Nullstellen vorhanden sind.

@c @code{find_root} initially applies binary search.
@c If the function in question appears to be smooth enough,
@c @code{find_root} applies linear interpolation instead.

@code{find_root} beginnt mit einer bin@"aren Suche der Nullstelle.  Erscheint
die Funktion als glatt genug, wendet Maxima einen Algorithmus mit einer linearen
Interpolation f@"ur die Suche der Nullstelle an.

@c The accuracy of @code{find_root} is governed by @code{find_root_abs} and 
@c @code{find_root_rel}.  @code{find_root} stops when the function in question
@c evaluates to something less than or equal to @code{find_root_abs},
@c or if successive approximants @var{x_0}, @var{x_1} differ by no more than
@c @code{find_root_rel * max(abs(x_0), abs(x_1))}.  The default values of 
@c @code{find_root_abs} and @code{find_root_rel} are both zero.

Die Genauigkeit der Nullstellensuche wird von den Optionsvariablen
@code{find_root_abs} und @code{find_root_rel} kontrolliert.  @code{find_root}
endet, wenn die Auswertung der Funktion ein Ergebnis hat, das kleiner als
@code{find_root_abs} ist oder wenn aufeinander folgende Auswertungen
Ergebnisse @var{x_0} und @var{x_1} haben, die sich voneinander weniger als
@code{find_root_rel * max(abs(x_0), abs(x_1))} unterscheiden.  Der Standardwert
der Optionsvariablen @code{find_root_abs} und @code{find_root_rel} ist Null.

@c @code{find_root} expects the function in question to have a different sign at
@c the endpoints of the search interval.  When the function evaluates to a
@c number at both endpoints and these numbers have the same sign, the behavior
@c of @code{find_root} is governed by @code{find_root_error}.
@c When @code{find_root_error} is @code{true}, @code{find_root} prints an error
@c message.  Otherwise @code{find_root} returns the value of 
@c @code{find_root_error}.  The default value of @code{find_root_error} is 
@c @code{true}.

@code{find_root} erwartet, dass die Funktion an den Endpunkten des Intervalls
f@"ur die Nullstellensuche ein unterschiedliches Vorzeichen hat.  Hat die
Funktion an den Endpunkten des Intervalls dasselbe Vorzeichen, wird das
Verhalten der Funktion @code{find_root} von der Optionsvariablen
@code{find_root_error} kontrolliert.  Hat @code{find_root_error} den Wert
@code{true}, wird eine Fehlermeldung ausgegeben.  Ansonsten wird von
@code{find_root} der Wert von @code{find_root_error} als Ergebnis
zur@"uckgegeben.  Der Standardwert von @code{find_root_error} ist @code{true}.

@c If @var{f} evaluates to something other than a number at any step in the
@c search algorithm, @code{find_root} returns a partially-evaluated
@c @code{find_root} expression.

Kann die Funktion @var{f} bei der Nullstellensuche nicht zu einer Zahl
ausgewertet werden, gibt @code{find_root} ein teilweise ausgewertetes Ergebnis
zur@"uck.

@c The order of @var{a} and @var{b} is ignored; the region in which a root is 
@c sought is @math{[min(@var{a}, @var{b}), max(@var{a}, @var{b})]}.

Die Reihenfolge der Grenzen des Intervalls @var{a} und @var{b} wird ignoriert.
@code{find_root} sucht die Nullstellen immer in dem Intervall
@code{[min(@var{a}, @var{b}), max(@var{a}, @var{b})]}.

Beispiele:

@example
(%i1) f(x) := sin(x) - x/2;
                                        x
(%o1)                  f(x) := sin(x) - -
                                        2
(%i2) find_root (sin(x) - x/2, x, 0.1, %pi);
(%o2)                   1.895494267033981
(%i3) find_root (sin(x) = x/2, x, 0.1, %pi);
(%o3)                   1.895494267033981
(%i4) find_root (f(x), x, 0.1, %pi);
(%o4)                   1.895494267033981
(%i5) find_root (f, 0.1, %pi);
(%o5)                   1.895494267033981
(%i6) find_root (exp(x) = y, x, 0, 100);
                            x
(%o6)           find_root(%e  = y, x, 0.0, 100.0)
(%i7) find_root (exp(x) = y, x, 0, 100), y = 10;
(%o7)                   2.302585092994046
(%i8) log (10.0);
(%o8)                   2.302585092994046
@end example
@end deffn

@c -----------------------------------------------------------------------------
@node Einf@"uhrung in Fourierreihen, Funktionen und Variablen f@"ur Fourierreihen, Funktionen und Variablen f@"ur die schnelle Fourier-Transformation, Fourier-Transformationen
@section Einf@"uhrung in Fourierreihen
@c -----------------------------------------------------------------------------

@c The @code{fourie} package comprises functions for the symbolic computation
@c of Fourier series.
@c There are functions in the @code{fourie} package to calculate Fourier 
@c integral coefficients and some functions for manipulation of expressions.

Das Paket @code{fourie} enth@"alt Funktionen f@"ur die symbolische Berechnungen
von Fourierreihen.  Weiterhin enth@"alt das Paket Funktionen, um
Fourierkoeffizienten zu berechnen und einige weitere Funktionen.

@c -----------------------------------------------------------------------------
@node Funktionen und Variablen f@"ur Fourierreihen, , Einf@"uhrung in Fourierreihen, Fourier-Transformationen
@section Funktionen und Variablen f@"ur Fourierreihen
@c -----------------------------------------------------------------------------

@c REPHRASE

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{equalp}
@deffn {Funktion} equalp (@var{x}, @var{y})

@c Returns @code{true} if @code{equal (@var{x}, @var{y})} otherwise @code{false}
@c (doesn't give an error message like @code{equal (x, y)} would do in this
@c case).

Gibt @code{true} zur@"uck, wenn @code{equal(@var{x}, @var{y})} das Ergebnis
@code{true} hat.  Ansonsten ist das Ergebnis @code{false}.
@end deffn

@c --- 28.05.2011 DK -----------------------------------------------------------
@deffn  {Funktion} remfun (@var{f}, @var{expr})
@deffnx {Funktion} remfun (@var{f}, @var{expr}, @var{x})

@c @code{remfun (@var{f}, @var{expr})} replaces all occurrences of 
@c @code{@var{f} (@var{arg})} by @var{arg} in @var{expr}.

@code{remfun(@var{f}, @var{expr}} ersetzt @code{@var{f}(@var{arg})} durch
@var{arg} im Ausdruck @var{expr}.

@c @code{remfun (@var{f}, @var{expr}, @var{x})} replaces all occurrences of 
@c @code{@var{f} (@var{arg})} by @var{arg} in @var{expr} only if @var{arg} 
@c contains the variable @var{x}.

@code{remfun(@var{f}, @var{expr}, @var{x})} ersetzt @code{@var{f} (@var{arg})}
durch @var{arg} im Ausdruck @var{expr} nur dann, wenn @var{arg} die Variable
@var{x} enth@"alt.
@end deffn

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{funp}
@deffn  {Funktion} funp (@var{f}, @var{expr})
@deffnx {Funktion} funp (@var{f}, @var{expr}, @var{x})

@c @code{funp (@var{f}, @var{expr})}
@c returns @code{true} if @var{expr} contains the function @var{f}.

@code{funp(@var{f}, @var{expr})} hat das Ergebnis @code{true}, wenn der
Ausdruck @var{expr} die Funktion @var{f} enth@"alt.

@c @code{funp (@var{f}, @var{expr}, @var{x})} returns @code{true} if @var{expr}
@c contains the function @var{f} and the variable @var{x} is somewhere in the
@c argument of one of the instances of @var{f}.

@code{funp(@var{f}, @var{expr}, @var{x})} hat das Ergebnis @code{true}, wenn
der Ausdruck @var{expr} die Funktion @var{f} enthält und die Variable @var{x}
ein Argument der Funktion @var{f} ist.
@end deffn

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{absint}
@deffn  {Funktion} absint (@var{f}, @var{x}, @var{halfplane})
@deffnx {Funktion} absint (@var{f}, @var{x})
@deffnx {Funktion} absint (@var{f}, @var{x}, @var{a}, @var{b})

@c @code{absint (@var{f}, @var{x}, @var{halfplane})}
@c returns the indefinite integral of @var{f} with respect to
@c @var{x} in the given halfplane (@code{pos}, @code{neg}, or @code{both}).
@c @var{f} may contain expressions of the form
@c @code{abs (x)}, @code{abs (sin (x))}, @code{abs(a) * exp (-abs(b) * abs(x))}.

@code{absint(@var{f}, @var{x}, @var{halfplane})} gibt das unbestimmte Integral
der Funktion @var{f} f@"ur die Variable @var{x} zur@"uck.  Das Integral wird in
der angegebenen Halbebene @code{pos}, @code{neg} oder f@"ur beide Halbebenen
mit @code{both} berechnet.  Der Integrand kann die Betragsfunktion enthalten:
@code{abs(x)}, @code{abs(sin(x))}, @code{abs(a) * exp(-abs(b) * abs(x))}.

@c @code{absint (@var{f}, @var{x})} is equivalent to 
@c @code{absint (@var{f}, @var{x}, pos)}.

@code{absint(@var{f}, @var{x})} ist @"aquivalent zu
@code{absint(@var{f}, @var{x}, pos)}.

@c @code{absint (@var{f}, @var{x}, @var{a}, @var{b})} returns the definite
@c integral of @var{f} with respect to @var{x} from @var{a} to @var{b}.
@c SAME LIST AS ABOVE ??
@c @var{f} may include absolute values.

@code{absint(@var{f}, @var{x}, @var{a}, @var{b})} gibt das bestimmte Integral
der Funktion @var{f} f@"ur die Variable @var{x} in den Grenzen @var{a} und
@var{b} zur@"uck.  Der Integrand kann die Betragsfunktion enthalten.
@end deffn

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{fourier}
@deffn {Funktion} fourier (@var{f}, @var{x}, @var{l})

Berechnet die Fourier-Koeffizienten @code{a[0]}, @code{a[n]} und @code{b[n]}
der Funktion @code{@var{f}(@var{x})} f@"ur das Intervall @code{[-l, l]}.  Die
Fourierreihe ist definiert als:

@example
         inf
         ====
         \             %pi n x           %pi n x
  f(x) =  >    (b  sin(-------) + a  cos(-------))
         /       n        l        n        l
         ====
         n = 0
@end example

Die Koeffizienten der Fourierreihe werden folgenderma@ss{}en berechnet:

@example
                     l
                    /
                - 1 [
      a  = 1/2 l    I    f(x) dx
       0            ]
                    /
                     - l
@end example

@example
                 l
                /
            - 1 [                  - 1
      a  = l    I    f(x) cos(%pi l    n x) dx
       n        ]
                /
                 - l
@end example

@example
                  l
                 /
            - 1 [                  - 1
      b  = l    I    f(x) sin(%pi l    n x) dx
       n        ]
                /
                 - l
@end example

@code{fourier} weist die Fourier-Koeffizienten Zwischenmarken zu.  Die
Zwischenmarken werden als eine Liste zur@"uckgegeben.

Der Index der Summe ist immer das Symbol @var{n}.  Sinus- und Kosinusfunktionen
mit ganzzahligen Vielfachen von @code{%pi} werden nicht automatisch vereinfacht.
Dies kann mit der Funktion @mref{foursimp} erreicht werden, der als Argument
die Liste der Fourier-Koeffizienten @"ubergeben wird.

Mit der Funktion @mref{fourexpand} kann die Fourierreihe aus den
Fourier-Koeffizienten konstruiert werden.  Siehe auch die Funktion
@mrefdot{totalfourier}

Mit den Funktionen @mref{fourcos} und @mref{foursin} werden jeweils die
Koeffizienten der Kosinus- und Sinus-Entwicklung berechnet.

Beispiel:

@example
(%i1) load(fourie)$

(%i2) fourier(x, x, 1);
(%t2)                        a  = 0
                              0

(%t3)                        a  = 0
                              n

                        sin(%pi n)   cos(%pi n)
(%t4)           b  = 2 (---------- - ----------)
                 n          2  2       %pi n
                         %pi  n

(%o4)                    [%t2, %t3, %t4]
(%i5) foursimp(%);
(%t5)                        a  = 0
                              0

(%t6)                        a  = 0
                              n

                                       n
                                2 (- 1)
(%t7)                    b  = - --------
                          n      %pi n

(%o7)                    [%t5, %t6, %t7]
(%i8) fourexpand(%, x, 1, inf);
                      inf
                      ====       n
                      \     (- 1)  sin(%pi n x)
                    2  >    -------------------
                      /              n
                      ====
                      n = 1
(%o8)             - ---------------------------
                                %pi
@end example
@end deffn

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{foursimp}
@deffn {Funktion} foursimp (@var{l})

@code{foursimp} wird auf das Ergebnis der Funktion @mref{fourier} angewendet,
um Sinus- und Kosinus-Funktionen zu vereinfachen, die ganzzahlige Vielfache
von @code{%pi} enthalten.  Das Argument @var{l} ist eine Liste mit den
Koeffizienten der Fourierreihe, f@"ur die die Vereinfachung ausgef@"uhrt werden
soll.

@code{sin(n %pi)} wird zu @code{0} vereinfacht, wenn die Optionsvariable
@mref{sinnpiflag} den Wert @code{true} hat, und @code{cos(n %pi)} wird zu
@code{(-1)^n}, wenn die Optionsvariable @mref{cosnpiflag} den Wert @code{true}
hat.

Siehe die Funktion @mref{fourier} f@"ur ein Beispiel.
@end deffn

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{sinnpiflag}
@defvr {Optionsvariable} sinnpiflag
Standardwert: @code{true}

Kontrolliert die Vereinfachung der Sinus-Funktion durch die Funktion
@code{foursimp}.  Siehe die Funktion @mrefdot{foursimp}
@end defvr

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{cosnpiflag}
@defvr {Optionsvariable} cosnpiflag
Standardwert: @code{true}

Kontrolliert die Vereinfachung der Kosinus-Funktion durch die Funktion
@code{foursimp}.  Siehe die Funktion @mrefdot{foursimp}
@end defvr

@c NEEDS EXPANSION.  EXPLAIN x AND p HERE (DO NOT REFER SOMEWHERE ELSE)

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{fourexpand}
@deffn {Funktion} fourexpand (@var{l}, @var{x}, @var{p}, @var{limit})

Konstruiert aus der Liste der Fourier-Koeffizienten @var{l} eine Fourierreihe
mit @var{limit} Termen.  Das Argument @var{limit} kann @code{inf} sein.  Die
Argumente @var{x} und @var{p} haben dieselbe Bedeutung wie f@"ur die Funktion
@mrefdot{fourier}

Siehe die Funktion @mref{fourier} f@"ur ein Beispiel.
@end deffn

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{fourcos}
@deffn {Funktion} fourcos (@var{f}, @var{x}, @var{p})

@c Returns the Fourier cosine coefficients for @code{@var{f}(@var{x})} defined
@c on @code{[0, @var{p}]}.

Gibt die Kosinus-Koeffizienten einer Fourierreihe f@"ur die Funktion
@code{@var{f}(@var{x})} zur@"uck, die auf dem Intervall @code{[0, @var{p}]}
definiert ist.
@end deffn

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{foursin}
@deffn {Funktion} foursin (@var{f}, @var{x}, @var{p})

@c Returns the Fourier sine coefficients for @code{@var{f}(@var{x})} defined on
@c @code{[0, @var{p}]}.

Gibt die Sinus-Koeffizienten einer Fourierreihe f@"ur die Funktion
@code{@var{f}(@var{x})} zur@"uck, die auf dem Intervall @code{[0, @var{p}]}
definiert ist.
@end deffn

@c NEEDS EXPANSION

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{totalfourier}
@deffn {Funktion} totalfourier (@var{f}, @var{x}, @var{l})

Gibt die Fourierreihe der Funktion @var{f(x)} f@"ur das Intervall
@code{[@var{-l}, @var{l}]} zur@"uck.  Das Ergebnis wird berechnet, indem
die nacheinander die Funktionen @mref{foursimp} und @mref{fourexpand} auf das
Ergebnis der Funktion @mref{fourier} angewendet werden.

Beispiel:

@example
(%i1) load(fourie)$

(%i2) totalfourier(x, x, 1);
(%t2)                        a  = 0
                              0

(%t3)                        a  = 0
                              n

                        sin(%pi n)   cos(%pi n)
(%t4)           b  = 2 (---------- - ----------)
                 n          2  2       %pi n
                         %pi  n

(%t5)                        a  = 0
                              0

(%t6)                        a  = 0
                              n
@group
                                       n
                                2 (- 1)
(%t7)                    b  = - --------
                          n      %pi n
@end group
@group
                      inf
                      ====       n
                      \     (- 1)  sin(%pi n x)
                    2  >    -------------------
                      /              n
                      ====
                      n = 1
(%o7)             - ---------------------------
                                %pi
@end group
@end example

@end deffn

@c NEEDS EXPANSION

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{fourint}
@deffn {Funktion} fourint (@var{f}, @var{x})

@c Constructs and returns a list of the Fourier integral coefficients of 
@c @code{@var{f}(@var{x})} defined on @code{[minf, inf]}.

Konstruiert eine Liste der Fourierintegral-Koeffizienten der Funktion
@code{@var{f}(@var{x})}, die auf dem Intervall @code{[minf, inf]} definiert ist.
@end deffn

@c NEEDS EXPANSION

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{fourintcos}
@deffn {Funktion} fourintcos (@var{f}, @var{x})

@c Returns the Fourier cosine integral coefficients for @code{@var{f}(@var{x})}
@c on @code{[0, inf]}.

Gibt die Koeffizienten des Kosinus-Fourierintegrals der Funktion
@code{@var{f}(@var{x})} zur@"uck, die auf dem Intervall @code{[0, inf]}
definiert ist.

@end deffn

@c NEEDS EXPANSION

@c --- 28.05.2011 DK -----------------------------------------------------------
@anchor{fourintsin}
@deffn {Funktion} fourintsin (@var{f}, @var{x})

@c Returns the Fourier sine integral coefficients for @code{@var{f}(@var{x})}
@c on @code{[0, inf]}.

Gibt die Koeffizienten des Sinus-Fourierintegrals der Funktion
@code{@var{f}(@var{x})} zur@"uck, die auf dem Intervall @code{[0, inf]}
definiert ist.
@end deffn

@c --- End of Numerical.de.texi ------------------------------------------------

