Next: Funktionen für komplexe Zahlen, Previous: Mathematische Funktionen, Up: Mathematische Funktionen [Contents][Index]

### 10.1 Funktionen für Zahlen

Funktion: abs (z)

  Die Funktion `abs` ist die Betragsfunktion und für das numerische und symbolische Rechnen geeignet. Ist das Argument z eine reelle oder komplexe Zahl wird der Betrag berechnet. Wenn möglich werden allgemeine Ausdrücke mit der Betragsfunktion vereinfacht. Maxima kann Ausdrücke mit der Betragsfunktion integrieren und ableiten sowie Grenzwerte von Ausdrücken mit der Betragsfunktion ermitteln. Das Paket `abs_integrate` erweitert Maximas Möglichkeiten, Integrale mit der Betragsfunktion zu lösen.

  Die Betragsfunktion wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe `distribute_over`.

  Siehe die Funktion `cabs`, um den Betrag eines komplexen Ausdrucks oder einer Funktion zu berechnen.

  Beispiele:

  Berechnung des Betrages für reelle und komplexen Zahlen sowie numerische Konstanten und unendliche Größen. Das erste Beispiel zeigt, wie die Betragsfunktion von Maxima auf die Elemente einer Liste angewendet wird.

      (%i1) abs([-4, 0, 1, 1+%i]);
      (%o1)                  [4, 0, 1, sqrt(2)]

      (%i2) abs((1+%i)*(1-%i));
      (%o2)                           2
      (%i3) abs(%e+%i);
                                      2
      (%o3)                    sqrt(%e  + 1)
      (%i4) abs([inf, infinity, minf]);
      (%o4)                   [inf, inf, inf]

  Vereinfachung von Ausdrücken mit der Betragsfunktion.

      (%i5) abs(x^2);
                                      2
      (%o5)                          x
      (%i6) abs(x^3);
                                   2
      (%o6)                       x  abs(x)

      (%i7) abs(abs(x));
      (%o7)                       abs(x)
      (%i8) abs(conjugate(x));
      (%o8)                       abs(x)

  Ableitung und Integrale mit der Betragsfunktion. Wird das Paket abs_integrate geladen, können weitere Integrale mit der Betragsfunktion gelöst werden. Das letzte Beispiel zeigt die Laplacetransformation der Betragsfunktion. Siehe `laplace`.

      (%i9) diff(x*abs(x),x),expand;
      (%o9)                       2 abs(x)

      (%i10) integrate(abs(x),x);
                                   x abs(x)
      (%o10)                       --------
                                      2

      (%i11) integrate(x*abs(x),x);
                                 /
                                 [
      (%o11)                     I x abs(x) dx
                                 ]
                                 /

      (%i12) load(abs_integrate)$
      (%i13) integrate(x*abs(x),x);
                            2           3
                           x  abs(x)   x  signum(x)
      (%o13)               --------- - ------------
                               2            6

      (%i14) integrate(abs(x),x,-2,%pi);
                                     2
                                  %pi
      (%o14)                      ---- + 2
                                   2

      (%i15) laplace(abs(x),x,s);
                                     1
      (%o15)                         --
                                      2
                                     s

