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

@page
@c -----------------------------------------------------------------------------
@node Funktionen und Variablen f@"ur Konstante, Listen, Zeichenketten, Datentypen und Strukturen
@section Funktionen und Variablen f@"ur Konstante
@c -----------------------------------------------------------------------------

@c --- 25.03.2011 DK -----------------------------------------------------------
@anchor{%e}
@defvr {Konstante} %e
@ifinfo
@vrindex e
@vrindex Eulersche Zahl
@vrindex Basis des nat@"urlichen Logarithmus
@end ifinfo

@code{%e} ist die Basis des nat@"urlichen Logarithmus, auch Eulersche Zahl 
genannt.  Der numerische Wert der Konstanten als Gleitkommazahl mit doppelter
Genauigkeit ist 2.718281828459045d0.

Die Funktion @mref{bfloat} kann @code{%e} mit einer beliebigen Genauigkeit
berechnen.

Hat die Optionsvariable @mref{numer} den Wert @code{true}, wird @code{%e} durch
den numerischen Wert ersetzt, aber nicht, wenn @code{%e} die Basis der
Exponentiation mit einem symbolischen Exponenten ist.  Hat zus@"atzlich die
Optionsvariable @mref{%enumer} den Wert @code{true}, dann wird @code{%e} in
einem Ausdruck immer durch den numerischen Wert ersetzt.

Beispiel:

Berechnung von @code{%e} auf 48 Stellen.

@example
(%i1) fpprec: 48$
(%i2) bfloat(%e);
(%o2)  2.7182818284590452353602874713526624977572470937b0
@end example

Die Wirkung der Optionsvariablen @code{numer} und @code{%enumer} auf das 
Ersetzen von @code{%e} durch den numerischen Wert.

@example
(%i1) %e, numer;
(%o1)                   2.718281828459045
(%i2) %e^x, numer;
                                 x
(%o2)                          %e
(%i3) %e^x, numer, %enumer;
                                        x
(%o3)                  2.718281828459045
@end example

Im ersten Beispiel vereinfacht die Reihe zu @code{%e}.  F@"ur die Vereinfachung
der Reihe wird die Funktion @mref{simplify_sum} geladen.  Im zweiten Beispiel
ist @code{%e} der Grenzwert.

@example
(%i1) load(simplify_sum)$

(%i2) sum(1/n!, n, 0, inf);
                            inf
                            ====
                            \     1
(%o2)                        >    --
                            /     n!
                            ====
                            n = 0
(%i3) simplify_sum(%);

(%o3)                          %e

(%i4) limit((1+x)^(1/x), x, 0);
(%o4)                          %e
@end example
@end defvr

@c --- 25.03.2011 DK -----------------------------------------------------------
@anchor{%i}
@defvr {Konstante} %i
@ifinfo
@vrindex i
@vrindex Imagin@"are Einheit
@end ifinfo

@code{%i} ist die imagin@"are Einheit.

Maxima kennt keinen eigenen Typ f@"ur komplexe Zahlen.  Komplexe Zahlen werden 
von Maxima intern als die Addition von Realteil und dem mit der imagin@"aren 
Einheit @mref{%i} multiplizierten Imagin@"arteil dargestellt.  Zum Beispiel sind
die komplexen Zahlen @code{2 + 3*%i} und @code{2 - 3*%i} die Wurzeln der 
Gleichung @code{x^2 - 4*x + 13 = 0}.  Siehe auch das Kapitel
@nrefdot{Zahlen}

Beispiele:

Einige Beispiele f@"ur das Rechnen mit der imagin@"aren Einheit.

@example
(%i1) sqrt(-1);
(%o1)                          %i
(%i2) %i^2;
(%o2)                          - 1
(%i3) exp(%i*%pi/2);
(%o3)                          %i
(%i4) sin(%i*x);
(%o4)                      %i sinh(x)
@end example
@end defvr

@c --- 25.03.2011 DK -----------------------------------------------------------
@anchor{false}
@defvr {Konstante} false

Repr@"asentiert den logischen Wert @code{falsch}.  @code{false} wird intern
von Maxima durch die Lisp-Konstante @code{NIL} dargestellt.

