doc/info/de/MathFunctions.de.texi

   1 @c -----------------------------------------------------------------------------
   2 @c File        : MathFunctions.de.texi
   3 @c License     : GNU General Public License (GPL)
   4 @c Language    : German
   5 @c Original    : New file
   6 @c Translation : Dr. Dieter Kaiser
   7 @c Date        : 19.10.2010
   8 @c Revision    : 01.11.2011
   9 @c
  10 @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
  11 @c -----------------------------------------------------------------------------
  12
  13 @menu
  14 * Funktionen f@"ur Zahlen::
  15 * Funktionen f@"ur komplexe Zahlen::
  16 * Funktionen der Kombinatorik::
  17 * Wurzel- Exponential- und Logarithmusfunktion::
  18 * Winkelfunktionen::
  19 * Hyperbelfunktionen::
  20 * Zufallszahlen::
  21 @end menu
  22
  23 @c -----------------------------------------------------------------------------
  24 @node Funktionen f@"ur Zahlen, Funktionen f@"ur komplexe Zahlen, Mathematische Funktionen, Mathematische Funktionen
  25 @section Funktionen f@"ur Zahlen
  26 @c -----------------------------------------------------------------------------
  27
  28 @c --- 20.02.2011 DK -----------------------------------------------------------
  29 @anchor{abs}
  30 @deffn {Funktion} abs (@var{z})
  31
  32 Die Funktion @code{abs} ist die Betragsfunktion und f@"ur das numerische und
  33 symbolische Rechnen geeignet.  Ist das Argument @var{z} eine reelle oder
  34 komplexe Zahl wird der Betrag berechnet.  Wenn m@"oglich werden allgemeine
  35 Ausdr@"ucke mit der Betragsfunktion vereinfacht.  Maxima kann Ausdr@"ucke mit
  36 der Betragsfunktion integrieren und ableiten sowie Grenzwerte von Ausdr@"ucken
  37 mit der Betragsfunktion ermitteln.  Das Paket @mref{abs_integrate} erweitert
  38 Maximas M@"oglichkeiten, Integrale mit der Betragsfunktion zu l@"osen.
  39
  40 Die Betragsfunktion wird automatisch auf die Elemente von Listen und Matrizen
  41 sowie auf die beiden Seiten von Gleichungen angewendet.  Siehe
  42 @mrefdot{distribute_over}
  43
  44 Siehe die Funktion @mrefcomma{cabs} um den Betrag eines komplexen Ausdrucks
  45 oder einer Funktion zu berechnen.
  46
  47 Beispiele:
  48
  49 Berechnung des Betrages f@"ur reelle und komplexen Zahlen sowie numerische
  50 Konstanten und unendliche Gr@"o@ss{}en.  Das erste Beispiel zeigt, wie die
  51 Betragsfunktion von Maxima auf die Elemente einer Liste angewendet wird.
  52
  53 @example
  54 (%i1) abs([-4, 0, 1, 1+%i]);
  55 (%o1)                  [4, 0, 1, sqrt(2)]
  56
  57 (%i2) abs((1+%i)*(1-%i));
  58 (%o2)                           2
  59 (%i3) abs(%e+%i);
  60                                 2
  61 (%o3)                    sqrt(%e  + 1)
  62 (%i4) abs([inf, infinity, minf]);
  63 (%o4)                   [inf, inf, inf]
  64 @end example
  65
  66 Vereinfachung von Ausdr@"ucken mit der Betragsfunktion.
  67
  68 @example
  69 (%i5) abs(x^2);
  70                                 2
  71 (%o5)                          x
  72 (%i6) abs(x^3);
  73                              2
  74 (%o6)                       x  abs(x)
  75
  76 (%i7) abs(abs(x));
  77 (%o7)                       abs(x)
  78 (%i8) abs(conjugate(x));
  79 (%o8)                       abs(x)
  80 @end example
  81
  82 Ableitung und Integrale mit der Betragsfunktion.  Wird das Paket
  83 @nref{abs_integrate} geladen, k@"onnen weitere Integrale mit der Betragsfunktion
  84 gel@"ost werden.  Das letzte Beispiel zeigt die Laplacetransformation der
  85 Betragsfunktion.  Siehe @mrefdot{laplace}
  86
  87 @example
  88 (%i9) diff(x*abs(x),x),expand;
  89 (%o9)                       2 abs(x)
  90
  91 (%i10) integrate(abs(x),x);
  92                              x abs(x)
  93 (%o10)                       --------
  94                                 2
  95
  96 (%i11) integrate(x*abs(x),x);
  97                            /
  98                            [
  99 (%o11)                     I x abs(x) dx
 100                            ]
 101                            /
 102
 103 (%i12) load("abs_integrate")$
 104 (%i13) integrate(x*abs(x),x);
 105                       2           3
 106                      x  abs(x)   x  signum(x)
 107 (%o13)               --------- - ------------
 108                          2            6
 109
 110 (%i14) integrate(abs(x),x,-2,%pi);
 111                                2
 112                             %pi
 113 (%o14)                      ---- + 2
 114                              2
 115
 116 (%i15) laplace(abs(x),x,s);
 117                                1
 118 (%o15)                         --
 119                                 2
 120                                s
 121 @end example
 122 @end deffn
 123
 124 @c --- 20.02.2011 DK -----------------------------------------------------------
 125 @anchor{ceiling}
 126 @deffn {Funktion} ceiling (@var{x})
 127
 128 Die Funktion @code{ceiling} ist f@"ur das numerische und symbolische Rechnen
 129 geeignet.
 130
 131 Ist das Argument @var{x} eine reelle Zahl, gibt @code{ceiling} die kleinste
 132 ganze Zahl zur@"uck, die gr@"o@ss{}er oder gleich @var{x} ist.
 133
 134 Die Funktion @code{ceiling} gibt auch dann einen numerischen Wert zur@"uck, wenn
 135 das Argument ein konstanter Ausdruck ist, wie zum Beispiel @code{1+%e}, der zu
 136 einer reellen Zahl ausgewertet werden kann.  In diesem Fall wird der konstante
 137 Ausdruck in eine gro@ss{}e Gleitkommazahl umgewandelt, auf die die Funktion
 138 @code{ceiling} angewendet wird.  Aufgrund von Rundungsfehlern bei der Umwandlung
 139 in Gleitkommazahlen kann es zu Fehlern bei der Berechnung von @code{ceiling}
 140 kommen.  Um diese zu minimieren, wird die Anzahl der Stellen
 141 @mref{fpprec} f@"ur die Berechnung von @code{ceiling} um drei Stellen erh@"oht.
 142
 143 Ist das Argument @var{expr} der Funktion ein komplexer Ausdruck, wird eine
 144 Substantivform zur@"uckgegeben.
 145
 146 Wenn m@"oglich werden Ausdr@"ucke mit der Funktion @code{ceiling} von Maxima
 147 vereinfacht.  Maxima kennt insbesondere Vereinfachungen f@"ur den Fall, dass
 148 das Argument der Funktion @code{ceiling} ein Ausdruck mit den Funktionen
 149 @mref{floor} oder @mref{round} ist.  Weiterhin werden f@"ur die Vereinfachung
 150 die Aussagen und Fakten der aktiven Kontexte herangezogen.  Siehe
 151 @ref{Funktionen und Variablen f@"ur Fakten}.
 152
 153 @code{ceiling} wird automatisch auf die Elemente von Listen und Matrizen
 154 sowie auf die beiden Seiten von Gleichungen angewendet.  Siehe
 155 @mrefdot{distribute_over}
 156
 157 Siehe auch die Funktionen @mref{floor} und @mrefdot{round}
 158
 159 Beispiele:
 160
 161 @example
 162 (%i1) ceiling(ceiling(x));
 163 (%o1)                      ceiling(x)
 164 (%i2) ceiling(floor(x));
 165 (%o2)                       floor(x)
 166 (%i3) declare (n, integer)$
 167 (%i4) ceiling([n, abs(n), max (n, 6)]);
 168 (%o4)               [n, abs(n), max(6, n)]
 169 (%i5) assume (x > 0, x < 1)$
 170 (%i6) ceiling (x);
 171 (%o6)                           1
 172 @end example
 173
 174 Sind die Werte einer Funktion eine Teilmenge der ganzen Zahlen, kann diese als
 175 @mref{integervalued} deklariert werden.  Die Funktionen @code{ceiling} und
 176 @mref{floor} k@"onnen diese Information nutzen, um Ausdr@"ucke zu vereinfachen.
 177
 178 @example
 179 (%i1) declare (f, integervalued)$
 180 (%i2) floor (f(x));
 181 (%o2)                         f(x)
 182 (%i3) ceiling (f(x) - 1);
 183 (%o3)                       f(x) - 1
 184 @end example
 185
 186 Maxima kennt das Integral der Funktion @code{ceiling}.
 187
 188 @example
 189 (%i1) integrate(ceiling(x),x);
 190                (- ceiling(x) + 2 x + 1) ceiling(x)
 191 (%o1)          -----------------------------------
 192                                 2
 193 @end example
 194 @end deffn
 195
 196 @c --- 19.10.2010 DK -----------------------------------------------------------
 197 @anchor{entier}
 198 @deffn {Funktion} entier (@var{x})
 199
 200 @code{entier} ist eine andere Bezeichnung f@"ur die Funktion @code{floor}.
 201 Siehe @mrefdot{floor}
 202 @end deffn
 203
 204 @c --- 20.02.2011 DK -----------------------------------------------------------
 205 @anchor{floor}
 206 @deffn {Funktion} floor (@var{x})
 207
 208 Die Funktion @code{floor} ist f@"ur das numerische und symbolische Rechnen
 209 geeignet.
 210
 211 Ist das Argument @var{x} eine reelle Zahl, gibt @code{floor} die gr@"o@ss{}te
 212 ganze Zahl zur@"uck, die kleiner oder gleich @var{x} ist.
 213
 214 Die Funktion @code{floor} gibt auch dann einen numerischen Wert zur@"uck, wenn
 215 das Argument ein konstanter Ausdruck ist, wie zum Beispiel @code{1+%e}, der zu
 216 einer reellen Zahl ausgewertet werden kann.  In diesem Fall wird der konstante
 217 Ausdruck in eine gro@ss{}e Gleitkommazahl umgewandelt, auf die die Funktion
 218 @code{floor} angewendet wird.  Aufgrund von Rundungsfehlern bei der Umwandlung
 219 in Gleitkommazahlen kann es zu Fehlern bei der Berechnung von @code{floor}
 220 kommen.  Um diese zu minimieren, wird die Anzahl der Stellen
 221 @mref{fpprec} f@"ur die Berechnung von @code{floor} um drei Stellen erh@"oht.
 222
 223 Ist das Argument @var{x} der Funktion ein komplexer Ausdruck, wird eine
 224 Substantivform zur@"uckgegeben.
 225
 226 Wenn m@"oglich werden Ausdr@"ucke mit der Funktion @code{floor} von Maxima
 227 vereinfacht.  Maxima kennt insbesondere Vereinfachungen f@"ur den Fall, dass
 228 das Argument der Funktion @code{floor} ein Ausdruck mit den Funktionen
 229 @mref{ceiling} oder @mref{round} ist.  Weiterhin werden f@"ur die Vereinfachung
 230 die Aussagen und Fakten der aktiven Kontexte herangezogen.  Siehe
 231 @ref{Funktionen und Variablen f@"ur Fakten}.
 232
 233 @code{floor} wird automatisch auf die Elemente von Listen und Matrizen
 234 sowie auf die beiden Seiten von Gleichungen angewendet.  Siehe
 235 @mrefdot{distribute_over}
 236
 237 Siehe auch die Funktionen @mref{ceiling} und @mrefdot{round}
 238
 239 Beispiele:
 240
 241 @example
 242 (%i1) floor(ceiling(x));
 243 (%o1)                      ceiling(x)
 244 (%i2) floor(floor(x));
 245 (%o2)                       floor(x)
 246 (%i3) declare(n, integer);
 247 (%o3)                         done
 248 (%i4) floor([n, abs(n), min (n, 6)]);
 249 (%o4)                [n, abs(n), min(6, n)]
 250 (%i5) assume(x>0, x<1)$
 251 (%i6) floor(x);
 252 (%o6)                           0
 253 @end example
 254
 255 Sind die Werte einer Funktion eine Teilmenge der ganzen Zahlen, kann diese als
 256 @mref{integervalued} deklariert werden.  Die Funktionen @mref{ceiling} und
 257 @code{floor} k@"onnen diese Information nutzen, um Ausdr@"ucke zu vereinfachen.
 258
 259 @example
 260 (%i1) declare (f, integervalued)$
 261 (%i2) floor(f(x));
 262 (%o2)                         f(x)
 263 (%i3) ceiling(f(x) - 1);
 264 (%o3)                       f(x) - 1
 265 @end example
 266
 267 Maxima kennt das Integral der Funktion @code{floor}.
 268
 269 @example
 270 (%i6) integrate(floor(x),x);
 271                  (- floor(x) + 2 x - 1) floor(x)
 272 (%o6)            -------------------------------
 273                                 2
 274 @end example
 275 @end deffn
 276
 277 @c --- 19.10.2010 DK -----------------------------------------------------------
 278 @anchor{fix}
 279 @deffn {Funktion} fix (@var{x})
 280
 281 @code{fix} ist eine andere Bezeichnung f@"ur die Funktion @code{floor}.  Siehe
 282 @mrefdot{floor}
 283 @end deffn
 284
 285 @c --- 22.02.2011 DK -----------------------------------------------------------
 286 @anchor{lmax}
 287 @deffn {Funktion} lmax (@var{L})
 288
 289 Ist das Argument @var{L} eine Liste oder Menge, wird die Funktion @mref{max} auf
 290 die Elemente der Liste oder Menge angewendet und das Ergebnis zur@"uckgegeben.
 291 Ist @var{L} keine Liste oder Menge, signalisiert Maxima einen Fehler.
 292
 293 @need 600
 294 Beispiel:
 295
 296 @example
 297 (%i1) L:[1+%e, %pi, 3];
 298 (%o1)                   [%e + 1, %pi, 3]
 299 (%i1) lmax(L);
 300 (%o1)                        %e + 1
 301 @end example
 302 @end deffn
 303
 304 @c --- 22.02.2011 DK -----------------------------------------------------------
 305 @anchor{lmin}
 306 @deffn {Funktion} lmin (@var{L})
 307
 308 Ist das Argument @var{L} eine Liste oder Menge, wird die Funktion @mref{min} auf
 309 die Elemente der Liste oder Menge angewendet und das Ergebnis zur@"uckgegeben.
 310 Ist @var{L} keine Liste oder Menge, signalisiert Maxima einen Fehler.
 311
 312 Beispiel:
 313
 314 @example
 315 (%i1) L:[1+%e, %pi, 3];
 316 (%o1)                   [%e + 1, %pi, 3]
 317 (%i2) lmin(L);
 318 (%o2)                           3
 319 @end example
 320 @end deffn
 321
 322 @c --- 22.02.2011 DK -----------------------------------------------------------
 323 @anchor{max}
 324 @deffn {Funktion} max (@var{x_1}, @dots{}, @var{x_n})
 325
 326 Sind alle Argumente @var{x_1}, @dots{}, @var{x_n} Zahlen oder konstante
 327 Ausdr@"ucke wie zum Beispiel @code{1+%e} oder @code{sin(1)}, dann wird der
 328 gr@"o@ss{}te Zahlenwert zur@"uckgegeben.  Sind symbolische Variablen oder
 329 allgemeine Ausdr@"ucke unter den Argumenten, gibt Maxima einen vereinfachten
 330 Ausdruck zur@"uck.  Die unendliche Gr@"o@ss{}en @mref{inf} und @mref{minf}@w{}
 331 k@"onnen als Argument auftreten.
 332
 333 Die Vereinfachung der Funktion @code{max} kann kontrolliert werden, in dem mit
 334 der Funktion @mref{put} dem Symbol @code{trylevel} zu der Eigenschaft
 335 @code{maxmin} ein Wert zwischen 1 bis 3 gegeben wird.  Folgende Werte k@"onnen
 336 mit der Funktion @code{put} gesetzt werden:
 337
 338 @table @code
 339 @item put(trylevel, 1, maxmin)
 340 @code{trylevel} hat den Wert 1.  Das ist der Standardwert.  Maxima f@"uhrt
 341 keine besonderen Vereinfachungen aus.
 342 @item put(trylevel, 2, maxmin)
 343 Maxima wendet die Vereinfachung @code{max(e,-e) --> |e|} an.
 344 @item put(trylevel, 3, maxima)
 345 Maxima wendet die Vereinfachung @code{max(e,-e) --> |e|} an und versucht
 346 Ausdr@"ucke zu eliminieren, die zwischen zwei anderen Argumenten liegen.  So
 347 wird zum Beispiel @code{max(x, 2*x, 3*x)} zu @code{max(x, 3*x)} vereinfacht.
 348 @end table
 349
 350 Mit dem Kommando @code{get(trylevel, maxmin)} wird der aktuelle Wert f@"ur
 351 das Symbol @code{trylevel} angezeigt.  Siehe die Funktion @mrefdot{get}
 352
 353 @code{max} ber@"ucksichtigt bei der Vereinfachung von Ausdr@"ucken die
 354 Aussagen und Fakten der aktiven Kontexte.  Siehe das Kapitel
 355 @ref{Funktionen und Variablen f@"ur Fakten}.
 356
 357 Beispiele:
 358
 359 @example
 360 (%i1) max(1.6, 3/2, 1);
 361 (%o1)                          1.6
 362 (%i2) max(1.5b0,1.5,3/2);
 363 @group
 364                                 3
 365 (%o2)                           -
 366                                 2
 367 @end group
 368 (%i3) max(%e,%pi,1,2,3);
 369 (%o3)                          %pi
 370 (%i4) max(1+%e,%pi,1,2,3);
 371 (%o4)                        %e + 1
 372 (%i5) max(minf,inf);
 373 (%o5)                          inf
 374 (%i6) assume(a>b);
 375 (%o6)                        [a > b]
 376 (%i7) max(a,b);
 377 (%o7)                           a
 378 @end example
 379 @end deffn
 380
 381 @c --- 22.02.2011 DK -----------------------------------------------------------
 382 @anchor{min}
 383 @deffn {Funktion} min (@var{x_1}, @dots{}, @var{x_n})
 384
 385 Sind alle Argumente @var{x_1}, @dots{}, @var{x_n} Zahlen oder konstante
 386 Ausdr@"ucke wie zum Beispiel @code{1+%e} oder @code{sin(1)}, dann wird der
 387 kleinste Zahlenwert zur@"uckgegeben.  Sind symbolische Variablen oder
 388 allgemeine Ausdr@"ucke unter den Argumenten, gibt Maxima einen vereinfachten
 389 Ausdruck zur@"uck.  Die unendliche Gr@"o@ss{}en @mref{inf} und @mref{minf}@w{}
 390 k@"onnen als Argument auftreten.
 391
 392 Die Vereinfachung der Funktion @code{min} kann kontrolliert werden, in dem mit
 393 der Funktion @mref{put} dem Symbol @code{trylevel} zu der Eigenschaft
 394 @code{maxmin} ein Wert zwischen 1 bis 3 gegeben wird.  Folgende Werte k@"onnen
 395 mit der Funktion @code{put} gesetzt werden:
 396
 397 @table @code
 398 @item put(trylevel, 1, maxmin)
 399 @code{trylevel} hat den Wert 1.  Das ist der Standardwert.  Maxima f@"uhrt
 400 keine besonderen Vereinfachungen aus.
 401 @item put(trylevel, 2, maxmin)
 402 Maxima wendet die Vereinfachung @code{min(e,-e) --> |e|} an.
 403 @item put(trylevel, 3, maxima)
 404 Maxima wendet die Vereinfachung @code{min(e,-e) --> |e|} an und versucht
 405 Ausdr@"ucke zu eliminieren, die zwischen zwei anderen Argumenten liegen.  So
 406 wird zum Beispiel @code{min(x, 2*x, 3*x)} zu @code{min(x, 3*x)} vereinfacht.
 407 @end table
 408
 409 Mit dem Kommando @code{get(trylevel, maxmin)} wird der aktuelle Wert f@"ur
 410 das Symbol @code{trylevel} angezeigt.  Siehe die Funktion @mrefdot{get}
 411
 412 @code{min} ber@"ucksichtigt bei der Vereinfachung von Ausdr@"ucken die
 413 Aussagen und Fakten der aktiven Kontexte.  Siehe das Kapitel
 414 @nrefdot{Funktionen und Variablen f@"ur Fakten}
 415
 416 Beispiele:
 417
 418 @example
 419 (%i1) min(1.6, 3/2, 1);
 420 (%o1)                           1
 421 (%i2) min(1.5b0,1.5,3/2);
 422                                 3
 423 (%o2)                           -
 424                                 2
 425 (%i3) min(%e,%pi,3);
 426 (%o3)                          %e
 427 (%i4) min(1+%e,%pi,3);
 428 (%o4)                           3
 429 (%i5) min(minf,inf);
 430 (%o5)                         minf
 431 (%i6) assume(a>b);
 432 (%o6)                        [a > b]
 433 (%i7) min(a,b);
 434 (%o7)                           b
 435 @end example
 436 @end deffn
 437
 438 @c --- 20.02.2011 DK -----------------------------------------------------------
 439 @anchor{round}
 440 @deffn {Funktion} round (@var{x})
 441
 442 Die Funktion @code{round} ist f@"ur das numerische und symbolische Rechnen
 443 geeignet.
 444
 445 Ist das Argument @var{x} eine reelle Zahl, gibt @code{round} die am
 446 n@"achsten liegende ganze Zahl zur@"uck.  Vielfache von 1/2 werden auf die
 447 n@"achste gerade ganze Zahl gerundet.
 448
 449 Die Funktion @code{round} gibt auch dann einen numerischen Wert zur@"uck, wenn
 450 das Argument ein konstanter Ausdruck ist, wie zum Beispiel @code{1+%e}, der zu
 451 einer reellen Zahl ausgewertet werden kann.  In diesem Fall wird der konstante
 452 Ausdruck in eine gro@ss{}e Gleitkommazahl umgewandelt, auf die die Funktion
 453 @code{round} angewendet wird.  Aufgrund von Rundungsfehlern bei der Umwandlung
 454 in Gleitkommazahlen kann es zu Fehlern bei der Berechnung von @code{round}
 455 kommen.  Um diese zu minimieren, wird die Anzahl der Stellen
 456 @mref{fpprec} f@"ur die Berechnung von @code{round} um drei Stellen erh@"oht.
 457
 458 Ist das Argument @var{x} der Funktion ein komplexer Ausdruck, wird eine
 459 Substantivform zur@"uckgegeben.
 460
 461 Wenn m@"oglich werden Ausdr@"ucke mit der Funktion @code{round} von Maxima
 462 vereinfacht.  Maxima kennt insbesondere Vereinfachungen f@"ur den Fall, dass
 463 das Argument der Funktion @code{round} ein Ausdruck mit den Funktionen
 464 @mref{ceiling} oder @mref{floor} ist.  Weiterhin werden f@"ur die Vereinfachung
 465 die Aussagen und Fakten der aktiven Kontexte herangezogen.  Siehe
 466 @ref{Funktionen und Variablen f@"ur Fakten}.
 467
 468 @code{round} wird automatisch auf die Elemente von Listen und Matrizen
 469 sowie auf die beiden Seiten von Gleichungen angewendet.  Siehe
 470 @mrefdot{distribute_over}
 471
 472 Siehe auch die Funktionen @mref{ceiling} und @mrefdot{floor}
 473
 474 Beispiele:
 475
 476 @example
 477 (%i1) round(floor(x));
 478 (%o1)                       floor(x)
 479 (%i2) round(round(x));
 480 (%o2)                       round(x)
 481 (%i3) declare(n, integer);
 482 (%o3)                         done
 483 (%i4) round([n, abs(n), min(n,6)]);
 484 (%o4)                [n, abs(n), min(6, n)]
 485 @end example
 486
 487 Sind die Werte einer Funktion eine Teilmenge der ganzen Zahlen, kann diese als
 488 @mref{integervalued} deklariert werden.  Die Funktion @code{round} kann diese
 489 Information nutzen, um Ausdr@"ucke zu vereinfachen.
 490
 491 @example
 492 (%i1) declare(f, integervalued);
 493 (%o1)                         done
 494 (%i2) round(f(x));
 495 (%o2)                         f(x)
 496 (%i3) round(f(x) - 1);
 497 (%o3)                       f(x) - 1
 498 @end example
 499 @end deffn
 500
 501 @c --- 22.02.2011 DK -----------------------------------------------------------
 502 @anchor{signum}
 503 @deffn {Funktion} signum (@var{z})
 504
 505 Die Signumfunktion @code{signum} ist f@"ur das numerische und symbolische
 506 Rechnen geeignet.  Ist das Argument @var{z} eine Zahl, ist das Ergebnis 0, 1
 507 oder -1, wenn die Zahl Null, positiv oder negativ ist.  Das Argument kann auch
 508 ein konstanter Ausdruck wie @code{%pi} oder @code{1+%e} sein.  Ist das Argument
 509 @var{z} eine komplexe Zahl, vereinfacht die der Ausdruck @code{signum(z)} zu
 510 @code{z/abs(z)}.
 511
 512 Ist das Argument @var{z} keine Zahl oder kein konstanter Ausdruck, versucht
 513 Maxima den Ausdruck zu vereinfachen.  Maxima kann die Funktion @code{signum}
 514 differenzieren.  Wird das Paket @nref{abs_integrate} geladen, kann Maxima
 515 Integrale mit der Funktion @code{signum} l@"osen.
 516
 517 @code{signum} wird automatisch auf die Elemente von Listen und Matrizen
 518 sowie auf die beiden Seiten von Gleichungen angewendet.  Siehe
 519 @mrefdot{distribute_over}
 520
 521 Beispiele:
 522
 523 Ergebnisse f@"ur verschiedene Zahlen und konstante Ausdr@"ucke.  Die Beispiele
 524 zeigen, dass das Ergebnis der Signumfunktion den Typ der Zahl erh@"alt.  Die
 525 unendlichen Gr@"o@ss{}en @mref{minf} und @mref{inf} k@"onnen als Argument
 526 auftreten.
 527
 528 @example
 529 (%i1) signum([-1.5, 0, 0.0, 1.5, 1.5b0, %e, sin(1), cos(4)]);
 530 (%o1)        [- 1.0, 0, 0.0, 1.0, 1.0b0, 1, 1, - 1]
 531 (%i2) signum(1+%i);
 532                           %i         1
 533 (%o2)                   ------- + -------
 534                         sqrt(2)   sqrt(2)
 535 (%i3) signum([minf,inf]);
 536 (%o3)                      [- 1, 1]
 537 @end example
 538
 539 Vereinfachungen der Signumfunktion.
 540
 541 @example
 542 (%i3) signum(x*y);
 543 (%o3)                  signum(x) signum(y)
 544 (%i4) signum(-x);
 545 (%o4)                      - signum(x)
 546 @end example
 547
 548 Wird das Paket @nref{abs_integrate} geladen, kann Maxima Integrale mit der
 549 Signumfunktion l@"osen.  Ausdr@"ucke mit der Signumfunktion k@"onnen
 550 differenziert werden.
 551
 552 @example
 553 (%i5) load("abs_integrate")$
 554
 555 (%i6) integrate(signum(x),x);
 556 (%o6)                        abs(x)
 557
 558 (%i7) integrate(sin(x)*signum(x),x);
 559 (%o7)               (1 - cos(x)) signum(x)
 560
 561 (%i7) diff(%,x);
 562 (%o7)                  signum(x) sin(x)
 563 @end example
 564 @end deffn
 565
 566 @c -----------------------------------------------------------------------------
 567 @node Funktionen f@"ur komplexe Zahlen, Funktionen der Kombinatorik, Funktionen f@"ur Zahlen, Mathematische Funktionen
 568 @section Funktionen f@"ur komplexe Zahlen
 569 @c -----------------------------------------------------------------------------
 570
 571 @c --- 20.02.2011 DK -----------------------------------------------------------
 572 @anchor{cabs}
 573 @deffn {Funktion} cabs (@var{expr})
 574
 575 Berechnet den Betrag eines komplexen Ausdrucks @var{expr}.  Im Unterschied
 576 zu der Funktion @mrefcomma{abs} zerlegt die Funktion @code{cabs} einen komplexen
 577 Ausdruck immer in einen Realteil und Imagin@"arteil, um den komplexen Betrag zu
 578 berechnen.  Sind @var{x} und @var{y} zwei reelle Variablen oder Ausdr@"ucke,
 579 berechnet die Funktion @code{cabs} den Betrag des komplexen Ausdrucks
 580 @code{x + %i*y} als:
 581 @example
 582                            2    2
 583                      sqrt(y  + x )
 584 @end example
 585
 586 Die Funktion @code{cabs} nutzt Symmetrieeigenschaften und implementierte
 587 Eigenschaften komplexer Funktionen, um den Betrag eines Ausdrucks zu berechnen.
 588 Sind solche Eigenschaften f@"ur eine Funktion vorhanden, k@"onnen diese mit der
 589 Funktion @mref{properties} angezeigt werden.  Eigenschaften, die das Ergebnis
 590 der Funktion @code{cabs} bestimmen, sind: @code{mirror symmetry},
 591 @code{conjugate function} und @code{complex characteristic}.
 592
 593 @code{cabs} ist eine Verbfunktion, die nicht f@"ur das symbolische Rechnen
 594 geeignet ist.  F@"ur das symbolische Rechnen wie der Integration oder der
 595 Ableitung von Ausdr@"ucken mit der Betragsfunktion muss die Funktion @code{abs}
 596 verwendet werden.
 597
 598 Das Ergebnis der Funktion @code{cabs} kann die Betragsfunktion @mref{abs} und
 599 den Arkustangens @mref{atan2} enthalten.
 600
 601 @code{cabs} wird automatisch auf die Elemente von Listen und Matrizen sowie auf
 602 die beiden Seiten von Gleichungen angewendet.
 603
 604 Siehe auch die Funktionen @mrefcomma{rectform} @mrefcomma{realpart}@w{}
 605 @mrefcomma{imagpart} @mrefcomma{carg} @mrefcomma{conjugate} und
 606 @mref{polarform} f@"ur das Rechnen mit komplexen Zahlen.
 607
 608 Beispiele:
 609
 610 Zwei Beispiele mit der Wurzelfunktion @mref{sqrt} und der Sinusfunktion
 611 @mrefdot{sin}
 612
 613 @example
 614 (%i1) cabs(sqrt(1+%i*x));
 615                              2     1/4
 616 (%o1)                      (x  + 1)
 617 (%i2) cabs(sin(x+%i*y));
 618                     2        2         2        2
 619 (%o2)       sqrt(cos (x) sinh (y) + sin (x) cosh (y))
 620 @end example
 621
 622 Die Funktion @mref{erf} hat Spiegelsymmetrie, die hier f@"ur die Berechnung des
 623 komplexen Betrages angewendet wird.
 624
 625 @example
 626 (%i3) cabs(erf(x+%i*y));
 627 @group
 628                                           2
 629            (erf(%i y + x) - erf(%i y - x))
 630 (%o3) sqrt(--------------------------------
 631                           4
 632                                                                2
 633                                 (erf(%i y + x) + erf(%i y - x))
 634                               - --------------------------------)
 635                                                4
 636 @end group
 637 @end example
 638
 639 Maxima kennt komplexe Eigenschaften der Besselfunktionen, um den komplexen
 640 Betrag zu vereinfachen.  Dies ist ein Beispiel f@"ur die Besselfunktion
 641 @mrefdot{bessel_j}
 642
 643 @example
 644 (%i4) cabs(bessel_j(1,%i));
 645 (%o4)                 abs(bessel_j(1, %i))
 646 @end example
 647 @end deffn
 648
 649 @c --- 20.02.2011 DK -----------------------------------------------------------
 650 @anchor{carg}
 651 @deffn {Funktion} carg (@var{expr})
 652
 653 Gibt das komplexe Argument des Ausdrucks @var{expr} zur@"uck.  Das komplexe
 654 Argument ist ein Winkel @code{theta} im Intervall @code{(-%pi, %pi)} derart,
 655 dass @var{expr} = @code{r exp (theta %i)} gilt, wobei @code{r} den Betrag des
 656 komplexen Ausdrucks @var{expr} bezeichnet.  Das ist die Polarform des Ausdrucks,
 657 wie sie auch von der Funktion @mref{polarform} zur@"uckgegeben wird.  Der Betrag
 658 des komplexen Ausdrucks kann mit der Funktion @mref{cabs} berechnet werden.
 659
 660 Das Ergebnis der Funktion @code{carg} kann die Funktion @mref{atan2} enthalten.
 661
 662 @code{carg} wird automatisch auf die Elemente von Listen und Matrizen sowie auf
 663 die beiden Seiten von Gleichungen angewendet.  Siehe @mrefdot{distribute_over}
 664
 665 Die Funktion @code{carg} ist eine Verbfunktion, mit der nicht symbolisch
 666 gerechnet werden kann.
 667
 668 Siehe auch die Funktionen @mrefcomma{rectform} @mref{realpart} und
 669 @mref{imagpart} sowie die Funktionen @mref{cabs} und @mrefdot{conjugate}
 670
 671 Beispiele:
 672
 673 @example
 674 (%i1) carg (1);
 675 (%o1)                           0
 676 (%i2) carg (1 + %i);
 677 @group
 678                                %pi
 679 (%o2)                          ---
 680                                 4
 681 @end group
 682 (%i3) carg (exp (%i));
 683 (%o3)                           1
 684
 685 (%i4) carg (exp (3/2 * %pi * %i));
 686                                 %pi
 687 (%o4)                         - ---
 688                                  2
 689 (%i5) carg(exp(x+%i*y));
 690 (%o5)                atan2(sin(y), cos(y))
 691
 692 (%i6) carg(sqrt(x+%i*y));
 693                           atan2(y, x)
 694 (%o6)                     -----------
 695                                2
 696 (%i7) carg(sqrt(1+%i*y));
 697                             atan(y)
 698 (%o7)                       -------
 699                                2
 700 @end example
 701 @end deffn
 702
 703 @c --- 20.02.2011 DK -----------------------------------------------------------
 704 @anchor{conjugate}
 705 @deffn {Funktion} conjugate (@var{expr})
 706
 707 Gibt den konjugiert komplexen Wert des Ausdrucks @var{expr} zur@"uck.  Sind
 708 @var{x} und @var{y} reelle Variablen oder Ausdr@"ucke, dann hat der Ausdruck
 709 @code{x + %i*y} das Ergebnis @code{x - %i*y}.  Die Funktion @code{conjugate} ist
 710 f@"ur numerische und symbolische Rechnungen geeignet.
 711
 712 Maxima kennt Regeln, um den konjugierten Wert f@"ur Summen, Produkte und
 713 Quotienten von komplexen Ausdr@"ucken zu vereinfachen.  Weiterhin kennt Maxima
 714 Symmetrieeigenschaften und komplexe Eigenschaften von Funktionen, um den
 715 konjugierten Wert mit diesen Funktionen zu vereinfachen.  Sind solche
 716 Eigenschaften f@"ur eine Funktion vorhanden, k@"onnen diese mit der
 717 Funktion @mref{properties} angezeigt werden.  Eigenschaften, die das Ergebnis
 718 der Funktion @code{conjugate} bestimmen, sind: @code{mirror symmetry},
 719 @code{conjugate function} und @code{complex characteristic}.
 720
 721 @code{conjugate} wird automatisch auf die Elemente von Listen und Matrizen sowie
 722 auf die beiden Seiten von Gleichungen angewendet.  Siehe
 723 @mrefdot{distribute_over}
 724
 725 F@"ur das Rechnen mit komplexen Ausdr@"ucken siehe auch die Funktionen
 726 @mref{cabs} und @mref{carg} sowie @mref{rectform} und @mrefdot{polarform}
 727
 728 Beispiele:
 729
 730 Beispiele mit reellen, imagin@"aren und komplexen Variablen.
 731
 732 @example
 733 (%i1) declare ([x, y], real, [z1, z2], complex, j, imaginary);
 734 (%o1)                         done
 735 (%i2) conjugate(x + %i*y);
 736 (%o2)                       x - %i y
 737 (%i3) conjugate(z1*z2);
 738 (%o3)              conjugate(z1) conjugate(z2)
 739 (%i4) conjugate(j/z2);
 740                                  j
 741 (%o4)                    - -------------
 742                            conjugate(z2)
 743 @end example
 744
 745 Im Folgenden nutzt Maxima Symmetrieeigenschaften, um den konjugiert komplexen
 746 Wert der Funktionen @mref{gamma} und @mref{sin} zu berechnen.  Die
 747 Logarithmusfunktion @mref{log} hat Spiegelsymmetrie, wenn das Argument einen
 748 positiven Realteil hat.
 749
 750 @example
 751 (%i5) conjugate(gamma(x+%i*y));
 752 (%o5)                    gamma(x - %i y)
 753 (%i6) conjugate(sin(x+%i*y));
 754 (%o6)                    - sin(%i y - x)
 755 (%i7) conjugate(log(x+%i*y));
 756 (%o7)               conjugate(log(%i y + x))
 757 (%i8) conjugate(log(1+%i*y));
 758 (%o8)                     log(1 - %i y)
 759 @end example
 760 @end deffn
 761
 762 @c --- 20.02.2011 DK -----------------------------------------------------------
 763 @anchor{imagpart}
 764 @deffn {Funktion} imagpart (@var{expr})
 765
 766 Gibt den Imagin@"arteil des Ausrucks @var{expr} zur@"uck.  Intern berechnet
 767 Maxima den Imagin@"arteil mit der Funktion @mrefcomma{rectform} die einen
 768 Ausdruck in den Realteil und in den Imagin@"arteil zerlegt.  Daher treffen die
 769 Ausf@"uhrungen zu @code{rectform} auch auf die Funktion @code{imagpart} zu.
 770
 771 Wie die Funktion @code{rectform} ist auch die Funktion @code{imagpart} eine
 772 Verbfunktion, mit der nicht symbolisch gerechnet werden kann.
 773
 774 @code{imagpart} wird automatisch auf die Elemente von Listen und Matrizen sowie
 775 auf die beiden Seiten von Gleichungen angewendet.  Siehe
 776 @mrefdot{distribute_over}
 777
 778 Mit der Funktion @mref{realpart} wird der Realteil eines Ausdrucks berechnet.
 779
 780 Siehe auch die Funktionen @mrefcomma{cabs} @mref{carg} und
 781 @mref{conjugate} f@"ur das Rechnen mit komplexen Zahlen.  Mit der Funktion
 782 @mref{polarform} kann ein komplexer Ausdruck in die Polarform gebracht werden.
 783
 784 Beispiele:
 785
 786 F@"ur weitere Erl@"auterungen dieser Beispiele siehe auch die Funktion
 787 @mrefdot{rectform}
 788
 789 @example
 790 (%i1) imagpart((2-%i)/(1-%i));
 791                                 1
 792 (%o1)                           -
 793                                 2
 794 (%i2) imagpart(sin(x+%i*y));
 795 (%o2)                    cos(x) sinh(y)
 796 (%i3) imagpart(gamma(x+%i*y));
 797              %i (gamma(x - %i y) - gamma(%i y + x))
 798 (%o3)        --------------------------------------
 799                                2
 800 (%i4) imagpart(bessel_j(1,%i));
 801 (%o4)                    bessel_j(1, %i)
 802 @end example
 803 @end deffn
 804
 805 @c --- 20.02.2011 DK -----------------------------------------------------------
 806 @anchor{polarform}
 807 @deffn {Funktion} polarform (@var{expr})
 808
 809 Gibt den Ausdruck @var{expr} in der Polarform @code{r %e^(%i theta)} zur@"uck.
 810 @code{r} ist der Betrag des komplexen Ausdrucks, wie er auch mit der Funktion
 811 @mref{cabs} berechnet werden kann.  @code{theta} ist das Argument des komplexen
 812 Ausdrucks, das mit der Funktion @mref{carg} berechnet werden kann.
 813
 814 Maxima kennt komplexe Eigenschaften von Funktionen, die bei der Berechnung der
 815 Polarform angewendet werden.  Siehe die Funktion @mref{cabs} f@"ur weitere
 816 Erl@"auterungen.
 817
 818 Wenn mit komplexen Ausdr@"ucken in der Polarform gerechnet werden soll, ist es
 819 hilfreich die Optionsvariable @mref{%emode} auf den Wert @code{false} zu setzen.
 820 Damit wird verhindert, dass Maxima komplexe Ausdr@"ucke mit der
 821 Exponentialfunktion @mref{exp} automatisch in die Standardform vereinfacht.
 822
 823 @code{polarform} wird automatisch auf die Elemente von Listen und Matrizen sowie
 824 auf die beiden Seiten von Gleichungen angewendet.  Siehe
 825 @mrefdot{distribute_over}
 826
 827 Die Funktion @code{polarform} ist eine Verbfunktion, mit der nicht symbolisch
 828 gerechnet werden kann.
 829
 830 Siehe auch die Funktionen @mrefcomma{cabs} @mref{carg} und
 831 @mref{conjugate} f@"ur das Rechnen mit komplexen Zahlen.  Mit der Funktion
 832 @mref{rectform} kann ein komplexer Ausdruck in die Standardform gebracht werden.
 833
 834 Beispiele:
 835
 836 Die allgemeine Polarform eines komplexen Ausdrucks.  Die Variablen @var{x} und
 837 @var{y} werden von Maxima als reell angenommen.
 838
 839 @example
 840 (%i1) polarform(x+%i*y);
 841 @group
 842                        2    2    %i atan2(y, x)
 843 (%o1)            sqrt(y  + x ) %e
 844 @end group
 845 @end example
 846
 847 Die Polarform einer komplexen Zahl und eines Ausdrucks mit einer reellen
 848 Variablen @var{x}.
 849
 850 @example
 851 (%i2) polarform(4/5+3*%i/5);
 852                            %i atan(3/4)
 853 (%o2)                    %e
 854 (%i3) polarform(sqrt(1+%i*x));
 855                                   %i atan(x)
 856                                   ----------
 857                       2     1/4       2
 858 (%o3)               (x  + 1)    %e
 859 @end example
 860
 861 Wenn in der Polarform gerechnet werden soll, ist es hilfreich die
 862 Optionsvariable @mref{%emode} auf den Wert @code{false} zu setzen.  Damit wird
 863 verhindert, dass Maxima komplexe Ausdr@"ucke mit der Exponentialfunktion
 864 @mref{exp} automatisch in eine Standardform vereinfacht.
 865
 866 @example
 867 (%i4) z:polarform(1+%i);
 868                                   %i %pi
 869                                   ------
 870                                     4
 871 (%o4)                   sqrt(2) %e
 872 (%i5) z^3;
 873                      3/2    %i         1
 874 (%o5)               2    (------- - -------)
 875                           sqrt(2)   sqrt(2)
 876 (%i6) %emode:false;
 877 (%o6)                         false
 878 (%i7) z^3;
 879                                 3 %i %pi
 880                                 --------
 881                           3/2      4
 882 (%o7)                    2    %e
 883 @end example
 884 @end deffn
 885
 886 @c --- 20.02.2011 DK -----------------------------------------------------------
 887 @anchor{realpart}
 888 @deffn {Funktion} realpart (@var{expr})
 889
 890 Gibt den Realteil des Ausdrucks @var{expr} zur@"uck.  Intern berechnet Maxima
 891 den Realteil mit der Funktion @mrefcomma{rectform} die einen Ausdruck in den
 892 Realteil und in den Imagin@"arteil zerlegt.  Daher treffen die Ausf@"uhrungen
 893 zu @code{rectform} auch auf die Funktion @code{realpart} zu.
 894
 895 Wie die Funktion @code{rectform} ist auch die Funktion @code{realpart} eine
 896 Verbfunktion, mit der nicht symbolisch gerechnet werden kann.
 897
 898 @code{realpart} wird automatisch auf die Elemente von Listen und Matrizen sowie
 899 auf die beiden Seiten von Gleichungen angewendet.  Siehe
 900 @mrefdot{distribute_over}
 901
 902 Mit der Funktion @mref{imagpart} wird der Imagin@"arteil eines Ausdrucks
 903 berechnet.
 904
 905 Siehe auch die Funktionen @mrefcomma{cabs} @mref{carg} und
 906 @mref{conjugate} f@"ur das Rechnen mit komplexen Zahlen.  Mit der Funktion
 907 @mref{polarform} kann ein komplexer Ausdruck in die Polarform gebracht werden.
 908
 909 Beispiele:
 910
 911 F@"ur weitere Erl@"auterungen dieser Beispiele siehe auch die Funktion
 912 @mrefdot{rectform}
 913
 914 @example
 915 (%i1) realpart((2-%i)/(1-%i));
 916                                 3
 917 (%o1)                           -
 918                                 2
 919 (%i2) realpart(sin(x+%i*y));
 920 (%o2)                    sin(x) cosh(y)
 921 (%i3) realpart(gamma(x+%i*y));
 922                 gamma(%i y + x) + gamma(x - %i y)
 923 (%o3)           ---------------------------------
 924                                 2
 925 (%i4) realpart(bessel_j(1,%i));
 926 (%o4)                           0
 927 @end example
 928 @end deffn
 929
 930 @c --- 20.02.2011 DK -----------------------------------------------------------
 931 @anchor{rectform}
 932 @deffn {Funktion} rectform (@var{expr})
 933
 934 Zerlegt den Ausdruck @var{expr} in den Realteil @code{a} und den Imagin@"arteil
 935 @code{b} und gibt den komplexen Ausdruck in der Standardform @code{a + b %i}
 936 zur@"uck.
 937
 938 Die Funktion @code{rectform} nutzt Symmetrieeigenschaften und implementierte
 939 Eigenschaften komplexer Funktionen, um den Realteil und Imagin@"arteil eines
 940 komplexen Ausdrucks zu berechnen.  Sind solche Eigenschaften f@"ur eine Funktion
 941 vorhanden, k@"onnen diese mit der Funktion @mref{properties} angezeigt werden.
 942 Eigenschaften, die das Ergebnis der Funktion @code{rectform} bestimmen, sind:
 943 @code{mirror symmetry}, @code{conjugate function} und
 944 @code{complex characteristic}.
 945
 946 @code{rectform} ist eine Verbfunktion, die nicht f@"ur das symbolische Rechnen
 947 geeignet ist.
 948
 949 @code{rectform} wird automatisch auf die Elemente von Listen und Matrizen sowie
 950 auf die beiden Seiten von Gleichungen angewendet.  Siehe
 951 @mrefdot{distribute_over}
 952
 953 Die Funktionen @mref{realpart} und @mref{imagpart} geben jeweils allein den
 954 Realteil und den Imagin@"arteil eines Ausdrucks zur@"uck.  Um einen Ausdruck in
 955 die Polarform zu bringen, kann die Funktion @mref{polarform} verwendet werden.
 956
 957 Siehe auch die Funktionen @mrefcomma{cabs} @mref{carg} und
 958 @mref{conjugate} f@"ur das Rechnen mit komplexen Zahlen.
 959
 960 Beispiele:
 961
 962 Zerlegung eines komplexen Ausdrucks und der Sinusfunktion @mref{sin} in den
 963 Realteil und Imagin@"arteil.  Maxima kennt komplexe Eigenschaften der
 964 trigonometrischen Funktionen, um den Realteil und den Imagin@"arteil zu
 965 bestimmen.
 966
 967 @example
 968 (%i1) rectform((2-%i)/(1-%i));
 969 @group
 970                              %i   3
 971 (%o1)                        -- + -
 972                              2    2
 973 @end group
 974 (%i2) rectform(sin(x+%i*y));
 975 (%o2)          %i cos(x) sinh(y) + sin(x) cosh(y)
 976 @end example
 977
 978 Bei der Zerlegung in einen Realteil und einen Imagin@"arteil nutzt Maxima die
 979 Spiegelsymmetrie der Gammfunktion @mrefdot{gamma}  Die Eigenschaft der
 980 Spiegelsymmetrie wird mit der Funktion @mref{properties} angezeigt, der Eintrag
 981 lautet @code{mirror symmetry}.
 982
 983 @example
 984 (%i3) properties(gamma);
 985 (%o3)    [mirror symmetry, noun, rule, gradef, transfun]
 986
 987 (%i4) rectform(gamma(x+%i*y));
 988       gamma(%i y + x) + gamma(x - %i y)
 989 (%o4) ---------------------------------
 990                       2
 991                                 gamma(x - %i y) - gamma(%i y + x)
 992                               - ---------------------------------
 993                                                 2
 994 @end example
 995
 996 Maxima kennt komplexe Eigenschaften der Besselfunktionen.  Die Besselfunktion
 997 @mref{bessel_j} ist f@"ur eine ganzzahlige Ordnung und einem imagin@"aren
 998 Argument rein imagin@"ar.
 999
1000 @example
1001 (%i5) rectform(bessel_j(1,%i));
1002 (%o5)                  %i bessel_j(1, %i)
1003 @end example
1004 @end deffn
1005
1006 @c -----------------------------------------------------------------------------
1007 @node Funktionen der Kombinatorik, Wurzel- Exponential- und Logarithmusfunktion, Funktionen f@"ur komplexe Zahlen, Mathematische Funktionen
1008 @section Funktionen der Kombinatorik
1009 @c -----------------------------------------------------------------------------
1010
1011 @c --- 25.02.2011 DK -----------------------------------------------------------
1012 @anchor{!!}
1013 @deffn {Operator} !!
1014 @ifinfo
1015 @fnindex Doppelte Fakult@"at
1016 @end ifinfo
1017
1018 Ist der Operator der doppelten Fakult@"at.
1019
1020 F@"ur eine positive ganze Zahl @code{n}, wird @code{n!!} zu dem Produkt
1021 @code{n (n-2) (n-4) (n-6) ... (n - 2 (k-1))} vereinfacht, wobei @code{k} gleich
1022 @code{floor(n/2)} ist und @mref{floor} die gr@"o@ss{}te ganze Zahl als Ergebnis
1023 hat, die kleiner oder gleich @code{n/2} ist.
1024
1025 F@"ur ein Argument @code{n}, das keine ganze positive Zahl ist, gibt @code{n!!}
1026 die Substantivform @code{genfact(n, n/2,2)} zur@"uck.  Siehe die Funktion
1027 @mrefdot{genfact}
1028
1029 Die Verallgemeinerung der doppelten Fakult@"at f@"ur reelle und komplexe Zahlen
1030 ist als die Funktion @mref{double_factorial} implementiert.
1031
1032 Beispiele:
1033
1034 @example
1035 (%i1) [0!!, 1!!, 2!!, 3!!, 4!!, 5!!, 6!!, 7!!, 8!!];
1036 (%o1)           [1, 1, 2, 3, 8, 15, 48, 105, 384]
1037 (%i2) 1.5!!;
1038 (%o2)                  genfact(1.5, 0, 2)
1039 (%i3) x!!;
1040                                    x
1041 (%o3)                   genfact(x, -, 2)
1042                                    2
1043 @end example
1044 @end deffn
1045
1046 @c --- 26.02.2011 DK -----------------------------------------------------------
1047 @anchor{binomial}
1048 @deffn {Funktion} binomial (@var{x}, @var{y})
1049
1050 Ist der Binominialkoeffizient, der definiert ist als
1051 @ifnottex
1052 @example
1053                                   x!
1054              binomial(x, y) = -----------
1055                               (x - y)! y!
1056 @end example
1057 @end ifnottex
1058 @tex
1059 $${{x}\choose{y}}={{x!}\over{\left(x-y\right)!\,y!}}$$
1060 @end tex
1061
1062 Die Funktion @code{binomial} ist f@"ur das numerische und symbolische Rechnen
1063 geeignet.
1064
1065 Sind die Argumente @var{x} oder @var{y} ganze Zahlen, wird der
1066 Binominialkoeffizient zu einer ganzen Zahl vereinfacht.  Sind die Argumente
1067 @var{x} und @var{y} reelle oder komplexe Gleitkommazahlen, wird der
1068 Binominialkoeffizient mit der entsprechenden verallgemeinerten Fakult@"at
1069 berechnet.  Siehe auch @mref{factorial} und @mrefdot{gamma}
1070
1071 Ist das Argument @var{y} oder die Differenz @var{x-y} eine ganz Zahl, wird
1072 der Binominialkoeffizient zu einem Polynom vereinfacht.
1073
1074 Mit den Funktionen @mref{makefact} oder @mref{makegamma} werden
1075 Binominialkoeffizienten in einem Ausdruck durch @"aquivalente Ausdr@"ucke mit
1076 der Fakult@"at oder der Gammafunktion ersetzt.
1077
1078 Maxima kennt die Ableitung des Binominialkoeffizienten nach den Argumenten
1079 @var{x} und @var{y}.
1080
1081 Beispiele:
1082
1083 @example
1084 (%i1) binomial(11, 7);
1085 (%o1)                          330
1086 (%i2) binomial(%i, 1.5);
1087 (%o2)       .3693753994635863 %i - .7573400496142132
1088 (%i3) binomial(x, 3);
1089                         (x - 2) (x - 1) x
1090 (%o3)                   -----------------
1091                                 6
1092 (%i4) binomial(x+3, 3);
1093                      (x + 1) (x + 2) (x + 3)
1094 (%o4)                -----------------------
1095                                 6
1096 (%i5) makefact(binomial(x,y));
1097                                x!
1098 (%o5)                      -----------
1099                            (x - y)! y!
1100
1101 (%i6) diff(binomial(x,y), y);
1102 (%o6)  - binomial(x, y) (psi (y + 1) - psi (- y + x + 1))
1103                             0             0
1104 @end example
1105 @end deffn
1106
1107 @c --- 25.02.2011 DK -----------------------------------------------------------
1108 @anchor{double_factorial}
1109 @deffn {Funktion} double_factorial (z)
1110
1111 Ist die doppelte Fakult@"at, die allgemein definiert ist als
1112 @ifnottex
1113 @example
1114                2  1/4 (1 - cos(z %pi))  z/2       z
1115              (---)                     2    gamma(- + 1)
1116               %pi                                 2
1117 @end example
1118 @end ifnottex
1119 @tex
1120 $$\left({{2}\over{\pi}}\right)^{{{1}\over{4}}\,\left(1-\cos \left(z\,
1121  \pi\right)\right)}\,2^{{{z}\over{2}}}\,\Gamma\left({{z}\over{2}}+1
1122  \right)$$
1123 @end tex
1124
1125 Die Funktion @code{double_factorial} ist f@"ur das numerische und symbolische
1126 Rechnen geeignet.  Ist das Argument @var{z} eine ganze Zahl, eine
1127 Gleitkommazahl, eine gro@ss{}e Gleitkommazahl oder eine komplexe Gleitkommazahl,
1128 dann wird ein numerisches Ergebnis berechnet.  F@"ur eine positive ganze Zahl
1129 ist das Ergebnis gleich dem Ergebnis des Operators der doppelten Fakult@"at
1130 @mref{!!}.  F@"ur rationale Zahlen ist das Ergebnis eine Substantivform.
1131
1132 F@"ur negative gerade ganze Zahlen ist die Funktion @code{double_factorial}
1133 nicht definiert.
1134
1135 Hat die Optionsvariable @mref{factorial_expand} den Wert @code{true},
1136 vereinfacht Maxima @code{double_factorial} f@"ur das Argument @code{n-1} und
1137 f@"ur Argumente @code{n+2*k}, wobei @code{k} eine ganze Zahl ist.
1138
1139 Maxima kennt die Ableitung der Funktion @code{double_factorial}.
1140
1141 @code{double_factorial} wird automatisch auf die Elemente von Listen und
1142 Matrizen sowie auf die beiden Seiten von Gleichungen angewendet.  Siehe
1143 @mrefdot{distribute_over}
1144
1145 Beispiele:
1146
1147 Numerische Ergebnisse f@"ur ganze Zahlen, Gleitkommazahlen und komplexen
1148 Gleitkommazahlen.
1149
1150 @example
1151 (%i1) double_factorial([-3, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
1152 (%o1) [- 1, 1, 1, 1, 2, 3, 8, 15, 48, 105, 384, 945, 3840]
1153
1154 (%i2) double_factorial([1.5, 1.5b0, 0.5+%i, 0.5b0+%i]);
1155 (%o2) [1.380662681753386, 1.380662681753387b0,
1156 .4186422526242637 - .7218816624466643 %i,
1157 4.186422526242633b-1 - 7.218816624466641b-1 %i]
1158 @end example
1159
1160 Vereinfachungen, wenn die Optionsvariable @mref{factorial_expand} den Wert
1161 @code{true} hat.
1162
1163 @example
1164 (%i3) factorial_expand:true;
1165 (%o3)                         true
1166 (%i4) double_factorial(n-1);
1167                                n!
1168 (%o4)                  -------------------
1169                        double_factorial(n)
1170 (%i5) double_factorial(n+4);
1171 (%o5)          (n + 2) (n + 4) double_factorial(n)
1172 (%i6) double_factorial(n-4);
1173 @group
1174                        double_factorial(n)
1175 (%o6)                  -------------------
1176                             (n - 2) n
1177 @end group
1178 @end example
1179
1180 Die Ableitung der Funktion @code{double_factorial}.
1181
1182 @example
1183 (%i7) diff(double_factorial(x), x);
1184                                      2
1185                             %pi log(---) sin(%pi x)
1186                                     %pi                    x
1187 (%o7) (double_factorial(x) (----------------------- + psi (- + 1)
1188                                        2                 0 2
1189                                                      + log(2)))/2
1190 @end example
1191 @end deffn
1192
1193 @c --- 26.02.2011 DK -----------------------------------------------------------
1194 @anchor{factcomb}
1195 @deffn {Funktion} factcomb (@var{expr})
1196
1197 Fasst Faktoren mit Fakult@"aten im Ausdruck @var{expr} zusammen.  Zum Beispiel
1198 wird @code{(n+1)*n!} zu @code{(n+1)!} zusammengefasst.
1199
1200 Hat die Optionsvariable @mref{sumsplitfact} den Wert @code{false}, wird nach
1201 der Vereinfachung mit @code{factcomb} die Funktion @mref{minfactorial} auf den
1202 Ausdruck @var{expr} angewendet.
1203
1204 Beispiele:
1205
1206 @example
1207 (%i1) expr: ((n+1)*n!)/(n+2)!;
1208                            (n + 1) n!
1209 (%o1)                      ----------
1210                             (n + 2)!
1211 (%i2) factcomb(expr);
1212 @group
1213                             (n + 1)!
1214 (%o2)                       --------
1215                             (n + 2)!
1216 @end group
1217 (%i3) factcomb(expr), sumsplitfact:false;
1218                                 1
1219 (%o3)                         -----
1220                               n + 2
1221 @end example
1222 @end deffn
1223
1224 @c --- 26.02.2011 DK -----------------------------------------------------------
1225 @anchor{factorial}
1226 @anchor{!}
1227 @deffn  {Funktion} factorial (@var{z})
1228 @deffnx {Operator} !
1229 @ifinfo
1230 @fnindex Fakult@"at
1231 @end ifinfo
1232
1233 Die Funktion @code{factorial} ist f@"ur das numerische und symbolische Rechnen
1234 der Fakult@"at geeignet.  Der Operator der Fakult@"at @code{!}, ist identisch
1235 mit der Funktion @code{factorial}.
1236
1237 F@"ur eine ganze Zahl @code{n}, vereinfacht @code{n!} zum Produkt der ganzen
1238 Zahlen von 1 bis einschlie@ss{}lich @code{n}.  @code{0!} vereinfacht zu 1.
1239 F@"ur reelle und komplexe Gleitkommazahlen wird @code{z!} mit der
1240 Verallgemeinerung @code{gamma(z+1)} berechnet.  Siehe die Funktion
1241 @mrefdot{gamma}  F@"ur eine halbzahlige rationale Zahl @code{n/2}, vereinfacht
1242 @code{(n/2)!} zu einem rationalen Faktor multipliziert mit @code{sqrt(%pi)}.
1243
1244 Die Optionsvariable @mref{factlim} enth@"alt die gr@"o@ss{}te Zahl, f@"ur die
1245 die Fakult@"at einer ganzen Zahl numerisch berechnet wird.  Ist das Argument
1246 der Fakult@"at eine rationale Zahl, wird von Maxima die Funktion
1247 @mref{gamma} f@"ur die numerische Berechnung aufgerufen.  In diesem Fall ist
1248 @code{gammalim - 1} der gr@"o@ss{}te Nenner, f@"ur den die Fakult@"at vereinfacht
1249 wird.  Siehe @mrefdot{gammalim}
1250
1251 Hat die Optionsvariable @mref{factorial_expand} den Wert @code{true}, wird die
1252 Fakult@"at von Argumenten der Form @code{(n+k)!} oder @code{(n-k)!} vereinfacht,
1253 wobei @code{k} eine ganze Zahl ist.
1254
1255 Mit den Funktionen @mref{minfactorial} und @mref{factcomb} k@"onnen Fakult@"aten
1256 in Ausdr@"ucken vereinfacht werden.
1257
1258 Die Funktion @mref{makegamma} ersetzt Fakult@"aten in einem Ausdruck durch die
1259 Gammafunktion @mrefdot{gamma}  Umgekehrt ersetzt die Funktion
1260 @mref{makefact} Binomialkoeffizienten und die Gammafunktion in einem Ausdruck
1261 durch Fakult@"aten.
1262
1263 Maxima kennt die Ableitung der Fakult@"at und die Grenzwerte der Fakult@"at
1264 f@"ur spezielle Werte wie negative ganze Zahlen.
1265
1266 Siehe auch die Gammfunktion @mref{gamma} und den Binomialkoeffizienten
1267 @mrefdot{binomial}
1268
1269 Beispiele:
1270
1271 Die Fakult@"at einer ganzen Zahl wird zu einer exakten Zahl vereinfacht, wenn
1272 das Argument nicht gr@"o@ss{}er als @code{factlim} ist.  Die Fakult@"at f@"ur
1273 reelle und komplexe Zahlen wird als Gleitkommazahl berechnet.
1274
1275 @example
1276 (%i1) factlim:10;
1277 (%o1)                          10
1278 (%i2) [0!, (7/2)!, 8!, 20!];
1279                      105 sqrt(%pi)
1280 (%o2)            [1, -------------, 40320, 20!]
1281                           16
1282 (%i3) [4.77!, (1.0+%i)!];
1283 (%o3) [81.44668037931197, .3430658398165451 %i
1284                                              + .6529654964201663]
1285 (%i4) [2.86b0!, (1.0b0+%i)!];
1286 (%o4) [5.046635586910012b0, 3.430658398165454b-1 %i
1287                                           + 6.529654964201667b-1]
1288 @end example
1289
1290 Die Fakult@"at von numerischen Konstanten oder eines konstanten Ausdrucks wird
1291 numerisch berechnet, wenn die Konstante oder der Ausdruck zu einer Zahl
1292 ausgewertet werden kann.
1293
1294 @example
1295 (%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
1296 (%o1)      [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!]
1297 (%i2) ev (%, numer, %enumer);
1298 (%o2) [.3430658398165451 %i + .6529654964201663,
1299          7.188082728976031, 4.260820476357003, 1.227580202486819]
1300 @end example
1301
1302 Fakult@"aten werden vereinfacht und nicht ausgewertet.  Daher wird die
1303 Fakult@"at auch dann berechnet, wenn die Auswertung mit dem
1304 @nxref{', Quote-Operator} @code{'} unterdr@"uckt ist.
1305
1306 @example
1307 (%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]);
1308             105 sqrt(%pi)
1309 (%o1)   [1, -------------, 81.44668037931197, 40320, 20!]
1310                  16
1311 @end example
1312
1313 Maxima kennt die Ableitung der Fakult@"at.
1314
1315 @example
1316 (%i1) diff(x!, x);
1317 (%o1)                    x! psi (x + 1)
1318                                0
1319 @end example
1320
1321 Die Optionsvariable @code{factorial_expand} kontrolliert die Expansion und
1322 Vereinfachung von Ausdr@"ucken, die die Fakult@"at enthalten.
1323
1324 @example
1325 (%i1) (n+1)!/n!,factorial_expand:true;
1326 (%o1)                         n + 1
1327 @end example
1328 @end deffn
1329
1330 @c --- 26.02.2011 DK -----------------------------------------------------------
1331 @anchor{factlim}
1332 @defvr {Optionsvariable} factlim
1333 Standardwert: 100000
1334
1335 Die Optionsvariable @code{factlim} spezifiziert die gr@"o@ss{}te ganze Zahl,
1336 f@"ur die die Fakult@"at einer ganzen Zahl numerisch berechnet wird.  Hat
1337 @code{factlim} den Wert -1, wird die Fakult@"at f@"ur jede ganze Zahl
1338 berechnet.  Siehe die Funktion @mrefdot{factorial}
1339 @end defvr
1340
1341 @c --- 26.02.2011 DK -----------------------------------------------------------
1342 @anchor{factorial_expand}
1343 @defvr {Optionsvariable} factorial_expand
1344 Standardwert: @code{false}
1345
1346 Die Optionsvariable @code{factorial_expand} kontrolliert die Vereinfachung von
1347 Aus@-dr@"u@-cken wie @code{(n+k)!} oder @code{(n-k)!}, wobei @code{k} eine
1348 ganze Zahl ist.  Siehe @mref{factorial} f@"ur ein Beispiel.
1349
1350 Siehe auch die Funktionen @mref{minfactorial} und @mref{factcomb} f@"ur die
1351 Vereinfachung von Ausdr@"ucken mit der Fakult@"at.
1352 @end defvr
1353
1354 @c --- 26.02.2011 DK -----------------------------------------------------------
1355 @anchor{genfact}
1356 @deffn {Funktion} genfact (@var{x}, @var{y}, @var{z})
1357
1358 Gibt die verallgemeinerte Fakult@"at zur@"uck, die als @code{x (x-z) (x - 2 z)
1359 ... (x - (y - 1) z)} definiert ist.  Ist @var{x} eine ganze Zahl, dann
1360 entspricht @code{genfact(x, x, 1)} der Fakult@"at @code{x!} und
1361 @code{genfact(x, x/2, 2)} der doppelten Fakult@"at @code{x!!}.  Siehe auch die
1362 Funktionen @mref{factorial} und @mref{double_factorial} sowie die Operatoren
1363 @mref{!} und @mrefdot{!!}
1364 @end deffn
1365
1366 @c --- 26.02.2011 DK -----------------------------------------------------------
1367 @anchor{minfactorial}
1368 @deffn {Funktion} minfactorial (@var{expr})
1369
1370 Die Funktion @code{minfactorial} vereinfacht Fakult@"aten @mref{factorial} in
1371 dem Ausdruck @var{epxr}, die sich um eine ganze Zahl voneinander unterscheiden.
1372 Siehe auch die Funktion @mrefcomma{factcomb} um Fakult@"aten zusammenzufassen,
1373 sowie die Optionsvariable @mrefdot{factorial_expand}
1374
1375 @example
1376 (%i1) n!/(n+2)!;
1377                                n!
1378 (%o1)                       --------
1379                             (n + 2)!
1380 (%i2) minfactorial (%);
1381                                 1
1382 (%o2)                    ---------------
1383                          (n + 1) (n + 2)
1384 @end example
1385 @end deffn
1386
1387 @c --- 26.02.2011 DK -----------------------------------------------------------
1388 @anchor{sumsplitfact}
1389 @defvr {Optionsvariable} sumsplitfact
1390 Standardwert: @code{true}
1391
1392 Hat die Optionsvariable @code{sumsplitfact} den Wert @code{false}, wird von
1393 der Funktion @code{factcomb} nach der Zusammenfassung von Fakult@"aten die
1394 Funktion @mref{minfactorial} angewendet.  Siehe die Funktion
1395 @mref{factcomb} f@"ur ein Beispiel.
1396 @end defvr
1397
1398 @c -----------------------------------------------------------------------------
1399 @node Wurzel- Exponential- und Logarithmusfunktion, Winkelfunktionen, Funktionen der Kombinatorik, Mathematische Funktionen
1400 @section Wurzel-, Exponential- und Logarithmusfunktion
1401 @c -----------------------------------------------------------------------------
1402
1403 @c --- 27.02.2011 DK -----------------------------------------------------------
1404 @anchor{%e_to_numlog}
1405 @defvr {Optionsvariable} %e_to_numlog
1406 Standardwert: @code{false}
1407
1408 Hat die Optionsvariable @code{%e_to_numlog} den Wert @code{true}, wird ein
1409 Ausdruck mit der Exponentialfunktion @mref{exp} der Form @code{%e^(r*log(x))}
1410 zu @code{x^r} vereinfacht, wenn @code{r} eine rationale Zahl ist.  Ist @code{r}
1411 eine ganze Zahl, wird die Vereinfachung von der Optionsvariablen
1412 @mref{logsimp} kontrolliert.
1413
1414 Beispiel:
1415
1416 @example
1417 (%i1) exp(1/2*log(x));
1418                               log(x)
1419                               ------
1420                                 2
1421 (%o1)                       %e
1422 (%i2) exp(1/2*log(x)), %e_to_numlog:true;
1423 (%o2)                        sqrt(x)
1424 @end example
1425 @end defvr
1426
1427 @c --- 27.02.2011 DK -----------------------------------------------------------
1428 @anchor{%emode}
1429 @defvr {Optionsvariable} %emode
1430 Standardwert: @code{true}
1431
1432 Die Optionsvariable @code{%emode} kontrolliert die Vereinfachung von
1433 Ausdr@"ucken mit der Exponentialfunktion @mref{exp} der Form
1434 @code{%e^(%pi %i x)}.
1435
1436 Ist das Argument @var{x} eine ganze Zahl oder eine rationale Zahl, die ein
1437 Vielfaches von 1/2, 1/3, 1/4 oder 1/6 ist, dann wird der Ausdruck
1438 @code{%e^(%pi %i x)} zu einer reellen oder komplexen Zahl vereinfacht.  F@"ur
1439 Gleitkommazahlen wird diese Vereinfachung dann ausgef@"uhrt, wenn diese eine
1440 ganze Zahl oder halbzahlige rationale Zahl repr@"asentieren.
1441
1442 Eine Summe im Exponenten wie zum Beispiel @code{%e^(%pi *%i (x+n))}, wobei
1443 @var{n} eine der oben genannten Zahlen und @var{x} ein allgemeiner Ausdruck ist,
1444 wird vereinfacht, indem der Faktor @code{%^(%pi %i n)} entsprechend vereinfacht
1445 wird.
1446
1447 Hat @code{%emode} den Wert @code{false}, werden keine speziellen Vereinfachungen
1448 f@"ur den Ausdruck @code{%e^(%pi %i x)} vorgenommen.
1449
1450 Beispiele:
1451
1452 @example
1453 (%i1) exp([2*%pi*%i, 1/2*%pi*%i, 0.5*%pi*%i, 0.5b0*%pi*%i]);
1454 (%o1)               [1, %i, 1.0 %i, 1.0b0 %i]
1455
1456 (%i2) exp([1/3*%pi*%i, 1/4*%pi*%i, 1/6*%pi*%i]);
1457          sqrt(3) %i   1    %i         1     %i   sqrt(3)
1458 (%o2)   [---------- + -, ------- + -------, -- + -------]
1459              2        2  sqrt(2)   sqrt(2)  2       2
1460
1461 (%i3) exp((1/3+x)*%pi*%i);
1462                     sqrt(3) %i   1    %i %pi x
1463 (%o3)              (---------- + -) %e
1464                         2        2
1465 @end example
1466 @end defvr
1467
1468 @c --- 27.02.2011 DK -----------------------------------------------------------
1469 @anchor{%enumer}
1470 @defvr {Optionsvariable} %enumer
1471 Standardwert: @code{false}
1472
1473 Hat @code{%enumer} den Wert @code{true}, wird die Konstante @code{%e} immer dann
1474 durch ihren nummerischen Wert ersetzt, wenn die Optionsvariable @mref{numer} den
1475 Wert @code{true} hat.
1476
1477 Hat @code{%enumer} den Wert @code{false}, wird die Konstante @code{%e} nur dann
1478 durch ihren nummerischen Wert ersetzt, wenn der Exponent von @code{%e^x} zu
1479 einer Gleitkommazahl ausgewertet wird.
1480
1481 Siehe auch @mref{ev} und @mrefdot{numer}
1482
1483 Beispiel:
1484
1485 @example
1486 (%i1) %enumer:true;
1487 (%o1)                         true
1488 (%i2) exp(x);
1489                                  x
1490 (%o2)                          %e
1491 (%i3) exp(x),numer;
1492                                         x
1493 (%o3)                  2.718281828459045
1494 @end example
1495 @end defvr
1496
1497 @c --- 27.02.2011 DK -----------------------------------------------------------
1498 @anchor{exp}
1499 @deffn {Funktion} exp (@var{z})
1500
1501 Ist die Exponentialfunktion.  Die Exponentialfunktion @code{exp} wird von Maxima
1502 sofort zu @code{%e^@var{z}} vereinfacht und tritt in vereinfachten
1503 Ausdr@"ucken nicht auf.  Maxima vereinfacht die Exponentialfunktion daher wie
1504 die allgemeine Exponentiation @mrefdot{^}  Dar@"uberhinaus kennt Maxima
1505 spezielle Regeln f@"ur die Vereinfachung der Exponentialfunktion.
1506
1507 Ist das Argument @var{z} der Exponentialfunktion eine ganze oder rationale
1508 Zahl wird ein vereinfachter Ausdruck zur@"uckgegeben.  Ist das Argument
1509 @var{z} eine reelle oder komplexe Gleitkommazahl wird ein numerisches
1510 Ergebnis berechnet.
1511
1512 Folgende Optionsvariablen kontrollieren die Vereinfachung der
1513 Exponentialfunktion:
1514
1515 @table @code
1516 @item %enumer
1517 Hat die Optionsvariable @mref{%enumer} den Wert @code{true}, vereinfacht Maxima
1518 die Eulersche Zahl @mref{%e} immer dann zu ihrem numerischen Wert, wenn die
1519 Optionsvariable @mref{numer} auch den Wert @code{true} hat.
1520
1521 @item %emode
1522 Hat die Optionsvariable @mref{%emode} den Wert @code{true}, wendet Maxima
1523 Regeln an, um Ausdr@"ucke der Form @code{%e^(x*%i*%pi)} zu vereinfachen.
1524 Der Standardwert von @code{%emode} ist @code{true}.  Wenn mit komplexen Zahlen
1525 in der Polarform gerechnet wird, kann es hilfreich sein, die Optionsvariable
1526 @code{%emode} auf den Wert @code{false} zu setzen.
1527
1528 @item %e_to_numlog
1529 Hat die Optionsvariable @mref{%e_to_numlog} den Wert @code{true}, vereinfacht
1530 Maxima einen Ausdruck @code{%e^(r*log(x)} zu @code{x^r}, wobei @var{r}
1531 eine rationale Zahl ist.  Ist @var{r} eine ganze Zahl wird diese Vereinfachung
1532 von der Optionsvariablen @mref{logsimp} kontrolliert.  F@"ur reelle oder
1533 komplexe Gleitkommazahlen wird diese Vereinfachung nicht ausgef@"uhrt.
1534
1535 @item radexpand
1536 Die Optionsvariable @mref{radexpand} kontrolliert die Vereinfachung von
1537 Ausdr@"ucken der Form @code{(%e^a)^b}.  Ist @var{a} ein reelles Argument
1538 vereinfacht Maxima immer zu einem Ausdruck @code{%e^(a*b)}.  Ist @var{a} ein
1539 komplexes Argument, wird die Vereinfachung @code{%e^(a*b)} dann ausgef@"uhrt,
1540 wenn die Optionsvariable @code{radexpand} den Wert @code{all} hat.
1541
1542 @item logsimp
1543 Die Optionsvariable @mref{logsimp} kontrolliert die Vereinfachung der
1544 Exponentialfunktion f@"ur den Fall, dass im Argument @var{expr} die
1545 Logarithmusfunktion @mref{log} auftritt.  Hat die @code{logsimp} den Wert
1546 @code{true}, wird ein Ausdruck @code{%e^(n*log(x)} zu @code{x^n} vereinfacht,
1547 wenn @var{n} eine ganze Zahl ist.  Mit der Optionsvariablen
1548 @mref{%e_to_numlog} wird diese Vereinfachung f@"ur eine rationale Zahl @var{n}
1549 kontrolliert.
1550
1551 @item demoivre
1552 Ist eine Optionsvariable und eine Funktion, die auch als Auswertungsschalter
1553 @mref{evflag} definiert ist.  Hat die Optionsvariable @mref{demoivre} den Wert
1554 @code{true}, wird ein Ausdruck @code{%e^(x + %i y)} zu
1555 @code{%e^x (cos(y) + %i sin(y))} vereinfacht.  Siehe auch die Optionsvariable
1556 @mrefdot{exponentialize}
1557 @end table
1558
1559 Maxima kennt viele spezielle unbestimmte und bestimmte Integrale mit der
1560 Exponentialfunktion.
1561 @end deffn
1562
1563 @c --- 01.11.2011 DK -----------------------------------------------------------
1564 @anchor{log}
1565 @deffn {Funktion} log (@var{z})
1566
1567 Ist der nat@"urliche Logarithmus zur Basis @math{e}.  Die Logarithmusfunktion
1568 ist f@"ur das numerische und symbolische Rechnen geeignet.
1569
1570 Maxima hat keine vordefinierte Logarithmusfunktion zur Basis 10 oder anderen
1571 Basen.  Eine einfache Definition ist zum Beispiel
1572 @code{log10(x) := log(x)/log(10)}.  Mit dem Kommando @code{load("log10")} kann ein
1573 Paket geladen werden, dass eine dekadische Logarithmusfunktion @code{log10}
1574 definiert.
1575
1576 Ist das Argument @var{z} der Logarithmusfunktion eine ganze oder rationale
1577 Zahl wird ein vereinfachter Ausdruck zur@"uckgegeben.  Ist das Argument
1578 @var{z} eine reelle oder komplexe Gleitkommazahl wird ein numerisches
1579 Ergebnis berechnet.
1580
1581 Die folgenden Optionsvariablen kontrollieren die Vereinfachung und Auswertung
1582 der Logarithmusfunktion:
1583
1584 @table @code
1585 @item logexpand
1586 Hat die Optionsvariable @code{logexpand} den Wert @code{true}, dann wird
1587 @code{log(a^b)} zu @code{b*log(a)} vereinfacht.  Hat @code{logexpand} den
1588 Wert @code{all}, wird zus@"atzlich @code{log(a*b)} zu @code{log(a)+log(b)}
1589 vereinfacht.  Mit den Wert @code{super} vereinfacht Maxima weiterhin
1590 @code{log(a/b)} zu @code{log(a)-log(b)}, wobei @code{a/b} eine rationale Zahl
1591 ist.  @code{log(1/b} wird f@"ur eine ganze Zahl @code{b} immer vereinfacht.
1592 Hat die Optionsvariable @code{logexpand} den Wert @code{false} werden alle
1593 obigen Vereinfachungen ausgeschaltet.
1594
1595 @item logsimp
1596 Hat die Optionsvariable @code{logsimp} den Wert @code{false}, werden
1597 Exponentialfunktionen @mrefcomma{exp} die Logarithmusfunktionen im Exponenten
1598 enthalten, nicht vereinfacht.
1599
1600 @item lognegint
1601 Hat die Optionsvariable @code{lognegint} den Wert @code{true}, wird
1602 @code{log(-n)} zu @code{log(n)+%i*%pi} f@"ur positive @code{n} vereinfacht.
1603
1604 @item %e_to_numlog
1605 Hat die Optionsvariable @code{%e_to_numlog} den Wert @code{true}, wird ein
1606 Ausdruck @code{%e^(r*log(x))} zu @code{x^r} vereinfacht.  Dabei sind @code{r}
1607 eine rationale Zahl und @code{x} ein beliebiger Ausdruck.  Die Funktion
1608 @code{radcan} f@"uhrt diese Vereinfachung ebenfalls aus.
1609 @end table
1610
1611 Die Logarithmusfunktion wird automatisch auf die Elemente von Listen und
1612 Matrizen sowie auf die beiden Seiten von Gleichungen angewendet.  Siehe
1613 @mrefdot{distribute_over}
1614
1615 Beispiele:
1616
1617 Verschiedene Beispiele mit der Logarithmusfunktion.
1618
1619 @example
1620 (%i1) log(%e);
1621 (%o1)                           1
1622 (%i2) log(100.0);
1623 (%o2)                   4.605170185988092
1624 (%i3) log(2.5+%i);
1625 (%o3)       .3805063771123649 %i + .9905007344332917
1626 (%i4) taylor(log(1+x),x,0,5);
1627                        2    3    4    5
1628                       x    x    x    x
1629 (%o4)/T/          x - -- + -- - -- + -- + . . .
1630                       2    3    4    5
1631 (%i5) rectform(log(x+%i*y));
1632                        2    2
1633                   log(y  + x )
1634 (%o5)             ------------ + %i atan2(y, x)
1635                        2
1636 (%i6) limit(log(x),x,0,plus);
1637 (%o6)                         minf
1638 (%i7) integrate(log(z)^n,z);
1639 @group
1640                                                     - n - 1
1641 (%o7) - gamma_incomplete(n + 1, - log(z)) (- log(z))
1642                                                             n + 1
1643                                                       log(z)
1644 @end group
1645 (%i8) laplace(log(t),t,s);
1646 @group
1647                         - log(s) - %gamma
1648 (%o8)                   -----------------
1649                                 s
1650 @end group
1651 (%i9) depends(y,x);
1652 (%o9)                        [y(x)]
1653 (%i10) ode2(diff(y,x)+log(y)+1,y,x);
1654             - 1
1655 (%o10)    %e    expintegral_e(1, - log(y) - 1) = x + %c
1656 @end example
1657 @end deffn
1658
1659 @c --- 12.03.2011 DK -----------------------------------------------------------
1660 @anchor{logabs}
1661 @defvr {Optionsvariable} logabs
1662 Standardwert: @code{false}
1663
1664 Treten bei der unbestimmten Integration Logarithmusfunktionen im Ergebnis auf,
1665 so wird der Betrag der Argumente der Logarithmusfunktionen gebildet, wenn die
1666 Optionsvariable @code{logabs} den Wert @code{true} hat.
1667
1668 Beispiele:
1669
1670 @example
1671 (%i1) logabs:true;
1672 (%o1)                         true
1673 (%i2) integrate(1/x,x);
1674 (%o2)                      log(abs(x))
1675 (%i3) integrate(1/(1+x^3),x);
1676                                                    2 x - 1
1677             ! 2        !                      atan(-------)
1678         log(!x  - x + 1!)   log(abs(x + 1))        sqrt(3)
1679 (%o3) - ----------------- + --------------- + -------------
1680                 6                  3             sqrt(3)
1681 @end example
1682 @end defvr
1683
1684 @c --- 20.10.2010 DK -----------------------------------------------------------
1685 @anchor{logarc}
1686 @deffn  {Funktion} logarc (@var{expr})
1687 @deffnx {Optionsvariable} logarc
1688
1689 Hat die Optionsvariable @code{logarc} den Wert @code{true}, werden inverse
1690 Winkel- und Hyperbelfunktionen durch Logarithmusfunktionen ersetzt.  Der
1691 Standardwert von @code{logarc} ist @code{false}.
1692
1693 Die Funktion @code{logarc(@var{expr})} f@"uhrt diese Ersetzung aus, ohne dass
1694 die Optionsvariable @code{logarc} gesetzt wird.
1695
1696 Beispiele:
1697
1698 @example
1699 (%i1) logarc(asin(x));
1700                                      2
1701 (%o1)             - %i log(sqrt(1 - x ) + %i x)
1702 (%i2) logarc:true;
1703 (%o2)                         true
1704 (%i3) asin(x);
1705                                      2
1706 (%o3)             - %i log(sqrt(1 - x ) + %i x)
1707 @end example
1708 @end deffn
1709
1710 @c --- 12.03.2011 DK -----------------------------------------------------------
1711 @need 800
1712 @anchor{logconcoeffp}
1713 @defvr {Optionsvariable} logconcoeffp
1714 Standardwert: @code{false}
1715
1716 Der Optionsvariablen @code{logconcoeffp} kann eine Aussagefunktion mit einem
1717 Argument zugewiesen werden, die kontrolliert, welche Koeffizienten von
1718 der Funktion @mref{logcontract} zusammengezogen werden.  Sollen zum Beispiel
1719 Wurzeln generiert werden, kann folgende Aussagefunktion definiert werden:
1720
1721 @example
1722 logconcoeffp:'logconfun$
1723 logconfun(m) := featurep(m,integer) or ratnump(m)$
1724 @end example
1725
1726 Das Kommando @code{logcontract(1/2*log(x))} liefert nun das Ergebnis
1727 @code{log(sqrt(x))}.
1728 @end defvr
1729
1730 @c --- 20.03.2011 DK -----------------------------------------------------------
1731 @anchor{logcontract}
1732 @deffn {Funktion} logcontract (@var{expr})
1733
1734 Der Ausdruck @var{expr} wird rekursiv nach Ausdr@"ucken der Form
1735 @code{a1*log(b1) + a2*log(b2) + c} durchsucht.  Diese werden zu
1736 @code{log(ratsimp(b1^a1 * b2^a2)) + c} transformiert.
1737
1738 @example
1739 (%i1) 2*(a*log(x) + 2*a*log(y))$
1740 (%i2) logcontract(%);
1741                                  2  4
1742 (%o2)                     a log(x  y )
1743 @end example
1744
1745 Wird die Variable @var{n} mit dem Kommando @code{declare(n, integer)} als eine
1746 ganze Zahl deklariert, dann wird  @code{logcontract(2*a*n*log(x))} zu
1747 @code{a*log(x^(2*n))} vereinfacht.  Die Koeffizienten, die zusammengezogen
1748 werden, sind in diesem Fall die Zahl 2 und die Variable @var{n}, welche
1749 die folgende Aussage erf@"ullen @code{featurep(coeff, integer)}.
1750 Der Nutzer kann kontrollieren, welche Koeffizienten zusammengezogen werden.
1751 Dazu wird der Optionsvariablen @mref{logconcoeffp} eine Aussagefunktion mit
1752 einem Argument zugewiesen.  Sollen zum Beispiel Wurzeln generiert werden, kann
1753 folgende Definition verwendet: @code{logconcoeffp: 'logconfun$ logconfun(m) :=
1754 featurep(m,integer) or ratnump(m)$}.  Dann hat das Kommando
1755 @code{logcontract(1/2*log(x))} das Ergebnis @code{log(sqrt(x))}.
1756 @end deffn
1757
1758 @c --- 01.11.2011 DK -----------------------------------------------------------
1759 @anchor{logexpand}
1760 @defvr {Optionsvariable} logexpand
1761 Standardwert: @code{true}
1762
1763 Die Optionsvariable @code{logexpand} kontrolliert die Vereinfachung der
1764 Logarithmusfunktion @mrefdot{log}
1765
1766 Hat @code{logexpand} den Wert @code{true}, wird @code{log(a^b)} zu
1767 @code{b*log(a)} vereinfacht.  Hat @code{logexpand} den Wert @code{all}, wird
1768 zus@"atzlich @code{log(a*b)} zu @code{log(a)+log(b)} vereinfacht.  Mit dem Wert
1769 @code{super} vereinfacht Maxima weiterhin @code{log(a/b)} zu
1770 @code{log(a)-log(b)}, wobei @code{a/b} eine rationale Zahl ist.  @code{log(1/b}
1771 wird f@"ur eine ganze Zahl @code{b} immer vereinfacht.  Hat die Optionsvariable
1772 @code{logexpand} den Wert @code{false} werden alle obigen Vereinfachungen
1773 ausgeschaltet.
1774 @end defvr
1775
1776 @c --- 12.03.2011 DK -----------------------------------------------------------
1777 @anchor{lognegint}
1778 @defvr {Optionsvariable} lognegint
1779 Standardwert: @code{false}
1780
1781 Hat die Optionsvariable @code{lognegint} den Wert @code{true}, wird
1782 @code{log(-n)} zu @code{log(n)+%i*%pi} f@"ur positive @code{n} vereinfacht.
1783 @end defvr
1784
1785 @c --- 12.03.2011 DK -----------------------------------------------------------
1786 @need 800
1787 @anchor{logsimp}
1788 @defvr {Optionsvariable} logsimp
1789 Standardwert: @code{true}
1790
1791 Hat die Optionsvariable @code{logsimp} den Wert @code{false}, werden
1792 Exponentialfunktionen @mrefcomma{exp} die Logarithmusfunktionen im Exponenten
1793 enthalten, nicht vereinfacht.
1794 @end defvr
1795
1796 @c --- 12.03.2011 DK -----------------------------------------------------------
1797 @anchor{plog}
1798 @deffn {Funktion} plog (@var{x})
1799
1800 Gibt den Hauptwert des komplexen nat@"urlichen Logarithmus im Intervall
1801 @code{-%pi} < @code{carg(@var{x})} <= @code{+%pi} zur@"uck.
1802 @end deffn
1803
1804 @c --- 12.03.2011 DK -----------------------------------------------------------
1805 @anchor{rootsconmode}
1806 @defvr {Optionsvariable} rootsconmode
1807 Standardwert: @code{true}
1808
1809 @code{rootsconmode} kontrolliert das Verhalten der Funktion
1810 @code{rootscontract}.  Siehe die Funktion @mref{rootscontract} f@"ur Details.
1811 @end defvr
1812
1813 @c --- 12.03.2011 DK -----------------------------------------------------------
1814 @anchor{rootscontract}
1815 @deffn {Funktion} rootscontract (@var{expr})
1816
1817 Konvertiert Produkte von Wurzeln in Wurzeln von Produkten.  Zum Beispiel hat
1818 @code{rootscontract(sqrt(x)*y^(3/2))} das Ergebnis @code{sqrt(x*y^3)}.
1819
1820 Hat die Optionsvariable @mref{radexpand} den Wert @code{true} und die
1821 Optionsvariable @mref{domain} den Wert @code{real}, das sind die Standardwerte,
1822 wird @code{abs(x)} zu @code{sqrt(x^2)} vereinfacht.  Zum Beispiel hat
1823 @code{rootscontract(abs(x) * sqrt(y))} das Ergebnis @code{sqrt(x^2*y)}.
1824
1825 Die Optionsvariable @mref{rootsconmode} kontrolliert das Ergebnis
1826 folgenderma@ss{}en:
1827
1828 @example
1829 Problem             Wert             Ergebnis
1830                     rootsconmode     rootscontract
1831
1832 x^(1/2)*y^(3/2)     false            sqrt(x*y^3)
1833 x^(1/2)*y^(1/4)     false            sqrt(x)*y^(1/4)
1834 x^(1/2)*y^(1/4)     true             sqrt(x*sqrt(y))
1835 x^(1/2)*y^(1/3)     true             sqrt(x)*y^(1/3)
1836 x^(1/2)*y^(1/4)     all              (x^2*y)^(1/4)
1837 x^(1/2)*y^(1/3)     all              (x^3*y^2)^(1/6)
1838 @end example
1839
1840 Hat @code{rootsconmode} den Wert @code{false}, kontrahiert @code{rootscontract}
1841 nur Faktoren mit rationalen Exponenten, die den gleichen Nenner haben.  Hat
1842 @code{rootsconmode} den Wert @code{all}, wird das kleinste gemeinsame Vielfache
1843 des Nenners der Faktoren verwendet, um die Faktoren zusammenzufassen.
1844
1845 @"Ahnlich wie bei der Funktion @mref{logcontract} werden von
1846 @code{rootscontract} die Argumente unter der Wurzel mit der Funktion
1847 @mref{ratsimp} vereinfacht.
1848
1849 Beispiele:
1850
1851 @example
1852 (%i1) rootsconmode: false$
1853 (%i2) rootscontract (x^(1/2)*y^(3/2));
1854                                    3
1855 (%o2)                      sqrt(x y )
1856 (%i3) rootscontract (x^(1/2)*y^(1/4));
1857                                    1/4
1858 (%o3)                     sqrt(x) y
1859 (%i4) rootsconmode: true$
1860 (%i5) rootscontract (x^(1/2)*y^(1/4));
1861 (%o5)                    sqrt(x sqrt(y))
1862 @group
1863 (%i6) rootscontract (x^(1/2)*y^(1/3));
1864                                    1/3
1865 (%o6)                     sqrt(x) y
1866 @end group
1867 (%i7) rootsconmode: all$
1868 (%i8) rootscontract (x^(1/2)*y^(1/4));
1869                               2   1/4
1870 (%o8)                       (x  y)
1871 (%i9) rootscontract (x^(1/2)*y^(1/3));
1872                              3  2 1/6
1873 (%o9)                      (x  y )
1874 (%i10) rootsconmode: false$
1875 (%i11) rootscontract (sqrt(sqrt(x) + sqrt(1 + x))
1876                     *sqrt(sqrt(1 + x) - sqrt(x)));
1877 (%o11)                          1
1878 (%i12) rootsconmode: true$
1879 (%i13) rootscontract (sqrt(5+sqrt(5)) - 5^(1/4)*sqrt(1+sqrt(5)));
1880 (%o13)                          0
1881 @end example
1882 @end deffn
1883
1884 @c --- 12.03.2011 DK -----------------------------------------------------------
1885 @anchor{sqrt}
1886 @deffn {Funktion} sqrt (@var{z})
1887
1888 Ist die Wurzelfunktion.  Die Wurzelfunktion wird von Maxima sofort zu
1889 @code{@var{x}^(1/2)} vereinfacht und tritt in Ausdr@"ucken nicht auf.
1890
1891 Die Wurzelfunktion ist f@"ur das numerische und symbolische Rechnen geeignet.
1892 Ist das Argument @var{z} der Wurzelfunktion eine Gleitkommazahl, wird ein
1893 numerisches Ergebnis zur@"uckgegeben.  F@"ur ganze und rationale Zahlen wird
1894 die Wurzelfunktion vereinfacht.  Die numerische Berechnung kann mit den
1895 Optionsvariablen und Auswertungsschaltern @mref{numer} und
1896 @mref{float} kontrolliert werden.
1897
1898 Hat die Optionsvariable @mref{radexpand} den Wert @code{true}, werden die
1899 n-ten Wurzeln von Faktoren unter einer Wurzel aus der Wurzel herausgezogen.
1900 So wird zum Beispiel @code{sqrt(16*x^2)} nur dann zu @code{4*x} vereinfacht,
1901 wenn @code{radexpand} den Wert @code{true} hat.
1902
1903 Siehe auch die Funktionen @mref{rootscontract} und @mref{sqrtdenest} f@"ur die
1904 Vereinfachung von Ausdr@"ucken, die die Wurzelfunktion enthalten.
1905
1906 Beispiele:
1907
1908 Verschiedene Beispiele mit der Wurzelfunktion.
1909
1910 @example
1911 (%i1) sqrt(4);
1912 (%o1)                           2
1913 (%i2) sqrt(24);
1914 (%o2)                       2 sqrt(6)
1915 (%i3) sqrt(2.0);
1916 (%o3)                   1.414213562373095
1917 (%i4) taylor(sqrt(1+x),x,0,5);
1918                        2    3      4      5
1919                   x   x    x    5 x    7 x
1920 (%o4)/T/      1 + - - -- + -- - ---- + ---- + . . .
1921                   2   8    16   128    256
1922 (%i5) rectform(sqrt(x+%i*y));
1923            2    2 1/4     atan2(y, x)
1924 (%o5) %i (y  + x )    sin(-----------)
1925                                2
1926                                       2    2 1/4     atan2(y, x)
1927                                   + (y  + x )    cos(-----------)
1928                                                           2
1929 (%i6) integrate(sqrt(t)*(t+1)^-2,t,0,1);
1930                              %pi - 2
1931 (%o6)                        -------
1932                                 4
1933 @end example
1934 @end deffn
1935
1936 @c -----------------------------------------------------------------------------
1937 @node Winkelfunktionen, Hyperbelfunktionen, Wurzel- Exponential- und Logarithmusfunktion, Mathematische Funktionen
1938 @section Winkelfunktionen
1939 @c -----------------------------------------------------------------------------
1940
1941 @menu
1942 * Einf@"uhrung in Winkelfunktionen::
1943 * Funktionen und Variablen f@"ur Winkelfunktionen::
1944 @end menu
1945
1946 @c -----------------------------------------------------------------------------
1947 @node Einf@"uhrung in Winkelfunktionen, Funktionen und Variablen f@"ur Winkelfunktionen, Winkelfunktionen, Winkelfunktionen
1948 @subsection Einf@"uhrung in Winkelfunktionen
1949 @c -----------------------------------------------------------------------------
1950
1951 Maxima kennt viele Winkel- und Hyperbelfunktionen.  Nicht alle Identit@"aten
1952 f@"ur Winkel- und Hyperbelfunktionen sind programmiert, aber es ist m@"oglich
1953 weitere Identit@"aten mit der F@"ahigkeit der Erkennung von Mustern
1954 hinzuzuf@"ugen.
1955
1956 Maxima kennt die folgenden Winkel- und Hyperbelfunktionen sowie deren Inverse:
1957
1958 @verbatim
1959      sin       cos       tan
1960      sec       csc       cot
1961      asin      acos      atan
1962      asec      acsc      acot
1963      sinh      cosh      tanh
1964      sech      csch      coth
1965      asinh     acosh     atanh
1966      asech     acsch     acoth
1967 @end verbatim
1968
1969 @c -----------------------------------------------------------------------------
1970 @node Funktionen und Variablen f@"ur Winkelfunktionen, , Einf@"uhrung in Winkelfunktionen, Winkelfunktionen
1971 @subsection Funktionen und Variablen f@"ur Winkelfunktionen
1972 @c -----------------------------------------------------------------------------
1973
1974 @c --- 12.03.2011 DK -----------------------------------------------------------
1975 @anchor{asin}
1976 @anchor{acos}
1977 @anchor{atan}
1978 @anchor{acot}
1979 @anchor{acsc}
1980 @anchor{asec}
1981 @deffn  {Funktion} asin (@var{z})
1982 @deffnx {Funktion} acos (@var{z})
1983 @deffnx {Funktion} atan (@var{z})
1984 @deffnx {Funktion} acot (@var{z})
1985 @deffnx {Funktion} acsc (@var{z})
1986 @deffnx {Funktion} asec (@var{z})
1987
1988 Die inversen Winkelfunktionen: Arkussinus, Arkuskosinus, Arkustangens,
1989 Arkuskotangens, Arkuskosekans und Arkussekans.
1990
1991 Die inversen Winkelfunktionen sind f@"ur das numerische und symbolische Rechnen
1992 geeignet.  Die inversen Winkelfunktionen k@"onnen f@"ur reelle und komplexe
1993 Gleitkommazahlen in doppelter und in beliebiger Genauigkeit berechnet werden.
1994 Ist das Argument eine ganze oder rationale Zahl, werden die inversen
1995 Winkelfunktionen nicht numerisch berechnet, sondern vereinfacht.  Die numerische
1996 Berechnung kann mit den Optionsvariablen und Auswertungsschaltern
1997 @mref{numer} und @mref{float} erzwungen werden.
1998
1999 Die inversen Winkelfunktionen sind bis auf die Funktionen @code{acos} und
2000 @code{asec} als ungerade definiert.  Die Funktionen @code{acos} und @code{asec}
2001 vereinfachen f@"ur ein negatives Argument @code{-x} zu @code{%pi-acos(x)} und
2002 @code{%pi-asec(x)}.  F@"ur die inversen Winkelfunktion @code{asin}, @code{acos}
2003 und @code{atan} ist die Spiegelsymmetrie f@"ur den Fall implementiert, dass das
2004 komplexe Argument @code{x+%i*y} einen Realteil @code{abs(x)<1} hat.
2005
2006 Ist das Argument @var{z} eine Matrix, eine Liste oder eine Gleichung werden die
2007 inversen Winkelfunktionen auf die Elemente der Matrix, der Liste oder auf die
2008 beiden Seiten der Gleichung angewendet.  Dieses Verhalten wird von der
2009 Optionsvariablen @mref{distribute_over} kontrolliert.
2010
2011 Inverse Winkelfunktionen k@"onnen f@"ur das symbolische Rechnen verwendet
2012 werden.  Maxima kann Ausdr@"ucke mit inversen Winkelfunktionen differenzieren
2013 und integrieren, Grenzwerte bestimmen sowie Gleichungen mit inversen
2014 Winkelfunktionen l@"osen.
2015
2016 Das Argument der inversen Winkelfunktionen kann eine Taylorreihe sein.  In
2017 diesem Fall wird die Taylorreihenentwicklung f@"ur die inverse Winkelfunktion
2018 vollst@"andig ausgef@"uhrt.
2019
2020 Die folgenden Optionsvariablen kontrollieren die Vereinfachung der
2021 inversen Winkelfunktionen:
2022
2023 @table @code
2024 @item distribute_over
2025 Hat die Optionsvariable @mref{distribute_over} den Wert @code{true} und ist das
2026 Argument der inversen Winkelfunktion eine Matrix, Liste oder Gleichung wird die
2027 Funktion auf die Elemente oder beiden Seiten der Gleichung angewendet.  Der
2028 Standardwert ist @code{true}.
2029
2030 @item %piargs
2031 Hat die Optionsvariable @mref{%piargs} den Wert @code{true}, werden die
2032 inversen Winkelfunktionen f@"ur spezielle Werte als Argument vereinfacht.
2033 Der Standardwert ist @code{true}.
2034
2035 @item %iargs
2036 Hat die Optionsvariable @mref{%iargs} den Wert @code{true} und ist das Argument
2037 der inversen Winkelfunktion ein Vielfaches der imagin@"aren Einheit @code{%i}
2038 werden die inversen Winkelfunktionen zu inversen Hyperbelfunktionen vereinfacht.
2039 Der Standardwert ist @code{true}.
2040
2041 @item triginverses
2042 Hat die Optionsvariable @mref{triginverses} den Wert @code{all} und ist das
2043 Argument die entsprechende Winkelfunktion vereinfachen die inversen
2044 Winkelfunktionen, zum Beispiel vereinfacht @code{asin(sin(x))} zu @code{x}.
2045 Der Standardwert ist @code{true} und die Vereinfachung wird nicht vorgenommen.
2046
2047 @item logarc
2048 Hat die Optionsvariable @mref{logarc} den Wert @code{true}, werden inverse
2049 Winkelfunktionen durch Logarithmusfunktionen ersetzt.  Der Standardwert von
2050 @code{logarc} ist @code{false}.
2051 @end table
2052 @end deffn
2053
2054 @c --- 01.06.2011 DK -----------------------------------------------------------
2055 @anchor{atan2}
2056 @deffn {Funktion} atan2 (@var{y}, @var{x})
2057
2058 Ist der Arkustangens mit zwei Argumenten, der in Maxima wie folgt definiert ist:
2059
2060 @verbatim
2061      atan(y/x)           x>0
2062      atan(y/x) + %pi     x<0 und y>=0
2063      atan(y/x) - %pi     x<0 und y<0
2064        %pi / 2           x=0 und y>0
2065      - %pi / 2           x=0 und y<0
2066      nicht definiert     x=0 und y=0
2067 @end verbatim
2068
2069 Mit der obigen Definition ist der Wertebereich des Arkustangens
2070 @code{-%pi < atan2(y,x) <= %pi}.  Alternativ kann der Arkustangens mit zwei
2071 Argumenten definiert werden als
2072
2073 @verbatim
2074                               %i y + x
2075      atan2(y, x) = - %i log(-------------)
2076                                   2    2
2077                             sqrt(y  + x )
2078 @end verbatim
2079
2080 Der Arkustangens ist f@"ur das symbolische und numerische Rechnen geeignet.
2081 F@"ur reelle Argumente @var{x} und @var{y} deren Vorzeichen bestimmt werden
2082 kann, vereinfacht Maxima den Arkustangens wie oben in der Definition angegeben.
2083 Sind beide Argumente Gleitkommazahlen wird ein numerisches Ergebnis berechnet.
2084 Die numerische Berechnung f@"ur komplexe Gleitkommazahlen ist nicht
2085 implementiert.  Weiterhin kennt Maxima die speziellen Werte, wenn eines der
2086 Argumente @var{x} oder @var{y} unendlich ist.  @code{atan2(x, x)} und
2087 @code{atan2(x, -x)} werden von Maxima vereinfacht, wenn Maxima das Vorzeichen
2088 von @var{x} ermitteln kann.
2089
2090 Die Vereinfachung des Arkustangens wird weiterhin von den folgenden
2091 Optionsvariablen kontrolliert:
2092
2093 @table @code
2094 @item distribute_over
2095 Hat die Optionsvariable @mref{distribute_over} den Wert @code{true} und ist das
2096 Argument des Arkustangens eine Matrix, Liste oder Gleichung wird die Funktion
2097 auf die Elemente oder beiden Seiten der Gleichung angewendet.  Der Standardwert
2098 ist @code{true}.
2099
2100 @item trigsign
2101 Hat die Optionsvariable @mref{trigsign} den Wert @code{true}, vereinfacht
2102 Maxima @code{atan2(-y, x)} zu @code{- atan2(y, x)}.  Der Standardwert ist
2103 @code{true}.
2104
2105 @item logarc
2106 Hat die Optionsvariable @mref{logarc} den Wert @code{true}, wird der
2107 Arkustangens durch einen Ausdruck mit der Logarithmusfunktionen ersetzt.
2108 Der Standardwert von @code{logarc} ist @code{false}.
2109 @end table
2110
2111 Maxima kann Ausdr@"ucke mit dem Arkustangens ableiten und integrieren sowie die
2112 Grenzwerte von Ausdr@"ucken mit dem Arkustangens ermitteln.
2113
2114 Beispiele:
2115
2116 @example
2117 (%i1) atan2([-1, 1],[-1, 0, 1]);
2118               3 %pi    %pi    %pi    3 %pi  %pi  %pi
2119 (%o1)     [[- -----, - ---, - ---], [-----, ---, ---]]
2120                 4       2      4       4     2    4
2121 (%i2) atan2(1,[-0.5, 0.5]);
2122 (%o2)         [2.034443935795703, 1.10714871779409]
2123 (%i3) assume(a>0)$
2124
2125 (%i4) atan2(2*a, -2*a);
2126                               3 %pi
2127 (%o4)                         -----
2128                                 4
2129 (%i5) diff(atan2(y,x), x);
2130 @group
2131                                  y
2132 (%o5)                       - -------
2133                                2    2
2134                               y  + x
2135 @end group
2136 (%i6) integrate(atan2(y,x), x);
2137                           2    2
2138                    y log(y  + x )          y
2139 (%o6)              -------------- + x atan(-)
2140                          2                 x
2141 @end example
2142 @end deffn
2143
2144 @c --- 12.03.2011 DK -----------------------------------------------------------
2145 @anchor{sin}
2146 @anchor{cos}
2147 @anchor{tan}
2148 @anchor{cot}
2149 @anchor{csc}
2150 @anchor{sec}
2151 @deffn  {Funktion} sin (@var{z})
2152 @deffnx {Funktion} cos (@var{z})
2153 @deffnx {Funktion} tan (@var{z})
2154 @deffnx {Funktion} cot (@var{z})
2155 @deffnx {Funktion} csc (@var{z})
2156 @deffnx {Funktion} sec (@var{z})
2157
2158 Die Winkelfunktionen: Sinus, Kosinus, Tangens, Kotangens, Kosekans und Sekans.
2159
2160 Die Winkelfunktionen sind f@"ur das numerische und symbolische Rechnen geeignet.
2161 Die Winkelfunktionen k@"onnen f@"ur reelle und komplexe Gleitkommazahlen in
2162 doppelter und in beliebiger Genauigkeit berechnet werden.  Ist das Argument
2163 eine ganze oder rationale Zahl, werden die Winkelfunktionen nicht numerisch
2164 berechnet, sondern vereinfacht.  Die numerische Berechnung kann mit den
2165 Optionsvariablen und Auswertungsschaltern @mref{numer} und @mref{float}@w{}
2166 erzwungen werden.
2167
2168 Die Winkelfunktionen sind gerade oder ungerade und haben Spiegelsymmetrie.
2169 Maxima wendet diese Symmetrieeigenschaften automatisch bei der Vereinfachung
2170 von Ausdr@"ucken mit Winkelfunktionen an.
2171
2172 Ist das Argument @var{z} eine Matrix, eine Liste oder eine Gleichung werden die
2173 Winkelfunktionen auf die Elemente der Matrix, der Liste oder auf die beiden
2174 Seiten der Gleichung angewendet.  Dieses Verhalten wird von der Optionsvariablen
2175 @mref{distribute_over} kontrolliert.
2176
2177 Winkelfunktionen k@"onnen f@"ur das symbolische Rechnen verwendet werden.
2178 Maxima kann Ausdr@"ucke mit Winkelfunktionen differenzieren und integrieren,
2179 Grenzwerte bestimmen sowie Gleichungen und  Differentialgleichungen mit
2180 Winkelfunktionen l@"osen.
2181
2182 Das Argument der Winkelfunktionen kann eine Taylorreihe sein.  In diesem Fall
2183 wird die Taylorreihenentwicklung f@"ur die Winkelfunktion vollst@"andig
2184 ausgef@"uhrt.
2185
2186 Die folgenden Optionsvariablen kontrollieren die Vereinfachung der
2187 Winkelfunktionen:
2188
2189 @table @code
2190 @item distribute_over
2191 Hat die Optionsvariable @mref{distribute_over} den Wert @code{true} und ist das
2192 Argument der Winkelfunktion eine Matrix, Liste oder Gleichung wird die Funktion
2193 auf die Elemente oder beiden Seiten der Gleichung angewendet.  Der Standardwert
2194 ist @code{true}.
2195
2196 @item %piargs
2197 Hat die Optionsvariable @mref{%piargs} den Wert @code{true}, werden die
2198 Winkelfunktionen f@"ur ganzzahlige und halbzahlige Vielfache der Konstanten
2199 @code{%pi} zu speziellen Werten vereinfacht.  Der Standardwert ist @code{true}.
2200
2201 @item %iargs
2202 Hat die Optionsvariable @mref{%iargs} den Wert @code{true} und ist das Argument
2203 der Winkelfunktion ein Vielfaches der imagin@"aren Einheit @code{%i} werden die
2204 Winkelfunktionen zu Hyperbelfunktionen vereinfacht.  Der Standardwert ist
2205 @code{true}.
2206
2207 @item trigsign
2208 Hat die Optionsvariable @mref{trigsign} den Wert @code{true}, werden die gerade
2209 oder ungerade Symmetrie der Winkelfunktionen bei der Vereinfachung angewendet.
2210 Der Standardwert ist @code{true}.
2211
2212 @item triginverses
2213 Hat die Optionsvariable @mref{triginverses} den Wert @code{true} und ist das
2214 Argument eine inverse Winkelfunktion vereinfachen die Winkelfunktionen zu einem
2215 einfachen algebraischen Ausdruck, zum Beispiel vereinfacht @code{sin(acos(x))}
2216 zu @code{sqrt(1-x^2)}.  Der Standardwert ist @code{true}.
2217
2218 @item trigexpand
2219 Hat die Optionsvariable @mref{trigexpand} den Wert @code{true}, dann werden die
2220 Winkelfunktionen f@"ur ein Argument expandiert, das eine Summe oder ein Produkt
2221 mit einer ganzen Zahl ist.  Der Standardwert ist @code{false}.
2222
2223 @item exponentialize
2224 Hat die Optionsvariable @mref{exponentialize} den Wert @code{true}, dann werden
2225 die Winkelfunktionen in eine Exponentialform transformiert.  Der Standardwert
2226 ist @code{false}.
2227
2228 @item halfangles
2229 Hat die Optionsvariable @mref{halfangles} den Wert @code{true}, dann werden die
2230 Winkelfunktionen f@"ur halbzahlige Argumente zu einem @"aquivalenten Ausdruck
2231 transformiert.  Der Standardwert ist @code{false}.
2232 @end table
2233
2234 Beispiele:
2235
2236 Im Folgenden werden Beispiele f@"ur die Sinusfunktion gezeigt.  Numerische
2237 Berechnungen f@"ur Gleitkommazahlen:
2238
2239 @example
2240 (%i1) sin(1+%i);
2241 (%o1)                      sin(%i + 1)
2242 (%i2) sin(1.0+%i);
2243 (%o2)       .6349639147847361 %i + 1.298457581415977
2244 (%i3) sin(1.0b0+%i);
2245 (%o3)     6.349639147847361b-1 %i + 1.298457581415977b0
2246 (%i4) sin(1.0b0),fpprec:45;
2247 (%o4)   8.41470984807896506652502321630298999622563061b-1
2248 @end example
2249
2250 Einige Vereinfachungen der Sinusfunktionen:
2251
2252 @example
2253 (%i5) sin(%i*(x+y));
2254 (%o5)                    %i sinh(y + x)
2255 (%i6) sin(%pi/3);
2256                              sqrt(3)
2257 (%o6)                        -------
2258                                 2
2259 (%i2) sin(x+y),trigexpand:true;
2260 (%o2)             cos(x) sin(y) + sin(x) cos(y)
2261 (%i3) sin(2*x+y),trigexpand:true;
2262            2         2
2263 (%o3)  (cos (x) - sin (x)) sin(y) + 2 cos(x) sin(x) cos(y)
2264 @end example
2265
2266 Grenzwerte, Ableitungen und Integrale mit der Sinusfunktion:
2267
2268 @example
2269 (%i4) limit(sin(x)/x,x,0);
2270 (%o4)                          1
2271 (%i5) diff(sin(sqrt(x))/x,x);
2272                   cos(sqrt(x))   sin(sqrt(x))
2273 (%o5)             ------------ - ------------
2274                         3/2            2
2275                      2 x              x
2276 (%i6) integrate(sin(x^3),x);
2277 @group
2278 (%o6)
2279                          1      3                     1        3
2280         gamma_incomplete(-, %i x ) + gamma_incomplete(-, - %i x )
2281                          3                            3
2282       - ---------------------------------------------------------
2283                                    12
2284 @end group
2285 @end example
2286
2287 Reihenentwicklung der Sinusfunktion:
2288
2289 @example
2290 (%i7) taylor(sin(x),x,0,3);
2291 @group
2292                               3
2293                              x
2294 (%o7)/T/                 x - -- + . . .
2295                              6
2296 @end group
2297 @end example
2298 @end deffn
2299
2300 @c --- 27.11.2010 DK -----------------------------------------------------------
2301 @anchor{%piargs}
2302 @defvr {Optionsvariable} %piargs
2303 Standardwert: @code{true}
2304
2305 Hat @code{%piargs} den Wert @code{true}, werden Winkel- und Hyperbelfunktionen
2306 sowie deren Inverse zu algebraischen Konstanten vereinfacht, wenn das Argument
2307 ein ganzzahliges Vielfaches der folgenden Konstanten ist:
2308 @iftex
2309 @math{\pi}, @math{\pi/2}, @math{\pi/3}, @math{\pi/4} oder @math{\pi/6}.
2310 @end iftex
2311 @ifnottex
2312 @code{%pi}, @code{%pi/2}, @code{%pi/3}, @code{%pi/4} oder @code{%pi/6}.
2313 @end ifnottex
2314
2315 Maxima kennt weiterhin einige Identit@"aten, wenn die Konstante
2316 @iftex
2317 @math{\pi}
2318 @end iftex
2319 @ifnottex
2320 @code{%pi}
2321 @end ifnottex
2322 mit einer Variablen multipliziert wird, die als ganzzahlig deklariert wurde.
2323
2324 Beispiele:
2325
2326 @example
2327 (%i1) %piargs : false$
2328 @group
2329 (%i2) [sin (%pi), sin (%pi/2), sin (%pi/3)];
2330                                 %pi       %pi
2331 (%o2)            [sin(%pi), sin(---), sin(---)]
2332                                  2         3
2333 @end group
2334 @group
2335 (%i3) [sin (%pi/4), sin (%pi/5), sin (%pi/6)];
2336                       %pi       %pi       %pi
2337 (%o3)            [sin(---), sin(---), sin(---)]
2338                        4         5         6
2339 @end group
2340 (%i4) %piargs : true$
2341 @group
2342 (%i5) [sin (%pi), sin (%pi/2), sin (%pi/3)];
2343                                 sqrt(3)
2344 (%o5)                    [0, 1, -------]
2345                                    2
2346 @end group
2347 @group
2348 (%i6) [sin (%pi/4), sin (%pi/5), sin (%pi/6)];
2349                          1         %pi   1
2350 (%o6)                [-------, sin(---), -]
2351                       sqrt(2)       5    2
2352 @end group
2353 @group
2354 (%i7) [cos (%pi/3), cos (10*%pi/3), tan (10*%pi/3),
2355        cos (sqrt(2)*%pi/3)];
2356                 1    1               sqrt(2) %pi
2357 (%o7)          [-, - -, sqrt(3), cos(-----------)]
2358                 2    2                    3
2359 @end group
2360 @end example
2361
2362 Weitere Identit@"aten werden angewendet, wenn
2363 @iftex
2364 @math{\pi} und @math{\pi/2}
2365 @end iftex
2366 @ifnottex
2367 @code{%pi} und @code{%pi/2}
2368 @end ifnottex
2369 mit einer ganzzahligen Variable multipliziert werden.
2370
2371 @example
2372 (%i1) declare (n, integer, m, even)$
2373 @group
2374 (%i2) [sin (%pi * n), cos (%pi * m), sin (%pi/2 * m),
2375        cos (%pi/2 * m)];
2376                                       m/2
2377 (%o2)                  [0, 1, 0, (- 1)   ]
2378 @end group
2379 @end example
2380 @end defvr
2381
2382 @c --- 27.11.2010 DK -----------------------------------------------------------
2383 @anchor{%iargs}
2384 @defvr {Optionsvariable} %iargs
2385 Standardwert: @code{true}
2386
2387 Hat @code{%iargs} den Wert @code{true}, werden Winkelfunktionen zu
2388 Hyperbelfunktionen vereinfacht, wenn das Argument ein Vielfaches der
2389 imagin@"aren Einheit
2390 @iftex
2391 @math{i}
2392 @end iftex
2393 @ifnottex
2394 @code{%i}
2395 @end ifnottex
2396 ist.
2397
2398 Die Vereinfachung zu Hyperbelfunktionen wird auch dann ausgef@"uhrt, wenn das
2399 Argument offensichtlich reell ist.
2400
2401 Beispiele:
2402
2403 @example
2404 (%i1) %iargs : false$
2405 @group
2406 (%i2) [sin (%i * x), cos (%i * x), tan (%i * x)];
2407 (%o2)           [sin(%i x), cos(%i x), tan(%i x)]
2408 @end group
2409 (%i3) %iargs : true$
2410 @group
2411 (%i4) [sin (%i * x), cos (%i * x), tan (%i * x)];
2412 (%o4)           [%i sinh(x), cosh(x), %i tanh(x)]
2413 @end group
2414 @end example
2415
2416 Auch wenn das Argument offensichtlich reell ist, wird zu einer Hyperbelfunktion
2417 vereinfacht.
2418
2419 @example
2420 (%i1) declare (x, imaginary)$
2421 @group
2422 (%i2) [featurep (x, imaginary), featurep (x, real)];
2423 (%o2)                     [true, false]
2424 @end group
2425 @group
2426 (%i3) sin (%i * x);
2427 (%o3)                      %i sinh(x)
2428 @end group
2429 @end example
2430 @end defvr
2431
2432 @c --- 27.11.2010 DK -----------------------------------------------------------
2433 @anchor{halfangles}
2434 @defvr {Optionsvariable} halfangles
2435 Standardwert: @code{false}
2436
2437 Hat @code{halfangles} den Wert @code{true}, werden Winkel- und
2438 Hyperbelfunktionen mit halbzahligen Argumenten @code{@var{expr}/2} vereinfacht.
2439
2440 F@"ur ein reelles Argument @var{x} im Intervall @code{0 < x < 2*%pi} vereinfacht
2441 der Sinus f@"ur ein halbzahliges Argument zu einer einfachen Formel:
2442
2443 @example
2444                          sqrt(1 - cos(x))
2445                          ----------------
2446                              sqrt(2)
2447 @end example
2448
2449 Ein komplizierter Faktor wird gebraucht, damit die Formel korrekt ist f@"ur ein
2450 komplexes Argument @var{z}:
2451
2452 @need 1600
2453 @verbatim
2454            realpart(z)
2455      floor(-----------)
2456               2 %pi
2457 (- 1)                   (1 - unit_step(- imagpart(z))
2458
2459                             realpart(z)            realpart(z)
2460                       floor(-----------) - ceiling(-----------)
2461                                2 %pi                  2 %pi
2462                 ((- 1)                                          + 1))
2463 @end verbatim
2464
2465 Maxima kennt diesen Faktor und @"ahnliche Faktoren f@"ur die Sinus, Kosinus,
2466 Sinus Hyperbolicus und Kosinus Hyperbolicus Funktionen.  F@"ur spezielle
2467 Argumente @math{z} dieser Funktionen vereinfachen diese Funktionen entsprechend.
2468
2469 Beispiele:
2470
2471 @example
2472 (%i1) halfangles:false;
2473 (%o1)                                false
2474 (%i2) sin(x/2);
2475                                         x
2476 (%o2)                               sin(-)
2477                                         2
2478 (%i3) halfangles:true;
2479 (%o3)                                true
2480 (%i4) sin(x/2);
2481                                                     x
2482                                             floor(-----)
2483                                                   2 %pi
2484                       sqrt(1 - cos(x)) (- 1)
2485 (%o4)                 ----------------------------------
2486                                    sqrt(2)
2487 (%i5) assume(x>0, x<2*%pi)$
2488 (%i6) sin(x/2);
2489                                sqrt(1 - cos(x))
2490 (%o6)                          ----------------
2491                                    sqrt(2)
2492 @end example
2493 @end defvr
2494
2495 @c --- 27.11.2010 DK -----------------------------------------------------------
2496 @anchor{ntrig}
2497 @defvr {Paket} ntrig
2498
2499 Das Paket @code{ntrig} enth@"alt Regeln, um Winkelfunktionen zu vereinfachen,
2500 die Argumente der Form @code{@var{f}(@var{n} %pi/10)} haben.  @var{f} ist eine
2501 der Funktionen @code{sin}, @code{cos}, @code{tan}, @code{csc}, @code{sec} oder
2502 @code{cot}.
2503
2504 Das Kommando @code{load("ntrig")} l@"adt das Paket.  Die Vereinfachungen werden
2505 dann von Maxima automatisch ausgef@"uhrt.
2506 @end defvr
2507
2508 @c --- 27.11.2010 DK -----------------------------------------------------------
2509 @anchor{trigexpand}
2510 @deffn {Funktion} trigexpand (@var{expr})
2511
2512 Die Funktion @code{trigexpand} expandiert Winkel- und Hyperbelfunktionen im
2513 Ausdruck @var{expr}, die Summen und Vielfache von Winkeln als Argument haben.
2514 Die besten Ergebnisse werden erzielt, wenn der Ausdruck @var{expr} zun@"achst
2515 expandiert wird.
2516
2517 Folgende Schalter kontrollieren @code{trigexpand}:
2518
2519 @table @code
2520 @item trigexpand
2521 Wenn @code{true}, werden Sinus- und Kosinusfunktionen expandiert.
2522
2523 @item halfangles
2524 Wenn @code{true}, werden Vereinfachungen f@"ur halbzahlige Argumente angewendet.
2525
2526 @item trigexpandplus
2527 Wenn @code{true}, werden Winkelfunktionen, die eine Summe als Argument haben,
2528 wie zum Beispiel @code{sin(x+y)}, vereinfacht.
2529
2530 @item trigexpandtimes
2531 Wenn @code{true},  werden Winkelfunktionen, die ein Produkt als Argument haben,
2532 wie zum Beispiel @code{sin(2 x)}, vereinfacht.
2533 @end table
2534
2535 Beispiele:
2536
2537 @example
2538 @group
2539 (%i1) x+sin(3*x)/sin(x),trigexpand=true,expand;
2540                          2           2
2541 (%o1)               - sin (x) + 3 cos (x) + x
2542 @end group
2543 @group
2544 (%i2) trigexpand(sin(10*x+y));
2545 (%o2)          cos(10 x) sin(y) + sin(10 x) cos(y)
2546 @end group
2547 @end example
2548 @end deffn
2549
2550 @c --- 27.11.2010 DK -----------------------------------------------------------
2551 @anchor{trigexpandplus}
2552 @defvr {Optionsvariable} trigexpandplus
2553 Standardwert: @code{true}
2554
2555 @code{trigexpandplus} kontrolliert die Vereinfachung von Winkelfunktionen mit
2556 der Funktion @mref{trigexpand} f@"ur den Fall, dass Winkelfunktionen mit Summen
2557 als Argumente auftreten.  Hat @code{trigexpandplus} den Wert @code{true},
2558 werden zum Beispiel Winkelfunktionen wie @code{sin(x+y)} vereinfacht.
2559 @end defvr
2560
2561 @c --- 27.11.2010 DK -----------------------------------------------------------
2562 @anchor{trigexpandtimes}
2563 @defvr {Optionsvariable} trigexpandtimes
2564 Standardwert: @code{true}
2565
2566 @code{trigexpandtimes} kontrolliert die Vereinfachung von Winkelfunktionen mit
2567 der Funktion @mref{trigexpand} f@"ur den Fall, dass Winkelfunktionen mit
2568 Produkten als Argumente auftreten.  Hat @code{trigexpandtimes} den Wert
2569 @code{true}, werden zum Beispiel Winkelfunktionen wie @code{sin(2 x)}
2570 vereinfacht.
2571 @end defvr
2572
2573 @c --- 27.11.2010 DK -----------------------------------------------------------
2574 @anchor{triginverses}
2575 @defvr {Optionsvariable} triginverses
2576 Standardwert: @code{true}
2577
2578 Kontrolliert die Vereinfachung, wenn das Argument einer Winkelfunktion oder
2579 Hyperbelfunktion eine der inversen Funktion ist.
2580
2581 Hat @code{triginverses} den Wert @code{all}, vereinfachen beide Ausdr@"ucke
2582 @code{atan(tan(@var{x}))} und @code{tan(atan(@var{x}))} zum Wert @var{x}.
2583
2584 Hat @code{triginverses} den Wert @code{all}, wird
2585 @code{@var{arcfun}(@var{fun}(@var{x}))} nicht vereinfacht.
2586
2587 Hat @code{triginverses} den Wert @code{false}, werden
2588 @code{@var{arcfun}(@var{fun}(@var{x}))} und
2589 @code{@var{fun}(@var{arcfun}(@var{x}))} nicht vereinfacht.
2590 @end defvr
2591
2592 @c --- 27.11.2010 DK -----------------------------------------------------------
2593 @anchor{trigreduce}
2594 @deffn  {Funktion} trigreduce (@var{expr}, @var{x})
2595 @deffnx {Funktion} trigreduce (@var{expr})
2596
2597 Produkte und Potenzen von Winkelfunktionen und den Hyperbelfunktionen mit dem
2598 Argument @var{x} werden zu Funktionen vereinfacht, die Vielfache von @var{x}
2599 enthalten.  @code{trigreduce} versucht auch, Sinus- und Kosinusfunktionen in
2600 einem Nenner zu eliminieren.  Wird keine Variable @var{x} angegeben, werden alle
2601 Variablen im Ausdruck @code{expr} betrachtet.
2602
2603 Siehe auch @mrefdot{poissimp}
2604
2605 @example
2606 @group
2607 (%i1) trigreduce(-sin(x)^2+3*cos(x)^2+x);
2608                cos(2 x)      cos(2 x)   1        1
2609 (%o1)          -------- + 3 (-------- + -) + x - -
2610                   2             2       2        2
2611 @end group
2612 @end example
2613 @end deffn
2614
2615 @c --- 27.11.2010 DK -----------------------------------------------------------
2616 @anchor{trigsign}
2617 @defvr {Optionsvariable} trigsign
2618 Standardwert: @code{true}
2619
2620 Hat @code{trigsign} den Wert @code{true}, werden Winkelfunktionen mit einem
2621 negativem Argument vereinfacht.  Zum Beispiel vereinfacht in diesem Fall
2622 @code{sin(-x)} zu @code{-sin(x)}.
2623 @end defvr
2624
2625 @c --- 27.11.2010 DK -----------------------------------------------------------
2626 @anchor{trigsimp}
2627 @deffn {Funktion} trigsimp (@var{expr})
2628
2629 Wendet die Identit@"aten
2630 @iftex
2631 @tex
2632 $\sin\left(x\right)^2 + \cos\left(x\right)^2 = 1$
2633 @end tex
2634 @end iftex
2635 @ifnottex
2636 @code{sin(x)^2 + cos(x)^2 = 1}
2637 @end ifnottex
2638 und
2639 @iftex
2640 @tex
2641 $\cosh\left(x\right)^2 - \sinh\left(x\right)^2 = 1$
2642 @end tex
2643 @end iftex
2644 @ifnottex
2645 @code{cosh(x)^2 - sinh(x)^2 = 1}
2646 @end ifnottex
2647 an, um Ausdr@"ucke, die Funktionen wie @code{tan}, @code{sec}, usw. enthalten,
2648 zu Ausdr@"ucken mit den Funktionen @code{sin}, @code{cos}, @code{sinh},
2649 @code{cosh} zu vereinfachen.
2650
2651 Die Anwendung von Funktionen wie @mrefcomma{trigreduce} @mref{ratsimp} und
2652 @mref{radcan} kann den Ausdruck weiter vereinfachen.
2653
2654 Das Kommando @code{demo(trgsmp)} zeigt einige Beispiele.
2655 @end deffn
2656
2657 @c -----------------------------------------------------------------------------
2658 @anchor{trigrat}
2659 @deffn {Funktion} trigrat (@var{expr})
2660
2661 Gives a canonical simplifyed quasilinear form of a trigonometrical expression;
2662 @var{expr} is a rational fraction of several @code{sin}, @code{cos} or
2663 @code{tan}, the arguments of them are linear forms in some variables (or
2664 kernels) and @code{%pi/@var{n}} (@var{n} integer) with integer coefficients.
2665 The result is a simplified fraction with numerator and denominator linear in
2666 @code{sin} and @code{cos}.  Thus @code{trigrat} linearize always when it is
2667 possible.
2668
2669 @example
2670 @group
2671 (%i1) trigrat(sin(3*a)/sin(a+%pi/3));
2672 (%o1)            sqrt(3) sin(2 a) + cos(2 a) - 1
2673 @end group
2674 @end example
2675
2676 The following example is taken from
2677 Davenport, Siret, and Tournier, @i{Calcul Formel}, Masson (or in English,
2678 Addison-Wesley), section 1.5.5, Morley theorem.
2679
2680 @example
2681 (%i1) c : %pi/3 - a - b$
2682 (%i2) bc : sin(a)*sin(3*c)/sin(a+b);
2683 @group
2684                                           %pi
2685                   sin(a) sin(3 (- b - a + ---))
2686                                            3
2687 (%o2)             -----------------------------
2688                            sin(b + a)
2689 @end group
2690 (%i3) ba : bc, c=a, a=c;
2691 @group
2692                                          %pi
2693                     sin(3 a) sin(b + a - ---)
2694                                           3
2695 (%o3)               -------------------------
2696                                   %pi
2697                           sin(a - ---)
2698                                    3
2699 @end group
2700 (%i4) ac2 : ba^2 + bc^2 - 2*bc*ba*cos(b);
2701 @group
2702          2         2         %pi
2703       sin (3 a) sin (b + a - ---)
2704                               3
2705 (%o4) ---------------------------
2706                 2     %pi
2707              sin (a - ---)
2708                        3
2709                                        %pi
2710  - (2 sin(a) sin(3 a) sin(3 (- b - a + ---)) cos(b)
2711                                         3
2712              %pi            %pi
2713  sin(b + a - ---))/(sin(a - ---) sin(b + a))
2714               3              3
2715       2       2              %pi
2716    sin (a) sin (3 (- b - a + ---))
2717                               3
2718  + -------------------------------
2719                 2
2720              sin (b + a)
2721 @end group
2722 (%i5) trigrat (ac2);
2723 @group
2724 (%o5) - (sqrt(3) sin(4 b + 4 a) - cos(4 b + 4 a)
2725  - 2 sqrt(3) sin(4 b + 2 a) + 2 cos(4 b + 2 a)
2726  - 2 sqrt(3) sin(2 b + 4 a) + 2 cos(2 b + 4 a)
2727  + 4 sqrt(3) sin(2 b + 2 a) - 8 cos(2 b + 2 a) - 4 cos(2 b - 2 a)
2728  + sqrt(3) sin(4 b) - cos(4 b) - 2 sqrt(3) sin(2 b) + 10 cos(2 b)
2729  + sqrt(3) sin(4 a) - cos(4 a) - 2 sqrt(3) sin(2 a) + 10 cos(2 a)
2730  - 9)/4
2731 @end group
2732 @end example
2733 @end deffn
2734
2735 @c -----------------------------------------------------------------------------
2736 @need 900
2737 @node Hyperbelfunktionen, Zufallszahlen, Winkelfunktionen, Mathematische Funktionen
2738 @section Hyperbelfunktionen
2739 @c -----------------------------------------------------------------------------
2740
2741 @menu
2742 * Einf@"uhrung in Hyperbelfunktionen::
2743 * Funktionen und Variablen f@"ur Hyperbelfunktionen::
2744 @end menu
2745
2746 @c -----------------------------------------------------------------------------
2747 @node Einf@"uhrung in Hyperbelfunktionen, Funktionen und Variablen f@"ur Hyperbelfunktionen, Hyperbelfunktionen, Hyperbelfunktionen
2748 @subsection Einf@"uhrung in Hyperbelfunktionen
2749 @c -----------------------------------------------------------------------------
2750
2751 @c -----------------------------------------------------------------------------
2752 @node Funktionen und Variablen f@"ur Hyperbelfunktionen, , Einf@"uhrung in Hyperbelfunktionen, Hyperbelfunktionen
2753 @subsection Funktionen und Variablen f@"ur Hyperbelfunktionen
2754
2755 @c --- 20.10.2010 DK -----------------------------------------------------------
2756 @anchor{asinh}
2757 @anchor{acosh}
2758 @anchor{atanh}
2759 @anchor{acoth}
2760 @anchor{acsch}
2761 @anchor{asech}
2762 @deffn  {Funktion} asinh (@var{x})
2763 @deffnx {Funktion} acosh (@var{x})
2764 @deffnx {Funktion} atanh (@var{x})
2765 @deffnx {Funktion} acoth (@var{x})
2766 @deffnx {Funktion} acsch (@var{x})
2767 @deffnx {Funktion} asech (@var{x})
2768
2769 Die inversen Hyperbelfunktionen: Areasinus Hyperbolicus, Areakosinus
2770 Hyperbolicus, Areatangens Hyperbolicus, Areakotangens Hyperbolicus, Areakosekans
2771 Hyperbolicus, Areasekans Hyperbolicus.
2772 @end deffn
2773
2774 @c --- 20.10.2010 DK -----------------------------------------------------------
2775 @anchor{sinh}
2776 @anchor{cosh}
2777 @anchor{tanh}
2778 @anchor{coth}
2779 @anchor{csch}
2780 @anchor{sech}
2781 @deffn  {Funktion} sinh (@var{x})
2782 @deffnx {Funktion} cosh (@var{x})
2783 @deffnx {Funktion} tanh (@var{x})
2784 @deffnx {Funktion} coth (@var{x})
2785 @deffnx {Funktion} csch (@var{x})
2786 @deffnx {Funktion} sech (@var{x})
2787
2788 Die Hyperbelfunktionen: Sinus Hyperbolicus, Kosinus Hyperbolicus, Tangens
2789 Hyperbolicus, Kotangens Hyperbolicus, Kosekans Hyperbolicus, Sekans
2790 Hyperbolicus.
2791 @end deffn
2792
2793 @c -----------------------------------------------------------------------------
2794 @node Zufallszahlen, , Hyperbelfunktionen, Mathematische Funktionen
2795 @section Zufallszahlen
2796 @c -----------------------------------------------------------------------------
2797
2798 @c -----------------------------------------------------------------------------
2799 @anchor{make_random_state}
2800 @deffn  {Funktion} make_random_state (@var{n})
2801 @deffnx {Funktion} make_random_state (@var{s})
2802 @deffnx {Funktion} make_random_state (true)
2803 @deffnx {Funktion} make_random_state (false)
2804
2805 Ein Zufallszustand repr@"asentiert den Zustand des Zufallszahlengenerators.  Der
2806 Zustand enth@"alt 627 32-Bit Worte.
2807
2808 @code{make_random_state(@var{n})} gibt einen neuen Zufallszustand zur@"uck, der
2809 aus einer ganzen Zahl @var{n} modulo 2^32 erzeugt wird.  @var{n} kann eine
2810 negative Zahl sein.
2811
2812 @code{make_random_state(@var{s})} gibt eine Kopie des Zufallszutandes @var{s}
2813 zur@"uck.
2814
2815 @code{make_random_state(true)} gibt einen neuen Zufallszustand zur@"uck, der aus
2816 der aktuellen Systemzeit des Computers erzeugt wird.
2817
2818 @code{make_random_state(false)} gibt eine Kopie des aktuellen Zustands des
2819 Zufallszahlengenerators zur@"uck.
2820 @end deffn
2821
2822 @c -----------------------------------------------------------------------------
2823 @anchor{set_random_state}
2824 @deffn {Funktion} set_random_state (@var{s})
2825
2826 Kopiert @var{s} in den Zufallszustand des Zufallszahlengenerators.
2827
2828 @code{set_random_state} gibt immer @code{done} zur@"uck.
2829 @end deffn
2830
2831 @c -----------------------------------------------------------------------------
2832 @anchor{random}
2833 @deffn {Funktion} random (@var{x})
2834
2835 Erzeugt eine Pseudo-Zufallszahl.  Ist @var{x} eine ganze Zahl, gibt
2836 @code{random(@var{x})} eine ganze Zahl im Intervall 0 bis einschlie@ss{}lich
2837 @code{@var{x}-1} zur@"uck.  Ist @var{x} eine Gleitkommazahl, gibt
2838 @code{random(@var{x})} eine positive Gleitkommazahl zur@"uck, die kleiner als
2839 @var{x} ist.  @code{random} gibt eine Fehlermeldung, wenn @var{x} weder eine
2840 ganze Zahl noch eine Gleitkommazahl ist oder wenn @var{x} eine negative Zahl
2841 ist.
2842
2843 Die Funktionen @code{make_random_state} und @code{set_random_state} verwalten
2844 den Zustand des Zufallszahlengenerators.
2845
2846 Der Maxima-Zufallszahlengenerator ist eine Implementation des Mersenne twister
2847 MT 19937.
2848
2849 Beispiele:
2850
2851 @example
2852 (%i1) s1: make_random_state (654321)$
2853 (%i2) set_random_state (s1);
2854 (%o2)                         done
2855 (%i3) random (1000);
2856 (%o3)                          768
2857 (%i4) random (9573684);
2858 (%o4)                        7657880
2859 (%i5) random (2^75);
2860 (%o5)                11804491615036831636390
2861 (%i6) s2: make_random_state (false)$
2862 (%i7) random (1.0);
2863 (%o7)                   .2310127244107132
2864 (%i8) random (10.0);
2865 (%o8)                   4.394553645870825
2866 (%i9) random (100.0);
2867 (%o9)                   32.28666704056853
2868 (%i10) set_random_state (s2);
2869 (%o10)                        done
2870 (%i11) random (1.0);
2871 (%o11)                  .2310127244107132
2872 (%i12) random (10.0);
2873 (%o12)                  4.394553645870825
2874 (%i13) random (100.0);
2875 (%o13)                  32.28666704056853
2876 @end example
2877 @end deffn
2878
2879 @c --- End of file MathFunctions.de.texi ---------------------------------------
2880