doc/info/de/Numerical.de.texi

   1 @c -----------------------------------------------------------------------------
   2 @c File        : Numerical.de.texi
   3 @c License     : GNU General Public License (GPL)
   4 @c Language    : German
   5 @c Original    : Numerical.texi revision 14.03.2011
   6 @c Translation : Dr. Dieter Kaiser
   7 @c Date        : 13.11.2010
   8 @c Revision    : 28.05.2011
   9 @c
  10 @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
  11 @c -----------------------------------------------------------------------------
  12
  13 @menu
  14 * Einf@"uhrung in die schnelle Fourier-Transformation::
  15 * Funktionen und Variablen f@"ur die schnelle Fourier-Transformation::
  16 * Einf@"uhrung in Fourierreihen::
  17 * Funktionen und Variablen f@"ur Fourierreihen::
  18 @end menu
  19
  20 @c -----------------------------------------------------------------------------
  21 @node Einf@"uhrung in die schnelle Fourier-Transformation, Funktionen und Variablen f@"ur die schnelle Fourier-Transformation, Fourier-Transformationen, Fourier-Transformationen
  22 @section Einf@"uhrung in die schnelle Fourier-Transformation
  23 @c -----------------------------------------------------------------------------
  24
  25 @c The @code{fft} package comprises functions for the numerical (not symbolic)
  26 @c computation of the fast Fourier transform.
  27
  28 Das Paket @code{fft} enth@"alt Funktionen f@"ur die numerische Berechnung der
  29 schnellen Fourier Transformation (FFT - "Fast Fourier Transform").
  30
  31 @c -----------------------------------------------------------------------------
  32 @node Funktionen und Variablen f@"ur die schnelle Fourier-Transformation, Einf@"uhrung in Fourierreihen, Einf@"uhrung in die schnelle Fourier-Transformation, Fourier-Transformationen
  33 @section Funktionen und Variablen f@"ur die schnelle Fourier-Transformation
  34 @c -----------------------------------------------------------------------------
  35
  36 @c --- 28.05.2011 DK -----------------------------------------------------------
  37 @anchor{polartorect}
  38 @deffn {Funktion} polartorect (@var{r}, @var{t})
  39
  40 @c Translates complex values of the form @code{r %e^(%i t)} to the form
  41 @c @code{a + b %i}, where @var{r} is the magnitude and @var{t} is the phase.
  42 @c @var{r} and @var{t} are 1-dimensional arrays of the same size.
  43 @c The array size need not be a power of 2.
  44
  45 Transformiert komplexe Zahlen der Form @code{r %e^(%i t)} in die Standardform
  46 @code{a + b %i}.  @var{r} ist der Betrag der komplexen Zahl und @var{t} die
  47 Phase.  Die Argumente @var{r} und @var{t} sind eindimensionale Arrays derselben
  48 Gr@"o@ss{}e.  Die Gr@"o@ss{}e der Arrays muss eine Potenz von 2 sein.
  49
  50 @c The original values of the input arrays are replaced by the real and
  51 @c imaginary parts, @code{a} and @code{b}, on return.  The outputs are
  52 @c calculated as
  53 @c @example
  54 @c a = r cos(t)
  55 @c b = r sin(t)
  56 @c @end example
  57
  58 Die Werte der originalen Arrays werden durch den Realteil @code{a = r cos(t)}
  59 und den Imagin@"arteil @code{b = r sin(t)} ersetzt.
  60
  61 @c @code{polartorect} is the inverse function of @code{recttopolar}.
  62 @c @code{load("fft")} loads this function.  See also @code{fft}.
  63
  64 @code{polartorect} ist die inverse Funktion zu @mrefdot{recttopolar}
  65 Das Kommando @code{load("fft")} l@"adt die Funktion.
  66 @end deffn
  67
  68 @c --- 28.05.2011 DK -----------------------------------------------------------
  69 @anchor{recttopolar}
  70 @deffn {Funktion} recttopolar (@var{a}, @var{b})
  71
  72 @c Translates complex values of the form @code{a + b %i} to the form
  73 @c @code{r %e^(%i t)}, where @var{a} is the real part and @var{b} is the
  74 @c imaginary part.  @var{a} and @var{b} are 1-dimensional arrays of the same
  75 @c size.  The array size need not be a power of 2.
  76
  77 Transformiert komplexe Zahlen der Form @code{a + b %i} in die Polarform
  78 @code{r %e^(%i t)}.  @var{a} ist der Realteil und @var{b} der Imagin@"arteil der
  79 komplexen Zahl.  Die Argumente @var{a} und @var{b} sind eindimensionale Arrays
  80 derselben Gr@"o@ss{}e.  Die Gr@"o@ss{}e der Arrays muss eine Potenz von 2 sein.
  81
  82 @c The original values of the input arrays are replaced by the magnitude and
  83 @c angle, @code{r} and @code{t}, on return. The outputs are calculated as
  84 @c @example
  85 @c r = sqrt(a^2 + b^2)
  86 @c t = atan2(b, a)
  87 @c @end example
  88 @c The computed angle is in the range @code{-%pi} to @code{%pi}.
  89
  90 Die Werte der originalen Arrays werden durch den Betrag
  91 @code{r = sqrt(a^2 + b^2} und die Phase @code{t = atan2(b, a)} ersetzt.  Die
  92 Phase ist ein Winkel in dem Bereich @code{-%pi} bis @code{%pi}.
  93
  94 @c @code{recttopolar} is the inverse function of @code{polartorect}.
  95 @c @code{load("fft")} loads this function.  See also @code{fft}.
  96
  97 @code{recttoploar} ist die inverse Funktion zu @mrefdot{polartorect}
  98 Das Kommando @code{load("fft")} l@"adt die Funktion.
  99 @end deffn
 100
 101 @c --- 28.05.2011 DK -----------------------------------------------------------
 102 @anchor{inverse_fft}
 103 @deffn {Funktion} inverse_fft (@var{y})
 104
 105 @c Computes the inverse complex fast Fourier transform.  @var{y} is a list or
 106 @c array (named or unnamed) which contains the data to transform.  The number of
 107 @c elements must be a power of 2.  The elements must be literal numbers
 108 @c (integers, rationals, floats, or bigfloats) or symbolic constants, or
 109 @c expressions @code{a + b*%i} where @code{a} and @code{b} are literal numbers
 110 @c or symbolic constants.
 111
 112 Berechnet die inverse schnelle Fourier-Transformation.  Das Argument @var{y} ist
 113 eine Liste oder ein Array mit den Daten, die zu transformieren sind.  Die Anzahl
 114 der Daten muss eine Potenz von 2 sein.  Die Elemente m@"ussen Zahlen (ganze,
 115 rationale, Gleitkommazahlen oder gro@ss{}e Gleitkommazahlen) oder numerische
 116 Konstanten sein.  Weiterhin k@"onnen die Elemente komplexe Zahlen
 117 @code{a + b*%i} sein, wobei der Realteil und der Imagin@"arteil wiederum Zahlen
 118 oder numerische Konstanten sein m@"ussen.
 119
 120 @c @code{inverse_fft} returns a new object of the same type as @var{y}, which is
 121 @c not modified.  Results are always computed as floats or expressions
 122 @c @code{a + b*%i} where @code{a} and @code{b} are floats.
 123
 124 @code{inverse_fft} gibt ein neues Objekt vom selben Typ wie @var{y} zur@"uck.
 125 Die Ergebnisse sind immer Gleitkommazahlen oder komplexe Zahlen
 126 @code{a + %i*b}, wobei @code{a} und @code{b} Gleitkommazahlen sind.
 127
 128 @c The inverse discrete Fourier transform is defined as follows.
 129 @c Let @code{x} be the output of the inverse transform.
 130 @c Then for @code{j} from 0 through @code{n - 1},
 131 @c @example
 132 @c x[j] = sum(y[k] exp(+2 %i %pi j k / n), k, 0, n - 1)
 133 @c @end example
 134
 135 Die inverse diskrete Fourier-Transformation ist wie folgt definiert.  Wenn
 136 @code{x} das Ergebnis der inversen Fourier-Transformation ist, dann gilt f@"ur
 137 @code{j} von 0 bis @code{n-1}
 138
 139 @ifnottex
 140 @example
 141 x[j] = sum(y[k] exp(2 %i %pi j k / n), k, 0, n - 1)
 142 @end example
 143 @end ifnottex
 144 @tex
 145 $$x_{j}=\sum_{k=0}^{n-1}{y_{k}\,e^{{{2\,i\,\pi\,j\,k}\over{n}}}}$$
 146 @end tex
 147
 148 @c @code{load("fft")} loads this function.
 149 @c See also @code{fft} (forward transform), @code{recttopolar}, and
 150 @c @code{polartorect}.
 151
 152 Mit dem Kommando @code{load("fft")} wird die Funktion geladen.  Siehe auch
 153 @mref{fft} f@"ur die schnelle Fourier-Transformation.
 154
 155 Beispiele:
 156
 157 @c Real data.
 158
 159 Reelle Daten.
 160
 161 @example
 162 (%i1) load ("fft") $
 163 (%i2) fpprintprec : 4 $
 164 (%i3) L : [1, 2, 3, 4, -1, -2, -3, -4] $
 165 (%i4) L1 : inverse_fft (L);
 166 (%o4) [0.0, 14.49 %i - .8284, 0.0, 2.485 %i + 4.828, 0.0,
 167                        4.828 - 2.485 %i, 0.0, - 14.49 %i - .8284]
 168 (%i5) L2 : fft (L1);
 169 (%o5) [1.0, 2.0 - 2.168L-19 %i, 3.0 - 7.525L-20 %i,
 170 4.0 - 4.256L-19 %i, - 1.0, 2.168L-19 %i - 2.0,
 171 7.525L-20 %i - 3.0, 4.256L-19 %i - 4.0]
 172 (%i6) lmax (abs (L2 - L));
 173 (%o6)                       3.545L-16
 174 @end example
 175
 176 @c Complex data.
 177
 178 Komplexe Daten.
 179
 180 @example
 181 (%i1) load ("fft") $
 182 (%i2) fpprintprec : 4 $
 183 (%i3) L : [1, 1 + %i, 1 - %i, -1, -1, 1 - %i, 1 + %i, 1] $
 184 (%i4) L1 : inverse_fft (L);
 185 (%o4) [4.0, 2.711L-19 %i + 4.0, 2.0 %i - 2.0,
 186 - 2.828 %i - 2.828, 0.0, 5.421L-20 %i + 4.0, - 2.0 %i - 2.0,
 187 2.828 %i + 2.828]
 188 (%i5) L2 : fft (L1);
 189 (%o5) [4.066E-20 %i + 1.0, 1.0 %i + 1.0, 1.0 - 1.0 %i,
 190 1.55L-19 %i - 1.0, - 4.066E-20 %i - 1.0, 1.0 - 1.0 %i,
 191 1.0 %i + 1.0, 1.0 - 7.368L-20 %i]
 192 (%i6) lmax (abs (L2 - L));
 193 (%o6)                       6.841L-17
 194 @end example
 195 @end deffn
 196
 197 @c --- 28.05.2011 DK -----------------------------------------------------------
 198 @anchor{fft}
 199 @deffn {Funktion} fft (@var{x})
 200
 201 @c Computes the complex fast Fourier transform.  @var{x} is a list or array
 202 @c (named or unnamed) which contains the data to transform.  The number of
 203 @c elements must be a power of 2.  The elements must be literal numbers
 204 @c (integers, rationals, floats, or bigfloats) or symbolic constants, or
 205 @c expressions @code{a + b*%i} where @code{a} and @code{b} are literal numbers
 206 @c or symbolic constants.
 207
 208 Berechnet die schnelle Fourier-Transformation.  Das Argument @var{x} ist eine
 209 Liste oder ein Array mit den Daten, die zu transformieren sind.  Die Anzahl der
 210 Elemente muss eine Potenz von 2 sein.  Die Elemente m@"ussen Zahlen (ganze,
 211 rationale, Gleitkommazahlen oder gro@ss{}e Gleitkommazahlen) oder numerische
 212 Konstanten sein.  Weiterhin k@"onnen die Elemente komplexe Zahlen
 213 @code{a + b*%i} sein, wobei der Realteil und der Imagin@"arteil wiederum Zahlen
 214 oder numerische Konstanten sein m@"ussen.
 215
 216 @c @code{fft} returns a new object of the same type as @var{x}, which is not
 217 @c modified.  Results are always computed as floats or expressions
 218 @c @code{a + b*%i} where @code{a} and @code{b} are floats.
 219
 220 @code{inverse_fft} gibt ein neues Objekt vom selben Typ wie @var{x} zur@"uck.
 221 Die Ergebnisse sind immer Gleitkommazahlen oder komplexe Zahlen
 222 @code{a + %i*b}, wobei @code{a} und @code{b} Gleitkommazahlen sind.
 223
 224 @c The discrete Fourier transform is defined as follows.
 225 @c Let @code{y} be the output of the transform.
 226 @c Then for @code{k} from 0 through @code{n - 1},
 227 @c @example
 228 @c y[k] = (1/n) sum(x[j] exp(-2 %i %pi j k / n), j, 0, n - 1)
 229 @c @end example
 230
 231 Die diskrete Fourier-Transformation ist wie folgt definiert.  Wenn @code{y} das
 232 Ergebnis der Fourier-Transformation ist, dann gilt f@"ur @code{k} von 0 bis
 233 @code{n-1}
 234
 235 @ifnottex
 236 @example
 237 y[k] = (1/n) sum(x[j] exp(-2 %i %pi j k / n), j, 0, n - 1)
 238 @end example
 239 @end ifnottex
 240 @tex
 241 $$y_{k}={{1}\over{n}}
 242         \sum_{j=0}^{n-1}{x_{j}\,e^ {- {{2\,i\,\pi\,j\,k}\over{n}} }}$$
 243 @end tex
 244
 245 @c When the data @var{x} are real,
 246 @c real coefficients @code{a} and @code{b} can be computed such that
 247
 248 Sind die Daten @var{x} reelle Zahlen, dann werden die reellen Koeffizienten
 249 @var{a} und @var{b} so berechnet, dass gilt
 250
 251 @ifnottex
 252 @example
 253 x[j] = sum (a[k] * cos (2*%pi*j*k / n)
 254           + b[k] * sin (2*%pi*j*k / n), k, 0, n/2)
 255 @end example
 256 @end ifnottex
 257 @tex
 258 $$x_{j}=\sum_{k=0}^{{{n}\over{2}}}{\left(b_{k}\,\sin \left({{2\,\pi\,
 259  j\,k}\over{n}}\right)+a_{k}\,\cos \left({{2\,\pi\,j\,k}\over{n}}
 260  \right)\right)}$$
 261 @end tex
 262
 263 wobei
 264
 265 @ifnottex
 266 @example
 267 a[0] = realpart (y[0])
 268 b[0] = 0
 269 @end example
 270 @end ifnottex
 271 @tex
 272 $$a_{0}={\it realpart}\left(y_{0}\right)$$
 273 $$b_{0}=0$$
 274 @end tex
 275
 276 @c and, for k from 1 through n/2 - 1,
 277
 278 und f@"ur @var{k} von 1 bis @code{n/2-1}
 279
 280 @ifnottex
 281 @example
 282 a[k] = realpart (y[k] + y[n - k])
 283 b[k] = imagpart (y[n - k] - y[k])
 284 @end example
 285 @end ifnottex
 286 @tex
 287 $$a_{k}={\it realpart}\left(y_{n-k}+y_{k}\right)$$
 288 $$b_{k}={\it imagpart}\left(y_{n-k}-y_{k}\right)$$
 289 @end tex
 290
 291 sowie
 292
 293 @ifnottex
 294 @example
 295 a[n/2] = realpart (y[n/2])
 296 b[n/2] = 0
 297 @end example
 298 @end ifnottex
 299 @tex
 300 $$a_{{{n}\over{2}}}={\it realpart}\left(y_{{{n}\over{2}}}\right)$$
 301 $$b_{{{n}\over{2}}}=0$$
 302 @end tex
 303
 304 @c @code{load("fft")} loads this function.
 305 @c See also @code{inverse_fft} (inverse transform), @code{recttopolar}, and
 306 @c @code{polartorect}.
 307
 308 Das Kommando @code{load("fft")} l@"adt die Funktion.
 309 Siehe auch @mref{inverse_fft} f@"ur die inverse schnelle Fourier-Transformation.
 310
 311 Beispiele:
 312
 313 Reelle Daten.
 314
 315 @example
 316 (%i1) load ("fft") $
 317 (%i2) fpprintprec : 4 $
 318 (%i3) L : [1, 2, 3, 4, -1, -2, -3, -4] $
 319 (%i4) L1 : fft (L);
 320 (%o4) [0.0, - 1.811 %i - .1036, 0.0, .6036 - .3107 %i, 0.0,
 321                          .3107 %i + .6036, 0.0, 1.811 %i - .1036]
 322 (%i5) L2 : inverse_fft (L1);
 323 (%o5) [1.0, 2.168L-19 %i + 2.0, 7.525L-20 %i + 3.0,
 324 4.256L-19 %i + 4.0, - 1.0, - 2.168L-19 %i - 2.0,
 325 - 7.525L-20 %i - 3.0, - 4.256L-19 %i - 4.0]
 326 (%i6) lmax (abs (L2 - L));
 327 (%o6)                       3.545L-16
 328 @end example
 329
 330 Komplexe Daten.
 331
 332 @example
 333 (%i1) load ("fft") $
 334 (%i2) fpprintprec : 4 $
 335 (%i3) L : [1, 1 + %i, 1 - %i, -1, -1, 1 - %i, 1 + %i, 1] $
 336 (%i4) L1 : fft (L);
 337 @group
 338 (%o4) [0.5, .3536 %i + .3536, - 0.25 %i - 0.25,
 339 0.5 - 6.776L-21 %i, 0.0, - .3536 %i - .3536, 0.25 %i - 0.25,
 340 0.5 - 3.388L-20 %i]
 341 @end group
 342 (%i5) L2 : inverse_fft (L1);
 343 (%o5) [1.0 - 4.066E-20 %i, 1.0 %i + 1.0, 1.0 - 1.0 %i,
 344 - 1.008L-19 %i - 1.0, 4.066E-20 %i - 1.0, 1.0 - 1.0 %i,
 345 1.0 %i + 1.0, 1.947L-20 %i + 1.0]
 346 (%i6) lmax (abs (L2 - L));
 347 (%o6)                       6.83L-17
 348 @end example
 349
 350 @c Computation of sine and cosine coefficients.
 351
 352 Berechnung der Sinus- und Kosinus-Koeffizienten.
 353
 354 @example
 355 (%i1) load ("fft") $
 356 (%i2) fpprintprec : 4 $
 357 (%i3) L : [1, 2, 3, 4, 5, 6, 7, 8] $
 358 (%i4) n : length (L) $
 359 (%i5) x : make_array (any, n) $
 360 (%i6) fillarray (x, L) $
 361 (%i7) y : fft (x) $
 362 (%i8) a : make_array (any, n/2 + 1) $
 363 (%i9) b : make_array (any, n/2 + 1) $
 364 (%i10) a[0] : realpart (y[0]) $
 365 (%i11) b[0] : 0 $
 366 (%i12) for k : 1 thru n/2 - 1 do
 367    (a[k] : realpart (y[k] + y[n - k]),
 368     b[k] : imagpart (y[n - k] - y[k]));
 369 (%o12)                        done
 370 (%i13) a[n/2] : y[n/2] $
 371 (%i14) b[n/2] : 0 $
 372 (%i15) listarray (a);
 373 (%o15)          [4.5, - 1.0, - 1.0, - 1.0, - 0.5]
 374 (%i16) listarray (b);
 375 (%o16)           [0, - 2.414, - 1.0, - .4142, 0]
 376 (%i17) f(j) := sum (a[k] * cos (2*%pi*j*k / n) + b[k]
 377                          * sin (2*%pi*j*k / n), k, 0, n/2) $
 378 (%i18) makelist (float (f (j)), j, 0, n - 1);
 379 (%o18)      [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]
 380 @end example
 381 @end deffn
 382
 383 @c --- 28.05.2011 DK -----------------------------------------------------------
 384 @anchor{horner}
 385 @deffn  {Funktion} horner (@var{expr}, @var{x})
 386 @deffnx {Funktion} horner (@var{expr})
 387
 388 @c Returns a rearranged representation of @var{expr} as in Horner's rule, using
 389 @c @var{x} as the main variable if it is specified.  @code{x} may be omitted in
 390 @c which case the main variable of the canonical rational expression form of
 391 @c @var{expr} is used.
 392
 393 Formt ein Polynom @var{expr} in das Horner-Schema um.  Mit @var{x} wird die
 394 Variable angegeben, f@"ur die das Horner-Schema zu bilden ist.  Wird das
 395 Argument @var{x} nicht angegeben, wird die Hauptvariable des kanonischen
 396 Ausdrucks @var{expr} f@"ur die Bildung des Horner-Schemas genutzt.
 397
 398 @c @code{horner} sometimes improves stability if @code{expr} is
 399 @c to be numerically evaluated.  It is also useful if Maxima is used to
 400 @c generate programs to be run in Fortran.  See also @code{stringout}.
 401
 402 Das Horner-Schema kann die Stabilit@"at der numerischen Berechnung eines
 403 Ausdrucks verbessern.
 404
 405 Beispiel:
 406
 407 @example
 408 (%i1) expr: 1e-155*x^2 - 5.5*x + 5.2e155;
 409                            2
 410 (%o1)            1.0E-155 x  - 5.5 x + 5.2E+155
 411 (%i2) expr2: horner (%, x), keepfloat: true;
 412 (%o2)            (1.0E-155 x - 5.5) x + 5.2E+155
 413 (%i3) ev (expr, x=1e155);
 414 Maxima encountered a Lisp error:
 415
 416  floating point overflow
 417
 418 Automatically continuing.
 419 To reenable the Lisp debugger set *debugger-hook* to nil.
 420 (%i4) ev (expr2, x=1e155);
 421 (%o4)                       7.0E+154
 422 @end example
 423 @end deffn
 424
 425 @c --- 28.05.2011 DK -----------------------------------------------------------
 426 @anchor{find_root}
 427 @anchor{find_root_error}
 428 @anchor{find_root_abs}
 429 @anchor{find_root_rel}
 430 @deffn  {Funktion} find_root (@var{expr}, @var{x}, @var{a}, @var{b})
 431 @deffnx {Funktion} find_root (@var{f}, @var{a}, @var{b})
 432 @deffnx {Optionsvariable} find_root_error
 433 @deffnx {Optionsvariable} find_root_abs
 434 @deffnx {Optionsvariable} find_root_rel
 435
 436 @c Finds a root of the expression @var{expr} or the function @var{f} over the
 437 @c closed interval @math{[@var{a}, @var{b}]}.  The expression @var{expr} may be
 438 @c an equation, in which case @code{find_root} seeks a root of
 439 @c @code{lhs(@var{expr}) - rhs(@var{expr})}.
 440
 441 Findet die Nullstellen eines Ausdrucks @var{expr} oder einer Funktion @var{f}
 442 in dem Intervall @code{[@var{a}, @var{b}]}.  Der Ausdruck @var{expr} kann eine
 443 Gleichung sein.  In diesem Fall sucht die Funktion @code{find_root} die
 444 Nullstellen f@"ur den Ausdruck @code{lhs(@var{expr}) - rhs(@var{expr})}.
 445
 446 @c Given that Maxima can evaluate @var{expr} or @var{f} over
 447 @c @math{[@var{a}, @var{b}]} and that @var{expr} or @var{f} is continuous,
 448 @c @code{find_root} is guaranteed to find the root, or one of the roots if there
 449 @c is more than one.
 450
 451 Kann Maxima den Ausdruck @var{expr} oder die Funktion @var{f} in dem Intervall
 452 @code{[@var{a}, @var{b}]} f@"ur alle Werte auswerten und ist der Ausdruck
 453 @var{expr} oder die Funktion @var{f} in dem Intervall stetig, dann ist sicher,
 454 dass @code{find_root} die Nullstelle oder zumindest eine Nullstelle findet,
 455 wenn mehrere Nullstellen vorhanden sind.
 456
 457 @c @code{find_root} initially applies binary search.
 458 @c If the function in question appears to be smooth enough,
 459 @c @code{find_root} applies linear interpolation instead.
 460
 461 @code{find_root} beginnt mit einer bin@"aren Suche der Nullstelle.  Erscheint
 462 die Funktion als glatt genug, wendet Maxima einen Algorithmus mit einer linearen
 463 Interpolation f@"ur die Suche der Nullstelle an.
 464
 465 @c The accuracy of @code{find_root} is governed by @code{find_root_abs} and
 466 @c @code{find_root_rel}.  @code{find_root} stops when the function in question
 467 @c evaluates to something less than or equal to @code{find_root_abs},
 468 @c or if successive approximants @var{x_0}, @var{x_1} differ by no more than
 469 @c @code{find_root_rel * max(abs(x_0), abs(x_1))}.  The default values of
 470 @c @code{find_root_abs} and @code{find_root_rel} are both zero.
 471
 472 Die Genauigkeit der Nullstellensuche wird von den Optionsvariablen
 473 @code{find_root_abs} und @code{find_root_rel} kontrolliert.  @code{find_root}
 474 endet, wenn die Auswertung der Funktion ein Ergebnis hat, das kleiner als
 475 @code{find_root_abs} ist oder wenn aufeinander folgende Auswertungen
 476 Ergebnisse @var{x_0} und @var{x_1} haben, die sich voneinander weniger als
 477 @code{find_root_rel * max(abs(x_0), abs(x_1))} unterscheiden.  Der Standardwert
 478 der Optionsvariablen @code{find_root_abs} und @code{find_root_rel} ist Null.
 479
 480 @c @code{find_root} expects the function in question to have a different sign at
 481 @c the endpoints of the search interval.  When the function evaluates to a
 482 @c number at both endpoints and these numbers have the same sign, the behavior
 483 @c of @code{find_root} is governed by @code{find_root_error}.
 484 @c When @code{find_root_error} is @code{true}, @code{find_root} prints an error
 485 @c message.  Otherwise @code{find_root} returns the value of
 486 @c @code{find_root_error}.  The default value of @code{find_root_error} is
 487 @c @code{true}.
 488
 489 @code{find_root} erwartet, dass die Funktion an den Endpunkten des Intervalls
 490 f@"ur die Nullstellensuche ein unterschiedliches Vorzeichen hat.  Hat die
 491 Funktion an den Endpunkten des Intervalls dasselbe Vorzeichen, wird das
 492 Verhalten der Funktion @code{find_root} von der Optionsvariablen
 493 @code{find_root_error} kontrolliert.  Hat @code{find_root_error} den Wert
 494 @code{true}, wird eine Fehlermeldung ausgegeben.  Ansonsten wird von
 495 @code{find_root} der Wert von @code{find_root_error} als Ergebnis
 496 zur@"uckgegeben.  Der Standardwert von @code{find_root_error} ist @code{true}.
 497
 498 @c If @var{f} evaluates to something other than a number at any step in the
 499 @c search algorithm, @code{find_root} returns a partially-evaluated
 500 @c @code{find_root} expression.
 501
 502 Kann die Funktion @var{f} bei der Nullstellensuche nicht zu einer Zahl
 503 ausgewertet werden, gibt @code{find_root} ein teilweise ausgewertetes Ergebnis
 504 zur@"uck.
 505
 506 @c The order of @var{a} and @var{b} is ignored; the region in which a root is
 507 @c sought is @math{[min(@var{a}, @var{b}), max(@var{a}, @var{b})]}.
 508
 509 Die Reihenfolge der Grenzen des Intervalls @var{a} und @var{b} wird ignoriert.
 510 @code{find_root} sucht die Nullstellen immer in dem Intervall
 511 @code{[min(@var{a}, @var{b}), max(@var{a}, @var{b})]}.
 512
 513 Beispiele:
 514
 515 @example
 516 (%i1) f(x) := sin(x) - x/2;
 517                                         x
 518 (%o1)                  f(x) := sin(x) - -
 519                                         2
 520 (%i2) find_root (sin(x) - x/2, x, 0.1, %pi);
 521 (%o2)                   1.895494267033981
 522 (%i3) find_root (sin(x) = x/2, x, 0.1, %pi);
 523 (%o3)                   1.895494267033981
 524 (%i4) find_root (f(x), x, 0.1, %pi);
 525 (%o4)                   1.895494267033981
 526 (%i5) find_root (f, 0.1, %pi);
 527 (%o5)                   1.895494267033981
 528 (%i6) find_root (exp(x) = y, x, 0, 100);
 529                             x
 530 (%o6)           find_root(%e  = y, x, 0.0, 100.0)
 531 (%i7) find_root (exp(x) = y, x, 0, 100), y = 10;
 532 (%o7)                   2.302585092994046
 533 (%i8) log (10.0);
 534 (%o8)                   2.302585092994046
 535 @end example
 536 @end deffn
 537
 538 @c -----------------------------------------------------------------------------
 539 @node Einf@"uhrung in Fourierreihen, Funktionen und Variablen f@"ur Fourierreihen, Funktionen und Variablen f@"ur die schnelle Fourier-Transformation, Fourier-Transformationen
 540 @section Einf@"uhrung in Fourierreihen
 541 @c -----------------------------------------------------------------------------
 542
 543 @c The @code{fourie} package comprises functions for the symbolic computation
 544 @c of Fourier series.
 545 @c There are functions in the @code{fourie} package to calculate Fourier
 546 @c integral coefficients and some functions for manipulation of expressions.
 547
 548 Das Paket @code{fourie} enth@"alt Funktionen f@"ur die symbolische Berechnungen
 549 von Fourierreihen.  Weiterhin enth@"alt das Paket Funktionen, um
 550 Fourierkoeffizienten zu berechnen und einige weitere Funktionen.
 551
 552 @c -----------------------------------------------------------------------------
 553 @node Funktionen und Variablen f@"ur Fourierreihen, , Einf@"uhrung in Fourierreihen, Fourier-Transformationen
 554 @section Funktionen und Variablen f@"ur Fourierreihen
 555 @c -----------------------------------------------------------------------------
 556
 557 @c REPHRASE
 558
 559 @c --- 28.05.2011 DK -----------------------------------------------------------
 560 @anchor{equalp}
 561 @deffn {Funktion} equalp (@var{x}, @var{y})
 562
 563 @c Returns @code{true} if @code{equal (@var{x}, @var{y})} otherwise @code{false}
 564 @c (doesn't give an error message like @code{equal (x, y)} would do in this
 565 @c case).
 566
 567 Gibt @code{true} zur@"uck, wenn @code{equal(@var{x}, @var{y})} das Ergebnis
 568 @code{true} hat.  Ansonsten ist das Ergebnis @code{false}.
 569 @end deffn
 570
 571 @c --- 28.05.2011 DK -----------------------------------------------------------
 572 @deffn  {Funktion} remfun (@var{f}, @var{expr})
 573 @deffnx {Funktion} remfun (@var{f}, @var{expr}, @var{x})
 574
 575 @c @code{remfun (@var{f}, @var{expr})} replaces all occurrences of
 576 @c @code{@var{f} (@var{arg})} by @var{arg} in @var{expr}.
 577
 578 @code{remfun(@var{f}, @var{expr}} ersetzt @code{@var{f}(@var{arg})} durch
 579 @var{arg} im Ausdruck @var{expr}.
 580
 581 @c @code{remfun (@var{f}, @var{expr}, @var{x})} replaces all occurrences of
 582 @c @code{@var{f} (@var{arg})} by @var{arg} in @var{expr} only if @var{arg}
 583 @c contains the variable @var{x}.
 584
 585 @code{remfun(@var{f}, @var{expr}, @var{x})} ersetzt @code{@var{f} (@var{arg})}
 586 durch @var{arg} im Ausdruck @var{expr} nur dann, wenn @var{arg} die Variable
 587 @var{x} enth@"alt.
 588 @end deffn
 589
 590 @c --- 28.05.2011 DK -----------------------------------------------------------
 591 @anchor{funp}
 592 @deffn  {Funktion} funp (@var{f}, @var{expr})
 593 @deffnx {Funktion} funp (@var{f}, @var{expr}, @var{x})
 594
 595 @c @code{funp (@var{f}, @var{expr})}
 596 @c returns @code{true} if @var{expr} contains the function @var{f}.
 597
 598 @code{funp(@var{f}, @var{expr})} hat das Ergebnis @code{true}, wenn der
 599 Ausdruck @var{expr} die Funktion @var{f} enth@"alt.
 600
 601 @c @code{funp (@var{f}, @var{expr}, @var{x})} returns @code{true} if @var{expr}
 602 @c contains the function @var{f} and the variable @var{x} is somewhere in the
 603 @c argument of one of the instances of @var{f}.
 604
 605 @code{funp(@var{f}, @var{expr}, @var{x})} hat das Ergebnis @code{true}, wenn
 606 der Ausdruck @var{expr} die Funktion @var{f} enthält und die Variable @var{x}
 607 ein Argument der Funktion @var{f} ist.
 608 @end deffn
 609
 610 @c --- 28.05.2011 DK -----------------------------------------------------------
 611 @anchor{absint}
 612 @deffn  {Funktion} absint (@var{f}, @var{x}, @var{halfplane})
 613 @deffnx {Funktion} absint (@var{f}, @var{x})
 614 @deffnx {Funktion} absint (@var{f}, @var{x}, @var{a}, @var{b})
 615
 616 @c @code{absint (@var{f}, @var{x}, @var{halfplane})}
 617 @c returns the indefinite integral of @var{f} with respect to
 618 @c @var{x} in the given halfplane (@code{pos}, @code{neg}, or @code{both}).
 619 @c @var{f} may contain expressions of the form
 620 @c @code{abs (x)}, @code{abs (sin (x))}, @code{abs(a) * exp (-abs(b) * abs(x))}.
 621
 622 @code{absint(@var{f}, @var{x}, @var{halfplane})} gibt das unbestimmte Integral
 623 der Funktion @var{f} f@"ur die Variable @var{x} zur@"uck.  Das Integral wird in
 624 der angegebenen Halbebene @code{pos}, @code{neg} oder f@"ur beide Halbebenen
 625 mit @code{both} berechnet.  Der Integrand kann die Betragsfunktion enthalten:
 626 @code{abs(x)}, @code{abs(sin(x))}, @code{abs(a) * exp(-abs(b) * abs(x))}.
 627
 628 @c @code{absint (@var{f}, @var{x})} is equivalent to
 629 @c @code{absint (@var{f}, @var{x}, pos)}.
 630
 631 @code{absint(@var{f}, @var{x})} ist @"aquivalent zu
 632 @code{absint(@var{f}, @var{x}, pos)}.
 633
 634 @c @code{absint (@var{f}, @var{x}, @var{a}, @var{b})} returns the definite
 635 @c integral of @var{f} with respect to @var{x} from @var{a} to @var{b}.
 636 @c SAME LIST AS ABOVE ??
 637 @c @var{f} may include absolute values.
 638
 639 @code{absint(@var{f}, @var{x}, @var{a}, @var{b})} gibt das bestimmte Integral
 640 der Funktion @var{f} f@"ur die Variable @var{x} in den Grenzen @var{a} und
 641 @var{b} zur@"uck.  Der Integrand kann die Betragsfunktion enthalten.
 642 @end deffn
 643
 644 @c --- 28.05.2011 DK -----------------------------------------------------------
 645 @anchor{fourier}
 646 @deffn {Funktion} fourier (@var{f}, @var{x}, @var{l})
 647
 648 Berechnet die Fourier-Koeffizienten @code{a[0]}, @code{a[n]} und @code{b[n]}
 649 der Funktion @code{@var{f}(@var{x})} f@"ur das Intervall @code{[-l, l]}.  Die
 650 Fourierreihe ist definiert als:
 651
 652 @example
 653          inf
 654          ====
 655          \             %pi n x           %pi n x
 656   f(x) =  >    (b  sin(-------) + a  cos(-------))
 657          /       n        l        n        l
 658          ====
 659          n = 0
 660 @end example
 661
 662 Die Koeffizienten der Fourierreihe werden folgenderma@ss{}en berechnet:
 663
 664 @example
 665                      l
 666                     /
 667                 - 1 [
 668       a  = 1/2 l    I    f(x) dx
 669        0            ]
 670                     /
 671                      - l
 672 @end example
 673
 674 @example
 675                  l
 676                 /
 677             - 1 [                  - 1
 678       a  = l    I    f(x) cos(%pi l    n x) dx
 679        n        ]
 680                 /
 681                  - l
 682 @end example
 683
 684 @example
 685                   l
 686                  /
 687             - 1 [                  - 1
 688       b  = l    I    f(x) sin(%pi l    n x) dx
 689        n        ]
 690                 /
 691                  - l
 692 @end example
 693
 694 @code{fourier} weist die Fourier-Koeffizienten Zwischenmarken zu.  Die
 695 Zwischenmarken werden als eine Liste zur@"uckgegeben.
 696
 697 Der Index der Summe ist immer das Symbol @var{n}.  Sinus- und Kosinusfunktionen
 698 mit ganzzahligen Vielfachen von @code{%pi} werden nicht automatisch vereinfacht.
 699 Dies kann mit der Funktion @mref{foursimp} erreicht werden, der als Argument
 700 die Liste der Fourier-Koeffizienten @"ubergeben wird.
 701
 702 Mit der Funktion @mref{fourexpand} kann die Fourierreihe aus den
 703 Fourier-Koeffizienten konstruiert werden.  Siehe auch die Funktion
 704 @mrefdot{totalfourier}
 705
 706 Mit den Funktionen @mref{fourcos} und @mref{foursin} werden jeweils die
 707 Koeffizienten der Kosinus- und Sinus-Entwicklung berechnet.
 708
 709 Beispiel:
 710
 711 @example
 712 (%i1) load("fourie")$
 713
 714 (%i2) fourier(x, x, 1);
 715 (%t2)                        a  = 0
 716                               0
 717
 718 (%t3)                        a  = 0
 719                               n
 720
 721                         sin(%pi n)   cos(%pi n)
 722 (%t4)           b  = 2 (---------- - ----------)
 723                  n          2  2       %pi n
 724                          %pi  n
 725
 726 (%o4)                    [%t2, %t3, %t4]
 727 (%i5) foursimp(%);
 728 (%t5)                        a  = 0
 729                               0
 730
 731 (%t6)                        a  = 0
 732                               n
 733
 734                                        n
 735                                 2 (- 1)
 736 (%t7)                    b  = - --------
 737                           n      %pi n
 738
 739 (%o7)                    [%t5, %t6, %t7]
 740 (%i8) fourexpand(%, x, 1, inf);
 741                       inf
 742                       ====       n
 743                       \     (- 1)  sin(%pi n x)
 744                     2  >    -------------------
 745                       /              n
 746                       ====
 747                       n = 1
 748 (%o8)             - ---------------------------
 749                                 %pi
 750 @end example
 751 @end deffn
 752
 753 @c --- 28.05.2011 DK -----------------------------------------------------------
 754 @anchor{foursimp}
 755 @deffn {Funktion} foursimp (@var{l})
 756
 757 @code{foursimp} wird auf das Ergebnis der Funktion @mref{fourier} angewendet,
 758 um Sinus- und Kosinus-Funktionen zu vereinfachen, die ganzzahlige Vielfache
 759 von @code{%pi} enthalten.  Das Argument @var{l} ist eine Liste mit den
 760 Koeffizienten der Fourierreihe, f@"ur die die Vereinfachung ausgef@"uhrt werden
 761 soll.
 762
 763 @code{sin(n %pi)} wird zu @code{0} vereinfacht, wenn die Optionsvariable
 764 @mref{sinnpiflag} den Wert @code{true} hat, und @code{cos(n %pi)} wird zu
 765 @code{(-1)^n}, wenn die Optionsvariable @mref{cosnpiflag} den Wert @code{true}
 766 hat.
 767
 768 Siehe die Funktion @mref{fourier} f@"ur ein Beispiel.
 769 @end deffn
 770
 771 @c --- 28.05.2011 DK -----------------------------------------------------------
 772 @anchor{sinnpiflag}
 773 @defvr {Optionsvariable} sinnpiflag
 774 Standardwert: @code{true}
 775
 776 Kontrolliert die Vereinfachung der Sinus-Funktion durch die Funktion
 777 @code{foursimp}.  Siehe die Funktion @mrefdot{foursimp}
 778 @end defvr
 779
 780 @c --- 28.05.2011 DK -----------------------------------------------------------
 781 @anchor{cosnpiflag}
 782 @defvr {Optionsvariable} cosnpiflag
 783 Standardwert: @code{true}
 784
 785 Kontrolliert die Vereinfachung der Kosinus-Funktion durch die Funktion
 786 @code{foursimp}.  Siehe die Funktion @mrefdot{foursimp}
 787 @end defvr
 788
 789 @c NEEDS EXPANSION.  EXPLAIN x AND p HERE (DO NOT REFER SOMEWHERE ELSE)
 790
 791 @c --- 28.05.2011 DK -----------------------------------------------------------
 792 @anchor{fourexpand}
 793 @deffn {Funktion} fourexpand (@var{l}, @var{x}, @var{p}, @var{limit})
 794
 795 Konstruiert aus der Liste der Fourier-Koeffizienten @var{l} eine Fourierreihe
 796 mit @var{limit} Termen.  Das Argument @var{limit} kann @code{inf} sein.  Die
 797 Argumente @var{x} und @var{p} haben dieselbe Bedeutung wie f@"ur die Funktion
 798 @mrefdot{fourier}
 799
 800 Siehe die Funktion @mref{fourier} f@"ur ein Beispiel.
 801 @end deffn
 802
 803 @c --- 28.05.2011 DK -----------------------------------------------------------
 804 @anchor{fourcos}
 805 @deffn {Funktion} fourcos (@var{f}, @var{x}, @var{p})
 806
 807 @c Returns the Fourier cosine coefficients for @code{@var{f}(@var{x})} defined
 808 @c on @code{[0, @var{p}]}.
 809
 810 Gibt die Kosinus-Koeffizienten einer Fourierreihe f@"ur die Funktion
 811 @code{@var{f}(@var{x})} zur@"uck, die auf dem Intervall @code{[0, @var{p}]}
 812 definiert ist.
 813 @end deffn
 814
 815 @c --- 28.05.2011 DK -----------------------------------------------------------
 816 @anchor{foursin}
 817 @deffn {Funktion} foursin (@var{f}, @var{x}, @var{p})
 818
 819 @c Returns the Fourier sine coefficients for @code{@var{f}(@var{x})} defined on
 820 @c @code{[0, @var{p}]}.
 821
 822 Gibt die Sinus-Koeffizienten einer Fourierreihe f@"ur die Funktion
 823 @code{@var{f}(@var{x})} zur@"uck, die auf dem Intervall @code{[0, @var{p}]}
 824 definiert ist.
 825 @end deffn
 826
 827 @c NEEDS EXPANSION
 828
 829 @c --- 28.05.2011 DK -----------------------------------------------------------
 830 @anchor{totalfourier}
 831 @deffn {Funktion} totalfourier (@var{f}, @var{x}, @var{l})
 832
 833 Gibt die Fourierreihe der Funktion @var{f(x)} f@"ur das Intervall
 834 @code{[@var{-l}, @var{l}]} zur@"uck.  Das Ergebnis wird berechnet, indem
 835 die nacheinander die Funktionen @mref{foursimp} und @mref{fourexpand} auf das
 836 Ergebnis der Funktion @mref{fourier} angewendet werden.
 837
 838 Beispiel:
 839
 840 @example
 841 (%i1) load("fourie")$
 842
 843 (%i2) totalfourier(x, x, 1);
 844 (%t2)                        a  = 0
 845                               0
 846
 847 (%t3)                        a  = 0
 848                               n
 849
 850                         sin(%pi n)   cos(%pi n)
 851 (%t4)           b  = 2 (---------- - ----------)
 852                  n          2  2       %pi n
 853                          %pi  n
 854
 855 (%t5)                        a  = 0
 856                               0
 857
 858 (%t6)                        a  = 0
 859                               n
 860 @group
 861                                        n
 862                                 2 (- 1)
 863 (%t7)                    b  = - --------
 864                           n      %pi n
 865 @end group
 866 @group
 867                       inf
 868                       ====       n
 869                       \     (- 1)  sin(%pi n x)
 870                     2  >    -------------------
 871                       /              n
 872                       ====
 873                       n = 1
 874 (%o7)             - ---------------------------
 875                                 %pi
 876 @end group
 877 @end example
 878
 879 @end deffn
 880
 881 @c NEEDS EXPANSION
 882
 883 @c --- 28.05.2011 DK -----------------------------------------------------------
 884 @anchor{fourint}
 885 @deffn {Funktion} fourint (@var{f}, @var{x})
 886
 887 @c Constructs and returns a list of the Fourier integral coefficients of
 888 @c @code{@var{f}(@var{x})} defined on @code{[minf, inf]}.
 889
 890 Konstruiert eine Liste der Fourierintegral-Koeffizienten der Funktion
 891 @code{@var{f}(@var{x})}, die auf dem Intervall @code{[minf, inf]} definiert ist.
 892 @end deffn
 893
 894 @c NEEDS EXPANSION
 895
 896 @c --- 28.05.2011 DK -----------------------------------------------------------
 897 @anchor{fourintcos}
 898 @deffn {Funktion} fourintcos (@var{f}, @var{x})
 899
 900 @c Returns the Fourier cosine integral coefficients for @code{@var{f}(@var{x})}
 901 @c on @code{[0, inf]}.
 902
 903 Gibt die Koeffizienten des Kosinus-Fourierintegrals der Funktion
 904 @code{@var{f}(@var{x})} zur@"uck, die auf dem Intervall @code{[0, inf]}
 905 definiert ist.
 906
 907 @end deffn
 908
 909 @c NEEDS EXPANSION
 910
 911 @c --- 28.05.2011 DK -----------------------------------------------------------
 912 @anchor{fourintsin}
 913 @deffn {Funktion} fourintsin (@var{f}, @var{x})
 914
 915 @c Returns the Fourier sine integral coefficients for @code{@var{f}(@var{x})}
 916 @c on @code{[0, inf]}.
 917
 918 Gibt die Koeffizienten des Sinus-Fourierintegrals der Funktion
 919 @code{@var{f}(@var{x})} zur@"uck, die auf dem Intervall @code{[0, inf]}
 920 definiert ist.
 921 @end deffn
 922
 923 @c --- End of Numerical.de.texi ------------------------------------------------
 924