Funktion: ceiling (x)

  Die Funktion `ceiling` ist für das numerische und symbolische Rechnen geeignet.

  Ist das Argument x eine reelle Zahl, gibt `ceiling` die kleinste ganze Zahl zurück, die größer oder gleich x ist.

  Die Funktion `ceiling` gibt auch dann einen numerischen Wert zurück, wenn das Argument ein konstanter Ausdruck ist, wie zum Beispiel `1+%e`, der zu einer reellen Zahl ausgewertet werden kann. In diesem Fall wird der konstante Ausdruck in eine große Gleitkommazahl umgewandelt, auf die die Funktion `ceiling` angewendet wird. Aufgrund von Rundungsfehlern bei der Umwandlung in Gleitkommazahlen kann es zu Fehlern bei der Berechnung von `ceiling` kommen. Um diese zu minimieren, wird die Anzahl der Stellen `fpprec` für die Berechnung von `ceiling` um drei Stellen erhöht.

  Ist das Argument expr der Funktion ein komplexer Ausdruck, wird eine Substantivform zurückgegeben.

  Wenn möglich werden Ausdrücke mit der Funktion `ceiling` von Maxima vereinfacht. Maxima kennt insbesondere Vereinfachungen für den Fall, dass das Argument der Funktion `ceiling` ein Ausdruck mit den Funktionen `floor` oder `round` ist. Weiterhin werden für die Vereinfachung die Aussagen und Fakten der aktiven Kontexte herangezogen. Siehe Funktionen und Variablen für Fakten.

  `ceiling` wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe `distribute_over`.

  Siehe auch die Funktionen `floor` und `round`.

  Beispiele:

      (%i1) ceiling(ceiling(x));
      (%o1)                      ceiling(x)
      (%i2) ceiling(floor(x));
      (%o2)                       floor(x)
      (%i3) declare (n, integer)$
      (%i4) ceiling([n, abs(n), max (n, 6)]);
      (%o4)               [n, abs(n), max(6, n)]
      (%i5) assume (x > 0, x < 1)$
      (%i6) ceiling (x);
      (%o6)                           1

  Sind die Werte einer Funktion eine Teilmenge der ganzen Zahlen, kann diese als `integervalued` deklariert werden. Die Funktionen `ceiling` und `floor` können diese Information nutzen, um Ausdrücke zu vereinfachen.

      (%i1) declare (f, integervalued)$
      (%i2) floor (f(x));
      (%o2)                         f(x)
      (%i3) ceiling (f(x) - 1);
      (%o3)                       f(x) - 1

  Maxima kennt das Integral der Funktion `ceiling`.

      (%i1) integrate(ceiling(x),x);
                     (- ceiling(x) + 2 x + 1) ceiling(x)
      (%o1)          -----------------------------------
                                      2

Funktion: entier (x)

  `entier` ist eine andere Bezeichnung für die Funktion `floor`. Siehe `floor`.

Funktion: floor (x)

  Die Funktion `floor` ist für das numerische und symbolische Rechnen geeignet.

  Ist das Argument x eine reelle Zahl, gibt `floor` die größte ganze Zahl zurück, die kleiner oder gleich x ist.

  Die Funktion `floor` gibt auch dann einen numerischen Wert zurück, wenn das Argument ein konstanter Ausdruck ist, wie zum Beispiel `1+%e`, der zu einer reellen Zahl ausgewertet werden kann. In diesem Fall wird der konstante Ausdruck in eine große Gleitkommazahl umgewandelt, auf die die Funktion `floor` angewendet wird. Aufgrund von Rundungsfehlern bei der Umwandlung in Gleitkommazahlen kann es zu Fehlern bei der Berechnung von `floor` kommen. Um diese zu minimieren, wird die Anzahl der Stellen `fpprec` für die Berechnung von `floor` um drei Stellen erhöht.

  Ist das Argument x der Funktion ein komplexer Ausdruck, wird eine Substantivform zurückgegeben.

  Wenn möglich werden Ausdrücke mit der Funktion `floor` von Maxima vereinfacht. Maxima kennt insbesondere Vereinfachungen für den Fall, dass das Argument der Funktion `floor` ein Ausdruck mit den Funktionen `ceiling` oder `round` ist. Weiterhin werden für die Vereinfachung die Aussagen und Fakten der aktiven Kontexte herangezogen. Siehe Funktionen und Variablen für Fakten.

  `floor` wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe `distribute_over`.

  Siehe auch die Funktionen `ceiling` und `round`.

  Beispiele:

      (%i1) floor(ceiling(x));
      (%o1)                      ceiling(x)
      (%i2) floor(floor(x));
      (%o2)                       floor(x)
      (%i3) declare(n, integer);
      (%o3)                         done
      (%i4) floor([n, abs(n), min (n, 6)]);
      (%o4)                [n, abs(n), min(6, n)]
      (%i5) assume(x>0, x<1)$
      (%i6) floor(x);
      (%o6)                           0

  Sind die Werte einer Funktion eine Teilmenge der ganzen Zahlen, kann diese als `integervalued` deklariert werden. Die Funktionen `ceiling` und `floor` können diese Information nutzen, um Ausdrücke zu vereinfachen.

      (%i1) declare (f, integervalued)$
      (%i2) floor(f(x));
      (%o2)                         f(x)
      (%i3) ceiling(f(x) - 1);
      (%o3)                       f(x) - 1

  Maxima kennt das Integral der Funktion `floor`.

      (%i6) integrate(floor(x),x);
                       (- floor(x) + 2 x - 1) floor(x)
      (%o6)            -------------------------------
                                      2

