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

@menu
* Zahlen::
* Zeichenketten::
* Funktionen und Variablen f@"ur Konstante::
* Listen::
* Arrays::
* Strukturen::
@end menu

@c -----------------------------------------------------------------------------
@node Zahlen, Zeichenketten, Datentypen und Strukturen, Datentypen und Strukturen
@section Zahlen
@c -----------------------------------------------------------------------------

@menu
* Einf@"uhrung in Zahlen::
* Funktionen und Variablen f@"ur Zahlen::
@end menu

@c -----------------------------------------------------------------------------
@node Einf@"uhrung in Zahlen, Funktionen und Variablen f@"ur Zahlen, Zahlen, Zahlen
@subsection Einf@"uhrung in Zahlen
@c -----------------------------------------------------------------------------

@subheading Ganze und rationale Zahlen

Arithmetische Rechnungen mit ganzen oder rationalen Zahlen sind exakt.
Prinzipiell k@"onnen die ganzen und rationalen Zahlen eine beliebige Anzahl an 
Stellen haben.  Eine Obergrenze ist allein der zur Verf@"ugung stehende
Speicherplatz.

@example
(%i1) 1/3+5/4+3;
                               55
(%o1)                          --
                               12
(%i2) 100!;
(%o2) 9332621544394415268169923885626670049071596826438162146859\
2963895217599993229915608941463976156518286253697920827223758251\
185210916864000000000000000000000000
(%i3) 100!/101!;
                                1
(%o3)                          ---
                               101
@end example

Funktionen f@"ur ganze und rationale Zahlen:

@verbatim
   integerp       numberp       nonnegintegerp     
   oddp           evenp
   ratnump        rationalize
@end verbatim

@subheading Gleitkommazahlen

Maxima rechnet mit Gleitkommazahlen in doppelter Genauigkeit.  Weiterhin kann
Maxima mit gro@ss{}en Gleitkommazahlen rechnen, die prinzipiell eine beliebige
Genauigkeit haben.

Gleitkommazahlen werden mit einem Dezimalpunkt eingegeben.  Der Exponent kann 
mit "f", "e" oder "d" angegeben werden.  Intern rechnet Maxima
ausschlie@ss{}lich mit Gleitkommazahlen in doppelter Genauigkeit, die immer mit
"e" f@"ur den Exponenten angezeigt werden.  Gro@ss{}e Gleitkommazahlen werden
mit dem Exponenten "b" bezeichnet.  Gro@ss{}- und Kleinschreibung werden bei der
Schreibweise des Exponenten nicht unterschieden.

@example
(%i1) [2.0,1f10,1,e10,1d10,1d300];
(%o1)        [2.0, 1.e+10, 1, e10, 1.e+10, 1.e+300]
(%i2) [2.0b0,1b10,1b300];
(%o2)               [2.0b0, 1.0b10, 1.0b300]
@end example

@noindent
Ist mindestens eine Zahl in einer Rechnung eine Gleitkommazahl, werden die 
Argumente in Gleitkommazahlen umgewandelt und eine Gleitkommazahl als Ergebnis
zur@"uckgegeben.  Dies wird auch f@"ur gro@ss{}e Gleitkommazahlen ausgef@"uhrt.

@example
(%i1) 2.0+1/2+3;
(%o1)                                 5.5
(%i2) 2.0b0+1/2+3;
(%o2)                                5.5b0
@end example

@noindent
Mit den Funktionen @mref{float} und @mref{bfloat} werden Zahlen in
Gleitkommazahlen und gro@ss{}e Gleitkommazahlen umgewandelt:

@example
(%i1) float([2,1/2,1/3,2.0b0]);
(%o1)          [2.0, 0.5, .3333333333333333, 2.0]
(%i2) bfloat([2,1/2,1/3,2.0b0]);
(%o2)     [2.0b0, 5.0b-1, 3.333333333333333b-1, 2.0b0]
@end example

@noindent
Funktionen und Variablen f@"ur Gleitkommazahlen:

@verbatim
   float        floatnump     
   bfloat       bfloatp       fpprec
   float2bf     bftorat       ratepsilon

   number_pbranch 
   m1pbranch
@end verbatim

@subheading Komplexe Zahlen

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}.

Maxima vereinfacht Produkte, Quotienten, Wurzeln und andere Ausdr@"ucke mit 
komplexen Zahlen nicht automatisch zu einer komplexen Zahl.  Um Produkte mit
komplexen Zahlen zu vereinfachen, kann der Ausdruck mit der Funktion 
@mref{expand} expandiert werden.

Funktionen f@"ur komplexe Zahlen:

@verbatim
   realpart     imagpart      rectform     polarform
   cabs         carg          conjugate    csign
@end verbatim