Siehe auch @mref{true} f@"ur den logischen Wert @code{wahr}.
@end defvr

@c --- 25.03.2011 DK -----------------------------------------------------------
@anchor{%gamma}
@defvr {Konstante} %gamma
@ifinfo
@vrindex Euler-Mascheroni-Konstante
@end ifinfo

Die Euler-Mascheroni-Konstante mit dem Wert @code{0.5772156649015329} als
Gleitkommazahl in doppelter Genauigkeit.

Die Funktion @mref{bfloat} kann @code{%gamma} mit einer beliebigen Genauigkeit
berechnen.

Hat die Optionsvariable @mref{numer} den Wert @code{true}, wird die Konstante
@code{%gamma} durch ihren numerischen Wert ersetzt.  

Beispiele:

Numerische Werte f@"ur @code{%gamma}.

@example
(%i1) %gamma, numer;
(%o1)                   .5772156649015329
(%i2) bfloat(%gamma), fpprec: 48;
(%o2)  5.7721566490153286060651209008240243104215933594b-1
@end example

Bestimmte Integrale, die @code{%gamma} als Ergebnis haben.

@example
(%i1) -integrate(exp(-t)*log(t), t, 0, inf);
(%o1)                        %gamma
(%i2) -integrate(log(log(1/t)),t, 0,1);
(%o2)                        %gamma
@end example
@end defvr

@c --- 25.03.2011 DK -----------------------------------------------------------
@anchor{ind}
@defvr {Konstante} ind
@ifinfo
@vrindex Unbestimmt
@end ifinfo

@code{ind} repr@"asentiert ein unbestimmtes Ergebnis.  Siehe auch @mref{und}@w{}
und die Funktion @mrefdot{limit}

Beispiel:

@example
(%i1) limit(sin(1/x), x, 0);
(%o1)                          ind
@end example
@end defvr

@c --- 25.03.2011 DK -----------------------------------------------------------
@anchor{inf}
@defvr {Konstante} inf
@ifinfo
@vrindex positiv unendlich
@end ifinfo

@code{inf} repr@"asentiert einen positiven unendlich gro@ss{}en Wert.  Siehe
auch @mref{minf} und @mrefdot{infinity}

Die unendlichen Gr@"o@ss{}en, aber auch die unbestimmten Gr@"o@ss{}en
@mref{ind} und @mrefcomma{und} eignen sich nicht f@"ur das arithmetische
Rechnen.  Diese Gr@"o@ss{}en werden von Maxima in Rechnungen
wie Symbole behandelt, was zu fehlerhaften Ergebnissen f@"uhrt.  Daher sollten
unendliche Gr@"o@ss{}en nur im Zusammenhang mit Grenzwerten
@mrefcomma{limit} bestimmten Integralen @mref{integrate} oder Reihen
@mref{sum} verwendet werden.
@end defvr

@c --- 25.03.2011 DK -----------------------------------------------------------
@anchor{infinity}
@defvr {Konstante} infinity
@ifinfo
@vrindex komplex unendlich
@end ifinfo

@code{infinity} repr@"asentiert einen komplexen unendlichen Wert.  Siehe
auch @mref{inf} und @mrefdot{minf}

Die unendlichen Gr@"o@ss{}en, aber auch die unbestimmten Gr@"o@ss{}en 
@mref{ind} und @mrefcomma{und} eignen sich nicht f@"ur das arithmetische 
Rechnen.  Diese Gr@"o@ss{}en werden von Maxima in Rechnungen
wie Symbole behandelt, was zu fehlerhaften Ergebnissen f@"uhrt.  Daher sollten
unendliche Gr@"o@ss{}en nur im Zusammenhang mit Grenzwerten
@mrefcomma{limit} bestimmten Integralen @mref{integrate} oder Reihen
@mref{sum} verwendet werden.
@end defvr

@c --- 25.03.2011 DK -----------------------------------------------------------
@anchor{minf}
@defvr {Konstante} minf
@ifinfo
@vrindex negativ unendlich
@vrindex minus unendlich
@end ifinfo