Funktion: fix (x)

  `fix` ist eine andere Bezeichnung für die Funktion `floor`. Siehe `floor`.

Funktion: lmax (L)

  Ist das Argument L eine Liste oder Menge, wird die Funktion `max` auf die Elemente der Liste oder Menge angewendet und das Ergebnis zurückgegeben. Ist L keine Liste oder Menge, signalisiert Maxima einen Fehler.

  Beispiel:

      (%i1) L:[1+%e, %pi, 3];
      (%o1)                   [%e + 1, %pi, 3]
      (%i1) lmax(L);
      (%o1)                        %e + 1

Funktion: lmin (L)

  Ist das Argument L eine Liste oder Menge, wird die Funktion `min` auf die Elemente der Liste oder Menge angewendet und das Ergebnis zurückgegeben. Ist L keine Liste oder Menge, signalisiert Maxima einen Fehler.

  Beispiel:

      (%i1) L:[1+%e, %pi, 3];
      (%o1)                   [%e + 1, %pi, 3]
      (%i2) lmin(L);
      (%o2)                           3

Funktion: max (x_1, …, x_n)

  Sind alle Argumente x_1, …, x_n Zahlen oder konstante Ausdrücke wie zum Beispiel `1+%e` oder `sin(1)`, dann wird der größte Zahlenwert zurückgegeben. Sind symbolische Variablen oder allgemeine Ausdrücke unter den Argumenten, gibt Maxima einen vereinfachten Ausdruck zurück. Die unendliche Größen `inf` und `minf` können als Argument auftreten.

  Die Vereinfachung der Funktion `max` kann kontrolliert werden, in dem mit der Funktion `put` dem Symbol `trylevel` zu der Eigenschaft `maxmin` ein Wert zwischen 1 bis 3 gegeben wird. Folgende Werte können mit der Funktion `put` gesetzt werden:

  `put(trylevel, 1, maxmin)`

    `trylevel` hat den Wert 1. Das ist der Standardwert. Maxima führt keine besonderen Vereinfachungen aus.

  `put(trylevel, 2, maxmin)`

    Maxima wendet die Vereinfachung `max(e,-e) --> |e|` an.

  `put(trylevel, 3, maxima)`

    Maxima wendet die Vereinfachung `max(e,-e) --> |e|` an und versucht Ausdrücke zu eliminieren, die zwischen zwei anderen Argumenten liegen. So wird zum Beispiel `max(x, 2*x, 3*x)` zu `max(x, 3*x)` vereinfacht.

  Mit dem Kommando `get(trylevel, maxmin)` wird der aktuelle Wert für das Symbol `trylevel` angezeigt. Siehe die Funktion `get`.

  `max` berücksichtigt bei der Vereinfachung von Ausdrücken die Aussagen und Fakten der aktiven Kontexte. Siehe das Kapitel Funktionen und Variablen für Fakten.

  Beispiele:

      (%i1) max(1.6, 3/2, 1);
      (%o1)                          1.6
      (%i2) max(1.5b0,1.5,3/2);

                                      3
      (%o2)                           -
                                      2

      (%i3) max(%e,%pi,1,2,3);
      (%o3)                          %pi
      (%i4) max(1+%e,%pi,1,2,3);
      (%o4)                        %e + 1
      (%i5) max(minf,inf);
      (%o5)                          inf
      (%i6) assume(a>b);
      (%o6)                        [a > b]
      (%i7) max(a,b);
      (%o7)                           a