@c -----------------------------------------------------------------------------
@node Funktionen und Variablen f@"ur Zahlen, , Einf@"uhrung in Zahlen, Zahlen
@subsection Funktionen und Variablen f@"ur Zahlen
@c -----------------------------------------------------------------------------

@c --- 17.02.2011 DK -----------------------------------------------------------
@anchor{bfloat}
@deffn {Funktion} bfloat (@var{expr})

Konvertiert alle Zahlen im Ausdruck @var{expr} in gro@ss{}e Gleitkommazahlen.
Die Anzahl der Stellen wird durch die Optionsvariable 
@mref{fpprec} spezifiziert.

Hat die Optionsvariable @mref{float2bf} den Wert @code{false}, gibt Maxima eine
Warnung aus, wenn eine Gleitkommazahl mit doppelter Genauigkeit in eine 
gro@ss{}e Gleitkommazahl umgewandelt wird.

Siehe auch die Funktion und den Auswertungsschalter @mref{float} sowie die
Optionsvariable @mref{numer} f@"ur die Umwandlung von Zahlen in Gleitkommazahlen
mit doppelter Genauigkeit.

Beispiele:

@example
(%i1) bfloat([2, 3/2, 1.5]);
(%o1)                 [2.0b0, 1.5b0, 1.5b0]
(%i2) bfloat(sin(1/2));
(%o2)                  4.79425538604203b-1
(%i3) bfloat(%pi),fpprec:45;
(%o3)    3.1415926535897932384626433832795028841971694b0
@end example
@end deffn

@c --- 17.02.2011 DK -----------------------------------------------------------
@anchor{bfloatp}
@deffn {Funktion} bfloatp (@var{number})

Gibt den Wert @code{true} zur@"uck, wenn das Argument @var{number} eine
gro@ss{}e Gleitkommazahl ist, ansonsten den Wert @code{false}.

Siehe auch die Funktionen @mrefcomma{numberp} @mrefcomma{floatnump}@w{}
@mref{ratnump} und @mrefdot{integerp}

Beispiele:

@example
(%i1) bfloatp(1.5b0);
(%o1)                         true
(%i2) a:bfloat(%e);
(%o2)                  2.718281828459045b0
(%i3) bfloatp(a);
(%o3)                         true
(%i4) bfloatp(1.5);
(%o4)                         false
@end example
@end deffn

@c --- 03.11.2011 DK -----------------------------------------------------------
@anchor{bftorat}
@defvr {Optionsvariable} bftorat
Standardwert: @code{false}

Die Optionsvariable @code{bftorat} kontrolliert die Umwandlung von gro@ss{}en
Gleitkommazahlen in rationale Zahlen.  Hat @code{bftorat} den Wert @code{false},
wird die Genauigkeit der Umwandlung von der Optionsvariablen
@mref{ratepsilon} kontrolliert.  Hat dagegen @code{bftorat} den Wert
@code{true}, wird die gro@ss{}e Gleitkommazahl exakt durch die rationale Zahl 
repr@"asentiert.

Hinweis: @code{bftorat} hat keinen Einfluss auf die Umwandlung in rationale
Zahlen mit der Funktion @mrefdot{rationalize}

Beispiel:

@example
(%i1) ratepsilon:1e-4;
(%o1)                         1.e-4
(%i2) rat(bfloat(11111/111111)), bftorat:false;
`rat' replaced 9.99990999991B-2 by 1/10 = 1.0B-1
                               1
(%o2)/R/                       --
                               10
(%i3) rat(bfloat(11111/111111)), bftorat:true;
`rat' replaced 9.99990999991B-2 by 11111/111111 = 9.99990999991B-2
                             11111
(%o3)/R/                     ------
                             111111
@end example
@end defvr

@c --- 17.02.2011 DK -----------------------------------------------------------
@anchor{bftrunc}
@defvr {Optionsvariable} bftrunc
Standardwert: @code{true}

Hat die Optionsvariable @code{bftrunc} den Wert @code{true}, werden bei der
Ausgabe einer gro@ss{}en Gleitkommazahl nachfolgende Nullen nicht angezeigt.

Beispiele:

@example
(%i1) bftrunc:true;
(%o1)                         true
(%i2) bfloat(1);
(%o2)                         1.0b0
(%i3) bftrunc:false;
(%o3)                         false
(%i4) bfloat(1);
(%o4)                  1.000000000000000b0
@end example
@end defvr

@c --- 17.02.2011 DK -----------------------------------------------------------
@anchor{evenp}
@deffn {Funktion} evenp (@var{expr})

Ist das Argument @var{expr} eine gerade ganze Zahl, wird @code{true}
zur@"uckgegeben.  In allen anderen F@"allen wird @code{false} zur@"uckgegeben.