@code{minf} repr@"asentiert einen negativen unendlichen Wert.  Siehe
auch @mref{inf} und @mrefdot{infinity}

Die unendlichen Gr@"o@ss{}en, aber auch die unbestimmten Gr@"o@ss{}en 
@mref{ind} und @mrefcomma{und} eignen sich nicht f@"ur das arithmetische 
Rechnen.  Diese Gr@"o@ss{}en werden von Maxima in Rechnungen
wie Symbole behandelt, was zu fehlerhaften Ergebnissen f@"uhrt.  Daher sollten
unendliche Gr@"o@ss{}en nur im Zusammenhang mit Grenzwerten 
@mrefcomma{limit} bestimmten Integralen @mref{integrate} oder Reihen
@mref{sum} verwendet werden.
@end defvr

@c --- 25.03.2011 DK -----------------------------------------------------------
@anchor{%phi}
@defvr {Konstante} %phi
@ifinfo
@vrindex phi
@vrindex Goldene Zahl
@end ifinfo

@code{%phi} repr@"asentiert die @i{Goldene Zahl} @math{(1 + sqrt(5))/2}.  Der
Wert als Gleitkommazahl in doppelter Genauigkeit ist 1.618033988749895d0.

Die Funktion @mref{fibtophi} dr@"uckt Fibonacci-Zahlen @code{fib(n)} durch die
Goldene Zahl @code{%phi} aus.  Stan@-dard@-m@"a@ss{}ig kennt Maxima keine
algebraischen Eigenschaften der Konstanten @code{%phi}.  Mit den Eingaben
@code{tellrat(%phi^2-%phi-1)} und @code{algebraic: true} kann die Funktion
@mref{ratsimp} einige Vereinfachungen ausf@"uhren.

Die Funktion @mref{bfloat} kann @code{%phi} mit einer beliebigen Genauigkeit
berechnen.  Hat die Optionsvariable @mref{numer} den Wert @code{true}, wird
die Konstante @code{%phi} durch ihren numerischen Wert ersetzt.

Beispiele:

Numerische Werte f@"ur @code{%phi}.

@example
(%i1) %phi, numer;
(%o1)                   1.618033988749895
(%i2) bfloat(%phi), fpprec: 48;
(%o2)  1.61803398874989484820458683436563811772030917981b0
@end example

@code{fibtophi} dr@"uckt Fibonacci-Zahlen @code{fib(n)} durch @code{%phi} aus.

@example
(%i1) fibtophi (fib (n));
                           n             n
                       %phi  - (1 - %phi)
(%o1)                  -------------------
                           2 %phi - 1
(%i2) fib (n-1) + fib (n) - fib (n+1);
(%o2)          - fib(n + 1) + fib(n) + fib(n - 1)
(%i3) fibtophi (%);
@group
            n + 1             n + 1       n             n
        %phi      - (1 - %phi)        %phi  - (1 - %phi)
(%o3) - --------------------------- + -------------------
                2 %phi - 1                2 %phi - 1
                                          n - 1             n - 1
                                      %phi      - (1 - %phi)
                                    + ---------------------------
                                              2 %phi - 1
@end group
(%i4) ratsimp (%);
(%o4)                           0
@end example

Mit den Eingaben @code{tellrat(%phi^2-%phi-1)} und @code{algebraic:true} kann 
die Funktion @code{ratsimp} einige Vereinfachungen f@"ur Ausdr@"ucke 
ausf@"uhren, die @code{%phi} enthalten.

@example
(%i1) e : expand ((%phi^2 - %phi - 1) * (A + 1));
                 2                      2
(%o1)        %phi  A - %phi A - A + %phi  - %phi - 1
(%i2) ratsimp (e);
                  2                     2
(%o2)        (%phi  - %phi - 1) A + %phi  - %phi - 1
(%i3) tellrat (%phi^2 - %phi - 1);
                            2
(%o3)                  [%phi  - %phi - 1]
(%i4) algebraic : true;
(%o4)                         true
(%i5) ratsimp (e);
(%o5)                           0
@end example
@end defvr