Funktion: min (x_1, …, x_n)

  Sind alle Argumente x_1, …, x_n Zahlen oder konstante Ausdrücke wie zum Beispiel `1+%e` oder `sin(1)`, dann wird der kleinste Zahlenwert zurückgegeben. Sind symbolische Variablen oder allgemeine Ausdrücke unter den Argumenten, gibt Maxima einen vereinfachten Ausdruck zurück. Die unendliche Größen `inf` und `minf` können als Argument auftreten.

  Die Vereinfachung der Funktion `min` kann kontrolliert werden, in dem mit der Funktion `put` dem Symbol `trylevel` zu der Eigenschaft `maxmin` ein Wert zwischen 1 bis 3 gegeben wird. Folgende Werte können mit der Funktion `put` gesetzt werden:

  `put(trylevel, 1, maxmin)`

    `trylevel` hat den Wert 1. Das ist der Standardwert. Maxima führt keine besonderen Vereinfachungen aus.

  `put(trylevel, 2, maxmin)`

    Maxima wendet die Vereinfachung `min(e,-e) --> |e|` an.

  `put(trylevel, 3, maxima)`

    Maxima wendet die Vereinfachung `min(e,-e) --> |e|` an und versucht Ausdrücke zu eliminieren, die zwischen zwei anderen Argumenten liegen. So wird zum Beispiel `min(x, 2*x, 3*x)` zu `min(x, 3*x)` vereinfacht.

  Mit dem Kommando `get(trylevel, maxmin)` wird der aktuelle Wert für das Symbol `trylevel` angezeigt. Siehe die Funktion `get`.

  `min` berücksichtigt bei der Vereinfachung von Ausdrücken die Aussagen und Fakten der aktiven Kontexte. Siehe das Kapitel Funktionen und Variablen für Fakten.

  Beispiele:

      (%i1) min(1.6, 3/2, 1);
      (%o1)                           1
      (%i2) min(1.5b0,1.5,3/2);
                                      3
      (%o2)                           -
                                      2
      (%i3) min(%e,%pi,3);
      (%o3)                          %e
      (%i4) min(1+%e,%pi,3);
      (%o4)                           3
      (%i5) min(minf,inf);
      (%o5)                         minf
      (%i6) assume(a>b);
      (%o6)                        [a > b]
      (%i7) min(a,b);
      (%o7)                           b