@code{evenp} gibt f@"ur Symbole oder Ausdr@"ucke immer den Wert @code{false} 
zur@"uck, auch wenn das Symbol als gerade ganze Zahl deklariert ist oder der 
Ausdruck eine gerade ganze Zahl repr@"asentiert.  Siehe die Funktion
@mrefcomma{featurep} um zu testen, ob ein Symbol oder Ausdruck eine gerade
ganze Zahl repr@"asentiert.

Beispiele:

@example
(%i1) evenp(2);
(%o1)                         true
(%i2) evenp(3);
(%o2)                         false
(%i3) declare(n, even);
(%o3)                         done
(%i4) evenp(n);
(%o4)                         false
(%i5) featurep(n, even);
(%o5)                         true
@end example
@end deffn

@c --- 08.03.2011 DK -----------------------------------------------------------
@anchor{float}
@deffn  {Funktion} float (@var{expr})
@deffnx {Optionsvariable} float

Die Funktion @code{float} konvertiert ganze, rationale und gro@ss{}e
Gleitkommazahlen, die im Argument @var{expr} enthalten sind, in Gleitkommazahlen
mit doppelter Genauigkeit.

@code{float} ist auch eine Optionsvariable mit dem Standardwert @code{false} und
ein Auswertungsschalter f@"ur die Funktion @mrefdot{ev}  Erh@"alt die
Optionsvariable @code{float} den Wert @code{true}, werden rationale und
gro@ss{}e Gleitkommazahlen sofort in Gleitkommazahlen umgewandelt.  Als
Auswertungsschalter der Funktion @code{ev} hat @code{float} denselben Effekt,
ohne dass die Optionsvariable @code{float} ihren Wert @"andert.  Im Unterschied
zur Funktion @code{float} werden durch das Setzen der Optionsvariablen oder bei
Verwendung als Auswertungsschalter keine ganze Zahlen in Gleitkommazahlen
umgewandelt.  Daher k@"onnen die beiden Kommandos @code{ev(expr, float)} und
@code{float(expr)} ein unterschiedliches Ergebnis haben.

Siehe auch die Optionsvariable @mrefdot{numer}

Beispiele:

In den ersten zwei Beispielen werden die Zahlen @code{1/2} und @code{1} in eine
Gleitkommazahl umgewandelt.  Die Sinusfunktion vereinfacht sodann zu einem
numerischen Wert.  Das Auswertungsschalter @code{float} wandelt ganze Zahlen
nicht in eine Gleitkommazahl um.  Daher wird @code{sin(1)} nicht zu einem
numerischen Wert vereinfacht.

@example
(%i1) float(sin(1/2));
(%o1)                   0.479425538604203
(%i2) float(sin(1));
(%o2)                   .8414709848078965
(%i3) sin(1/2),float;
(%o3)                   0.479425538604203
(%i4) sin(1),float;
(%o4)                        sin(1)
@end example
@end deffn

@c --- 17.02.2011 DK -----------------------------------------------------------
@anchor{float2bf}
@defvr {Optionsvariable} float2bf
Standardwert: @code{true}
 
Hat die Optionsvariable @code{float2bf} den Wert @code{false}, wird eine
Warnung ausgegeben, wenn eine Gleitkommazahl in eine gro@ss{}e Gleitkommazahl 
umgewandelt wird, da die Umwandlung zu einem Verlust an Genauigkeit f@"uhren 
kann.

Beispiele:

@example
(%i1) float2bf:true;
(%o1)                         true
(%i2) bfloat(1.5);
(%o2)                         1.5b0
(%i3) float2bf:false;
(%o3)                         false
(%i4) bfloat(1.5);
bfloat: converting float 1.5 to bigfloat.
(%o4)                         1.5b0
@end example
@end defvr

@c --- 17.02.2011 DK -----------------------------------------------------------
@anchor{floatnump}
@deffn {Funktion} floatnump (@var{number})

Gibt den Wert @code{true} zur@"uck, wenn das Argument @var{number} eine 
Gleitkommazahl ist.  Ansonsten wird @code{false} zur@"uckgegeben.  Auch wenn 
@var{number} eine gro@ss{}e Gleitkommazahl ist, ist das Ergebnis @code{false}.

Siehe auch die Funktionen @mrefcomma{numberp} @mrefcomma{bfloatp}@w{}
@mref{ratnump} und @mrefdot{integerp}

Beispiele:

@example
(%i1) floatnump(1.5);
(%o1)                         true
(%i2) floatnump(1.5b0);
(%o2)                         false
@end example
@end deffn

@c --- 17.02.2011 DK -----------------------------------------------------------
@anchor{fpprec}
@defvr {Optionsvariable} fpprec
Standardwert: 16