@c --- 25.03.2011 DK -----------------------------------------------------------
@anchor{%pi}
@defvr {Konstante} %pi
@ifinfo
@vrindex Pi
@end ifinfo

@code{%pi} repr@"asentiert die Kreiszahl.  Der numerische Wert als 
Gleitkommazahl in doppelter Genauigkeit ist @code{3.141592653589793d0}.

Die Funktion @mref{bfloat} kann @code{%pi} mit einer beliebigen Genauigkeit
berechnen.  Hat die Optionsvariable @mref{numer} den Wert @code{true}, wird die
Konstante @code{%pi} durch ihren numerischen Wert ersetzt.

Beispiele:

Numerische Werte f@"ur @code{%pi}.

@example
(%i1) %pi, numer;
(%o1)                   3.141592653589793
(%i2) bfloat(%pi), fpprec:48;
(%o2)  3.14159265358979323846264338327950288419716939938b0
@end example

Grenzwert und bestimmte Integrale, die @code{%pi} als Ergebnis haben.

@example
(%i1) 'limit(n!^2*(n+1)^(2*n^2+n)/(2*n^(2*n^2+3*n+1)),n,inf);
                        2                     2
                   - 2 n  - 3 n - 1        2 n  + n   2
         limit    n                 (n + 1)         n!
         n -> inf
(%o1)    ----------------------------------------------
                               2
(%i2) %, nouns;
(%o2)                          %pi
(%i3) 'integrate(4*sqrt(1-t^2),t,0,1);
                         1
                        /
                        [            2
(%o3)                 4 I  sqrt(1 - t ) dt
                        ]
                        /
                         0
(%i4) %, nouns;
(%o4)                          %pi
(%i5) 'integrate(2*exp(-t^2),t,0,inf);
                           inf
                          /         2
                          [      - t
(%o5)                   2 I    %e     dt
                          ]
                          /
                           0
(%i6) %, nouns;
(%o6)                       sqrt(%pi)
@end example
@end defvr

@c --- 25.03.2011 DK -----------------------------------------------------------
@anchor{true}
@defvr {Konstante} true

@code{true} repr@"asentiert den logischen Wert @code{wahr}.  Intern ist 
@code{true} als die Lisp-Konstante @code{T} implementiert.

Siehe auch @mref{false} f@"ur den logischen Wert @code{falsch}.
@end defvr

@c --- 25.03.2011 DK -----------------------------------------------------------
@anchor{und}
@defvr {Konstante} und
@ifinfo
@vrindex nicht definiert
@end ifinfo

@code{und} repr@"asentiert ein nicht definiertes Ergebnis.  Siehe auch 
@mref{ind} und die Funktion @mrefdot{limit}

Beispiel:

@example
(%i1) limit (x*sin(x), x, inf);
(%o1)                          und
@end example
@end defvr

@c --- 21.08.2010 DK -----------------------------------------------------------
@anchor{zeroa}
@defvr {Konstante} zeroa

@code{zeroa} repr@"asentiert eine positive unendlich kleine Zahl.  @code{zeroa}
kann in Ausdr@"ucken benutzt werden.  Die Funktion @code{limit} vereinfacht
Ausdr@"ucke, die infinitesimale Gr@"o@ss{}en enthalten.

Siehe auch @mref{zerob} und @mrefdot{limit}

Beispiele:

@code{limit} vereinfacht Ausdr@"ucke, die infinitesimale Gr@"o@ss{}en enthalten.

@example
(%i1) limit(zeroa);
(%o1)                           0
(%i2) limit(x+zeroa);
(%o2)                           x
@end example
@end defvr

@c --- 15.10.2010 DK -----------------------------------------------------------
@anchor{zerob}
@defvr {Konstante} zerob

@code{zerob} repr@"asentiert eine negative unendlich kleine Zahl.  @code{zerob}
kann in Ausdr@"ucken benutzt werden.  Die Funktion @code{limit} vereinfacht
Ausdr@"ucke, die infinitesimale Gr@"o@ss{}en enthalten.

Siehe auch @mref{zeroa} und @mrefdot{limit}
@end defvr

@c --- End of file Constants.de.texi -------------------------------------------