Funktion: round (x)

  Die Funktion `round` ist für das numerische und symbolische Rechnen geeignet.

  Ist das Argument x eine reelle Zahl, gibt `round` die am nächsten liegende ganze Zahl zurück. Vielfache von 1/2 werden auf die nächste gerade ganze Zahl gerundet.

  Die Funktion `round` gibt auch dann einen numerischen Wert zurück, wenn das Argument ein konstanter Ausdruck ist, wie zum Beispiel `1+%e`, der zu einer reellen Zahl ausgewertet werden kann. In diesem Fall wird der konstante Ausdruck in eine große Gleitkommazahl umgewandelt, auf die die Funktion `round` angewendet wird. Aufgrund von Rundungsfehlern bei der Umwandlung in Gleitkommazahlen kann es zu Fehlern bei der Berechnung von `round` kommen. Um diese zu minimieren, wird die Anzahl der Stellen `fpprec` für die Berechnung von `round` um drei Stellen erhöht.

  Ist das Argument x der Funktion ein komplexer Ausdruck, wird eine Substantivform zurückgegeben.

  Wenn möglich werden Ausdrücke mit der Funktion `round` von Maxima vereinfacht. Maxima kennt insbesondere Vereinfachungen für den Fall, dass das Argument der Funktion `round` ein Ausdruck mit den Funktionen `ceiling` oder `floor` ist. Weiterhin werden für die Vereinfachung die Aussagen und Fakten der aktiven Kontexte herangezogen. Siehe Funktionen und Variablen für Fakten.

  `round` wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe `distribute_over`.

  Siehe auch die Funktionen `ceiling` und `floor`.

  Beispiele:

      (%i1) round(floor(x));
      (%o1)                       floor(x)
      (%i2) round(round(x));
      (%o2)                       round(x)
      (%i3) declare(n, integer);
      (%o3)                         done
      (%i4) round([n, abs(n), min(n,6)]);
      (%o4)                [n, abs(n), min(6, n)]

  Sind die Werte einer Funktion eine Teilmenge der ganzen Zahlen, kann diese als `integervalued` deklariert werden. Die Funktion `round` kann diese Information nutzen, um Ausdrücke zu vereinfachen.

      (%i1) declare(f, integervalued);
      (%o1)                         done
      (%i2) round(f(x));
      (%o2)                         f(x)
      (%i3) round(f(x) - 1);
      (%o3)                       f(x) - 1

Funktion: signum (z)

  Die Signumfunktion `signum` ist für das numerische und symbolische Rechnen geeignet. Ist das Argument z eine Zahl, ist das Ergebnis 0, 1 oder -1, wenn die Zahl Null, positiv oder negativ ist. Das Argument kann auch ein konstanter Ausdruck wie `%pi` oder `1+%e` sein. Ist das Argument z eine komplexe Zahl, vereinfacht die der Ausdruck `signum(z)` zu `z/abs(z)`.

  Ist das Argument z keine Zahl oder kein konstanter Ausdruck, versucht Maxima den Ausdruck zu vereinfachen. Maxima kann die Funktion `signum` differenzieren. Wird das Paket abs_integrate geladen, kann Maxima Integrale mit der Funktion `signum` lösen.

  `signum` wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe `distribute_over`.

  Beispiele:

  Ergebnisse für verschiedene Zahlen und konstante Ausdrücke. Die Beispiele zeigen, dass das Ergebnis der Signumfunktion den Typ der Zahl erhält. Die unendlichen Größen `minf` und `inf` können als Argument auftreten.

      (%i1) signum([-1.5, 0, 0.0, 1.5, 1.5b0, %e, sin(1), cos(4)]);
      (%o1)        [- 1.0, 0, 0.0, 1.0, 1.0b0, 1, 1, - 1]
      (%i2) signum(1+%i);
                                %i         1
      (%o2)                   ------- + -------
                              sqrt(2)   sqrt(2)
      (%i3) signum([minf,inf]);
      (%o3)                      [- 1, 1]

  Vereinfachungen der Signumfunktion.

      (%i3) signum(x*y);
      (%o3)                  signum(x) signum(y)
      (%i4) signum(-x);
      (%o4)                      - signum(x)

  Wird das Paket abs_integrate geladen, kann Maxima Integrale mit der Signumfunktion lösen. Ausdrücke mit der Signumfunktion können differenziert werden.

      (%i5) load(abs_integrate)$

      (%i6) integrate(signum(x),x);
      (%o6)                        abs(x)

      (%i7) integrate(sin(x)*signum(x),x);
      (%o7)               (1 - cos(x)) signum(x)

      (%i7) diff(%,x);
      (%o7)                  signum(x) sin(x)

Next: Funktionen für komplexe Zahlen, Previous: Mathematische Funktionen, Up: Mathematische Funktionen [Contents][Index]