@code{ffprec} ist die Zahl der Stellen f@"ur das Rechnen mit gro@ss{}en 
Gleitkommazahlen.  @code{ffprec} hat keinen Einflu@ss{} auf das Rechnen mit
Gleitkommazahlen in doppelter Genauigkeit.  Siehe auch @mref{bfloat} und 
@mrefdot{fpprintprec}

Beispiele:

@example
(%i1) fpprec:16;
(%o1)                          16
(%i2) bfloat(%pi);
(%o2)                  3.141592653589793b0
(%i3) fpprec:45;
(%o3)                          45
(%i4) bfloat(%pi);
(%o4)    3.1415926535897932384626433832795028841971694b0
(%i5) sin(1.5b0);
(%o5)   9.97494986604054430941723371141487322706651426b-1
@end example
@end defvr

@c --- 17.02.2011 DK -----------------------------------------------------------
@anchor{fpprintprec}
@defvr {Optionsvariable} fpprintprec
Standardwert: 0

@code{fpprintprec} ist die Anzahl der Stellen, die angezeigt werden, wenn eine
Gleitkommazahl ausgegeben wird.

Hat @code{fpprintprec} einen Wert zwischen 2 und 16, ist die Anzahl der 
angezeigten Stellen f@"ur einfache Gleitkommazahlen gleich dem Wert von 
@code{fpprintprec}.  Hat @code{fpprintprec} den Wert 0 oder ist gr@"o@ss{}er als
16 werden 16 Stellen angezeigt.

Hat f@"ur gro@ss{}e Gleitkommazahlen @code{fpprintprec} einen Wert zwischen 2 
und @mrefcomma{fpprec} ist die Anzahl der angezeigten Stellen gleich
@code{fpprintprec}.  Ist der Wert von @code{fpprintprec} gleich 0 oder 
gr@"o@ss{}er als @code{fpprec} werden @code{fpprec} Stellen angezeigt.

@code{fpprintprec} kann nicht den Wert 1 erhalten.

Beispiele:

@example
(%i1) fpprec:16;
(%o1)                          16
(%i2) fpprintprec:5;
(%o2)                           5
(%i3) float(%pi);
(%o3)                        3.1416
(%i4) bfloat(%pi);
(%o4)                       3.1415b0
(%i5) fpprintprec:25;
(%o5)                          25
(%i6) bfloat(%pi);
(%o6)                  3.141592653589793b0
(%i7) bfloat(%pi);
(%o7)                  3.141592653589793b0
(%i8) fpprec:45;
(%o8)                          45
(%i9) bfloat(%pi);
(%o9)             3.141592653589793238462643b0
(%i10) fpprintprec:45;
(%o10)                         45
(%i11) bfloat(%pi);
(%o11)   3.1415926535897932384626433832795028841971694b0
@end example
@end defvr

@c --- 15.10.2010 DK -----------------------------------------------------------
@anchor{integerp}
@deffn {Funktion} integerp (@var{number})

Hat den R@"uckgabewert @code{true}, wenn das Argument @var{number} eine ganze 
Zahl ist.  In allen anderen F@"allen gibt @code{integerp} den Wert @code{false} 
zur@"uck.

@code{integerp} gibt f@"ur Symbole oder Ausdr@"ucke immer den Wert @code{false} 
zur@"uck, auch wenn das Symbol als ganze Zahl deklariert ist oder der Ausdruck 
eine ganze Zahl repr@"asentiert.  Siehe die Funktion @mrefcomma{featurep} um zu
testen, ob ein Symbol oder Ausdruck eine ganze Zahl repr@"asentiert.

Beispiele:

@example
(%i1) integerp (1);
(%o1)                         true
(%i2) integerp (1.0);
(%o2)                         false
(%i3) integerp (%pi);
(%o3)                         false
(%i4) declare (n, integer)$
(%i5) integerp (n);
(%o5)                         false
@end example
@end deffn

@c --- 08.10.2010 --------------------------------------------------------------
@anchor{m1pbranch}
@need 800
@defvr {Optionsvariable} m1pbranch
Standardwert: @code{false}

Die Optionsvariable @code{m1pbranch} kontrolliert die Vereinfachung der
Exponentiation von @code{-1} f@"ur den Fall, dass die Optionsvariable
@mref{domain} den Wert @code{complex} hat.  Hat @code{m1pbranch} f@"ur diesen
Fall den Wert @code{true}, wird die Exponentiation von @code{-1} zu einem
Ausdruck vereinfacht, der dem Hauptwert entspricht.  Die Auswirkung der
Optionsvariable @code{m1pbranch} ist in der folgenden Tabelle gezeigt.

@example
@group
              domain:real
                            
(-1)^(1/3):      -1
(-1)^(1/4):   (-1)^(1/4)

             domain:complex
          
m1pbranch:false          m1pbranch:true
(-1)^(1/3)               1/2+%i*sqrt(3)/2
(-1)^(1/4)              sqrt(2)/2+%i*sqrt(2)/2
@end group
@end example

Siehe auch die Optionsvariable @mrefdot{numer_pbranch}
@end defvr

@c --- 17.02.2011 DK -----------------------------------------------------------
@anchor{nonnegintegerp}
@deffn {Funktion} nonnegintegerp (@var{number})

Gibt den Wert @code{true} zur@"uck, wenn @code{number} eine ganze positive Zahl
oder Null ist.  Siehe auch @mrefdot{integerp}

Beispiele:

@example
(%i1) nonnegintegerp(2);
(%o1)                         true
(%i2) nonnegintegerp(-2);
(%o2)                         false
@end example
@end deffn

@c --- 21.08.2010 --------------------------------------------------------------
@anchor{numberp}
@deffn {Funktion} numberp (@var{number})

Hat das Ergebnis @code{true}, wenn @var{number} eine ganze, rationale, eine
Gleitkommazahl oder eine gro@ss{}e Gleitkommazahl ist.  Ansonsten ist das 
Ergebnis @code{false}.

@code{numberp} gibt f@"ur ein Symbol immer das Ergebnis @code{false} zur@"uck.
Dies ist auch dann der Fall, wenn das Symbol eine numerische Konstante wie 
@mref{%pi} ist oder wenn das Symbol mit der Funktion @mref{declare} eine 
Eigenschaft wie @mrefcomma{integer} @mref{real} oder @mref{complex} erhalten
hat.

Beispiele:

@example
(%i1) numberp (42);
(%o1)                         true
(%i2) numberp (-13/19);
(%o2)                         true
(%i3) numberp (3.14159);
(%o3)                         true
(%i4) numberp (-1729b-4);
(%o4)                         true
(%i5) map (numberp, [%e, %pi, %i, %phi, inf, minf]);
(%o5)      [false, false, false, false, false, false]
(%i6) declare(a,even, b,odd, c,integer, d,rational, e,real);
(%o6)                         done
(%i7) map (numberp, [a, b, c, d, e]);
(%o7) [false, false, false, false, false]
@end example
@end deffn

@c --- 08.03.2011 DK -----------------------------------------------------------
@anchor{numer}
@defvr {Optionsvariable} numer
Standardwert: @code{false}

Hat die Optionsvariable @code{numer} den Wert @code{true}, werden rationale
Zahlen und gro@ss{}e Gleitkommazahlen in Gleitkommazahlen umgewandelt.
Weiterhin werden Konstante wie zum Beispiel @mrefcomma{%pi} die einen
numerischen Wert haben, durch diesen ersetzt.  Mathematische Funktionen mit
numerischen Argumenten vereinfachen zu einer Gleitkommazahl.  Wird die
Optionsvariable @code{numer} gesetzt, erh@"alt die Optionsvariable
@mref{float} denselben Wert.  Im Unterschied zur Optionsvariablen @code{float}
vereinfachen auch mathematische Funktionen mit einem ganzzahligen Wert wie zum
Beispiel @code{sin(1)} zu einem numerischen Wert.

@code{numer} ist auch ein Auswertungsschalter der Funktion @mrefdot{ev}  Der
Auswertungsschalter hat die gleiche Funktionsweise wie die Optionsvariable,
ohne dass die Optionsvariable ihren Wert @"andert.

Siehe auch @mref{float} und @mrefdot{%enumer}

Beispiele:

Erh@"alt @code{numer} den Wert @code{true}, werden rationale Zahlen, Konstante
mit einem numerischen Wert und mathematische Funktionen mit numerischen
Argumenten zu einer Gleitkommazahl ausgewertet oder vereinfacht.

@example
(%i1) numer:false;
(%o1)                         false
(%i2) [1, 1/3, %pi, sin(1)];
                           1
(%o2)                  [1, -, %pi, sin(1)]
                           3
(%i3) numer:true;
(%o3)                         true
(%i4) [1, 1/3, %pi, sin(1)];
(%o4) [1, .3333333333333333, 3.141592653589793, 
                                               .8414709848078965]
@end example

@code{numer} ist auch ein Auswertungsschalter der Funktion @code{ev}.  Hier wird
die Kurzschreibweise der Funktion @code{ev} verwendet.

@example
(%i1) [sqrt(2), sin(1), 1/(1+sqrt(3))];
                                        1
(%o1)            [sqrt(2), sin(1), -----------]
                                   sqrt(3) + 1

(%i2) [sqrt(2), sin(1), 1/(1+sqrt(3))],numer;
(%o2) [1.414213562373095, .8414709848078965, .3660254037844387]
@end example
@end defvr

@c --- 15.10.2010 DK -----------------------------------------------------------
@anchor{numer_pbranch}
@defvr {Optionsvariable} numer_pbranch
Standardwert: @code{false}

Die Optionsvariable @code{numer_pbranch} kontrolliert die Vereinfachung der
Exponentiation einer negativen ganzen, rationalen oder Gleitkommazahl.
Hat @code{numer_pbranch} den Wert @code{true} und ist der Exponent eine 
Gleitkommazahl oder hat die Optionsvariable @mref{numer} den Wert @code{true}, 
dann berechnet Maxima den Hauptwert der Exponentiation.  Ansonsten wird ein 
vereinfachter Ausdruck, aber nicht numerischer Wert zur@"uckgegeben.  Siehe auch
die Optionsvariable @mrefdot{m1pbranch}

Beispiele:

@example
(%i1) (-2)^0.75;
(%o1) (-2)^0.75

(%i2) (-2)^0.75,numer_pbranch:true;
(%o2) 1.189207115002721*%i-1.189207115002721

(%i3) (-2)^(3/4);
(%o3) (-1)^(3/4)*2^(3/4)

(%i4) (-2)^(3/4),numer;
(%o4) 1.681792830507429*(-1)^0.75

(%i5) (-2)^(3/4),numer,numer_pbranch:true;
(%o5) 1.189207115002721*%i-1.189207115002721
@end example
@end defvr

@c --- 08.03.2011 DK -----------------------------------------------------------
@anchor{numerval}
@deffn {Funktion} numerval (@var{x_1}, @var{val_1}, @dots{}, @var{var_n}, @var{val_n})

Die Variablen @var{x_1}, @dots{}, @var{x_n} erhalten die numerischen Werte
@var{val_1}, @dots{}, @code{val_n}.  Die numerischen Werte werden immer dann
f@"ur die Variablen in Ausdr@"ucke eingesetzt, wenn die Optionsvariable 
@mref{numer} den Wert @code{true} hat.  Siehe auch @mrefdot{ev}

Die Argumente @var{val_1}, @dots{}, @var{val_n} k@"onnen auch beliebige 
Ausdr@"ucke sein, die wie numerische Werte f@"ur Variablen eingesetzt werden.

Beispiele:

@example
(%i1) numerval(a, 123, b, x^2)$

(%i2) [a, b];
(%o2)                        [a, b]
(%i3) numer:true;
(%o3)                         true
(%i4) [a, b];
                                   2
(%o4)                       [123, x ]
@end example
@end deffn

@c --- 18.02.2011 DK -----------------------------------------------------------
@anchor{oddp}
@deffn {Funktion} oddp (@var{expr})

Gibt @code{true} zur@"uck, wenn das Argument @var{expr} eine ungerade ganze Zahl
ist.  In allen anderen F@"allen wird @code{false} zur@"uckgegeben.

@code{oddp} gibt f@"ur Symbole oder Ausdr@"ucke immer den Wert @code{false} 
zur@"uck, auch wenn das Symbol als ungerade ganze Zahl deklariert ist oder der 
Ausdruck eine ungerade ganze Zahl repr@"asentiert.  Siehe die Funktion 
@mrefcomma{featurep} um zu testen, ob ein Symbol oder Ausdruck eine ungerade 
ganze Zahl repr@"asentiert.

Beispiele:

@example
(%i1) oddp(3);
(%o1)                         true
(%i2) oddp(2);
(%o2)                         false
(%i3) declare(n,odd);
(%o3)                         done
(%i4) oddp(n);
(%o4)                         false
(%i5) featurep(n,odd);
(%o5)                         true
@end example
@end deffn

@c --- 03.11.2011 DK -----------------------------------------------------------
@anchor{ratepsilon}
@defvr {Optionsvariable} ratepsilon
Standardwert: @code{2.0e-15}

Die Optionsvariable @code{ratepsilon} kontrolliert die Genauigkeit, mit der
Gleitkommazahlen in rationale Zahlen umgewandelt werden, wenn die
Optionsvariable @code{bftorat} den Wert @code{false} hat.  F@"ur ein Beispiel
siehe die Optionsvariable @mrefdot{bftorat}
@end defvr

@c --- 18.02.2011 DK -----------------------------------------------------------
@anchor{rationalize}
@deffn {Funktion} rationalize (@var{expr})

Konvertiert alle Gleitkommazahlen einschlie@ss{}lich gro@ss{}er 
Gleitkommazahlen, die in dem Ausdruck @var{expr} auftreten, in rationale Zahlen.

Es mag @"uberraschend sein, dass @code{rationalize(0.1)} nicht das Ergebnis
@code{1/10} hat.  Dies ist nicht speziell f@"ur Maxima.  Ursache ist, dass die 
gebrochene Zahl @code{1/10} in der internen Darstellung als bin@"are Zahl keine
endliche Darstellung hat.

Siehe auch die Funktionen @mref{float} und @mref{bfloat} sowie die
Auswertungsschalter @mref{float} und @mrefcomma{numer} um eine rationale Zahl
in eine Gleitkommazahl umzuwandeln.

Beispiele:

@example
(%i1) rationalize (0.5);
                                1
(%o1)                           -
                                2
(%i2) rationalize (0.1);
                        3602879701896397
(%o2)                   -----------------
                        36028797018963968
(%i3) fpprec : 5$
(%i4) rationalize (0.1b0);
                             209715
(%o4)                        -------
                             2097152
(%i5) fpprec : 20$
@group
(%i6) rationalize (0.1b0);
                     236118324143482260685
(%o6)                ----------------------
                     2361183241434822606848
@end group
(%i7) rationalize (sin (0.1*x + 5.6));
@group
               3602879701896397 x   3152519739159347
(%o7)      sin(------------------ + ----------------)
               36028797018963968    562949953421312
@end group
(%i8) float(%);
(%o8)                          sin(0.1 x + 5.6)
@end example
@end deffn

@c --- 08.10.2010 DK -----------------------------------------------------------
@anchor{ratnump}
@deffn {Funktion} ratnump (@var{number})

Gibt @code{true} zur@"uck, wenn @var{number} eine ganze oder rationale Zahl ist.
In allen anderen F@"allen ist das Ergebnis @code{false}.

Siehe auch die Funktionen @mrefcomma{numberp} @mrefcomma{integerp}@w{}
@mref{floatnump} und @mrefdot{bfloatp}

Beispiele:

@example
(%i1) ratnump(1/2);
(%o1)                         true
(%i2) ratnump(3);
(%o2)                         true
(%i3) ratnump(3.0);
(%o3)                         false
@end example
@end deffn

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

@menu
* Einf@"uhrung in Zeichenketten::
* Funktionen und Variablen f@"ur Zeichenketten::
@end menu

@c -----------------------------------------------------------------------------
@node Einf@"uhrung in Zeichenketten, Funktionen und Variablen f@"ur Zeichenketten, Zeichenketten, Zeichenketten
@subsection Einf@"uhrung in Zeichenketten
@c -----------------------------------------------------------------------------

@cindex backslash
@ifnotinfo
@cindex \
@end ifnotinfo
@ifinfo
@c adding the backslash to the index here breaks the LaTeX syntax of the file
@c maxima.fns that is created by the first pdfLaTeX run by "make pdf".
@end ifinfo
Zeichenketten werden bei der Eingabe in Anf@"uhrungszeichen gesetzt.  Sie werden 
standardm@"a@ss{}ig ohne Anf@"uhrungszeichen ausgegeben.  Hat die 
Optionsvariable @mref{stringdisp} den Wert @code{true}, werden Zeichenketten mit
Anf@"uhrungszeichen dargestellt.

Zeichenketten k@"onnen jedes Zeichen einschlie@ss{}lich Tabulator-, 
Zeilenvorschub- oder Wagenr@"ucklauf-Zeichen enthalten.  Das Anf@"uhrungszeichen 
wird innerhalb einer Zeichenkette durch @code{\"} und der Backslash durch 
@code{\\} dargestellt.  Ein Backslash am Ende einer Eingabezeile erlaubt die
Fortsetzung einer Zeichenkette in der n@"achsten Zeile.  Maxima kennt keine 
weiteren Kombinationen mit einem Backslash.  Daher wird der Backslash an anderer
Stelle ignoriert.  Maxima kennt keine andere M@"oglichkeit, als spezielle
Zeichen wie ein Tabulator-, Zeilenvorschub- oder Wagenr@"ucklaufzeichen in einer
Zeichenkette darzustellen.

Maxima hat keinen Typ f@"ur ein einzelnes Zeichen.  Einzelne Zeichen werden
daher als eine Zeichenkette mit einem Zeichen dargestellt.  Folgende Funktionen
und Variablen arbeiten mit Zeichenketten:

@verbatim
   concat   sconcat   string   stringdisp
@end verbatim

@noindent
Das Zusatzpaket @code{stringproc} enth@"alt eine umfangreiche Bibliothek an 
Funktionen f@"ur Zeichenketten.  Siehe @ref{stringproc}.

Beispiele:

@example
(%i1) s_1 : "This is a string.";
(%o1)               This is a string.
(%i2) s_2 : "Embedded \"double quotes\" and backslash \\ characters.";
(%o2) Embedded "double quotes" and backslash \ characters.
(%i3) s_3 : "Embedded line termination
in this string.";
(%o3) Embedded line termination
in this string.
(%i4) s_4 : "Ignore the \
line termination \
characters in \
this string.";
(%o4) Ignore the line termination characters in this string.
(%i5) stringdisp : false;
(%o5)                         false
(%i6) s_1;
(%o6)                   This is a string.
(%i7) stringdisp : true;
(%o7)                         true
(%i8) s_1;
(%o8)                  "This is a string."
@end example

@c -----------------------------------------------------------------------------
@node Funktionen und Variablen f@"ur Zeichenketten, , Einf@"uhrung in Zeichenketten, Zeichenketten
@subsection Funktionen und Variablen f@"ur Zeichenketten
@c -----------------------------------------------------------------------------

@c --- 15.10.2010 DK -----------------------------------------------------------
@anchor{concat}
@deffn {Funktion} concat (@var{arg_1}, @var{arg_2}, @dots{})

Verkettet die Argumente @var{arg_1}, @var{arg_2}, @dots{} zu einer Zeichenkette 
oder einem Symbol.  Die Argumente m@"ussen sich zu einem Atom auswerten lassen.
Der R@"uckgabewert ist ein Symbol, wenn das erste Argument ein Symbol ist.
Ansonsten wird eine Zeichenkette zur@"uckgegeben.

@code{concat} wertet die Argumente aus.  Der @nxref{', Quote-Operator} @code{'}
verhindert die Auswertung.  Siehe auch die Funktion @mrefdot{sconcat}

Beispiele:

@example
(%i1) y: 7$
(%i2) z: 88$
(%i3) stringdisp:true$
(%i4) concat(y, z/2);
(%o4)                         "744"
(%i5) concat('y, z/2);
(%o5)                          y44
@end example

Einem Symbol, das mit @code{concat} konstruiert wird, kann ein Wert zugewiesen
werden und es kann in Ausdr@"ucken auftreten.

@example
(%i6) a: concat ('y, z/2);
(%o6)                          y44
@group
(%i7) a:: 123;
(%o7)                          123
@end group
(%i8) y44;
(%o8)                          123
(%i9) b^a;
                               y44
(%o9)                         b
(%i10) %, numer;
                                123
(%o11)                         b
@end example

@code{concat(1, 2)} gibt eine Zeichenkette als Ergebnis zur@"uck.

@example
(%i12) concat (1, 2) + 3;
(%o12)                       "12" + 3
@end example
@end deffn

@c --- 15.10.2010 DK -----------------------------------------------------------
@anchor{sconcat}
@deffn {Funktion} sconcat (@var{arg_1}, @var{arg_2}, @dots{})

Verkettet die Argumente @var{arg_1}, @var{arg_2}, @dots{} zu einer Zeichenkette.
Im Unterschied zu der Funktion @mref{concat} m@"ussen die Argumente @i{nicht} 
Atome sein.  Der R@"uckgabewert ist eine Zeichenkette.

Beispiel:

@example
(%i1) sconcat ("xx[", 3, "]:", expand ((x+y)^3));
(%o1)               xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
@end example
@end deffn

@c --- 18.02.2011 DK -----------------------------------------------------------
@anchor{string}
@deffn {Funktion} string (@var{expr})

Konvertiert das Argument @code{expr} in eine lineare Darstellung, wie sie auch
vom Parser von der Eingabe eingelesen wird.  Die R@"uckgabe von @code{string}
ist eine Zeichenkette.  Diese kann nicht als Eingabe f@"ur eine Berechnung
genutzt werden.

Beispiele:

Die hier verwendete Funktion @mref{stringp} ist im Paket @mref{stringproc}@w{}
definiert und wird automatisch geladen.

@example
(%i1) stringdisp:true;
(%o1)                         true
(%i2) string(expand((a+b)^2));
(%o2)                    "b^2+2*a*b+a^2"
(%i3) stringp(%);
(%o3)                         true
@end example
@end deffn

@c --- 28.08.2010 DK -----------------------------------------------------------
@anchor{stringdisp}
@defvr {Optionsvariable} stringdisp
Standardwert: @code{false}

Hat @code{stringdisp} den Wert @code{true}, werden Zeichenketten mit
Anf@"uhrungszeichen ausgegeben.  Ansonsten werden keine Anf@"uhrungszeichen
ausgegeben.

Wird die Definition einer Funktion ausgegeben, werden enthaltene Zeichenketten
unabh@"angig vom Wert der Optionsvariablen @code{stringdisp} immer mit
Anf@"uhrungszeichen ausgegeben.

Beispiele:

@example
(%i1) stringdisp: false$
(%i2) "This is an example string.";
(%o2)              This is an example string.
(%i3) foo () :=
      print ("This is a string in a function definition.");
(%o3) foo() := 
              print("This is a string in a function definition.")
(%i4) stringdisp: true$
(%i5) "This is an example string.";
(%o5)             "This is an example string."
@end example
@end defvr

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

