Maxima Manual: Funktionen und Variablen für Konstante

Next: Listen, Previous: Zeichenketten, Nach oben: Datentypen und Strukturen [Inhalt][Index]

### 5.3 Funktionen und Variablen für Konstante

Konstante: %e

  `%e` ist die Basis des natürlichen Logarithmus, auch Eulersche Zahl genannt. Der numerische Wert der Konstanten als Gleitkommazahl mit doppelter Genauigkeit ist 2.718281828459045d0.

  Die Funktion `bfloat` kann `%e` mit einer beliebigen Genauigkeit berechnen.

  Hat die Optionsvariable `numer` den Wert `true`, wird `%e` durch den numerischen Wert ersetzt, aber nicht, wenn `%e` die Basis der Exponentiation mit einem symbolischen Exponenten ist. Hat zusätzlich die Optionsvariable `%enumer` den Wert `true`, dann wird `%e` in einem Ausdruck immer durch den numerischen Wert ersetzt.

  Beispiel:

  Berechnung von `%e` auf 48 Stellen.

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

  Die Wirkung der Optionsvariablen `numer` und `%enumer` auf das Ersetzen von `%e` durch den numerischen Wert.

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

  Im ersten Beispiel vereinfacht die Reihe zu `%e`. Für die Vereinfachung der Reihe wird die Funktion `simplify_sum` geladen. Im zweiten Beispiel ist `%e` der Grenzwert.

      (%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

Konstante: %i

  `%i` ist die imaginäre Einheit.

  Maxima kennt keinen eigenen Typ für komplexe Zahlen. Komplexe Zahlen werden von Maxima intern als die Addition von Realteil und dem mit der imaginären Einheit `%i` multiplizierten Imaginärteil dargestellt. Zum Beispiel sind die komplexen Zahlen `2 + 3*%i` und `2 - 3*%i` die Wurzeln der Gleichung `x^2 - 4*x + 13 = 0`. Siehe auch das Kapitel Zahlen.

  Beispiele:

  Einige Beispiele für das Rechnen mit der imaginären Einheit.

      (%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)

Konstante: false

  Repräsentiert den logischen Wert `falsch`. `false` wird intern von Maxima durch die Lisp-Konstante `NIL` dargestellt.

  Siehe auch `true` für den logischen Wert `wahr`.

Konstante: %gamma

  Die Euler-Mascheroni-Konstante mit dem Wert `0.5772156649015329` als Gleitkommazahl in doppelter Genauigkeit.

  Die Funktion `bfloat` kann `%gamma` mit einer beliebigen Genauigkeit berechnen.

  Hat die Optionsvariable `numer` den Wert `true`, wird die Konstante `%gamma` durch ihren numerischen Wert ersetzt.

  Beispiele:

  Numerische Werte für `%gamma`.

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

  Bestimmte Integrale, die `%gamma` als Ergebnis haben.

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

Konstante: ind

  `ind` repräsentiert ein unbestimmtes Ergebnis. Siehe auch `und` und die Funktion `limit`.

  Beispiel:

      (%i1) limit(sin(1/x), x, 0);
      (%o1)                          ind

Konstante: inf

  `inf` repräsentiert einen positiven unendlich großen Wert. Siehe auch `minf` und `infinity`.

  Die unendlichen Größen, aber auch die unbestimmten Größen `ind` und `und`, eignen sich nicht für das arithmetische Rechnen. Diese Größen werden von Maxima in Rechnungen wie Symbole behandelt, was zu fehlerhaften Ergebnissen führt. Daher sollten unendliche Größen nur im Zusammenhang mit Grenzwerten `limit`, bestimmten Integralen `integrate` oder Reihen `sum` verwendet werden.

Konstante: infinity

  `infinity` repräsentiert einen komplexen unendlichen Wert. Siehe auch `inf` und `minf`.

  Die unendlichen Größen, aber auch die unbestimmten Größen `ind` und `und`, eignen sich nicht für das arithmetische Rechnen. Diese Größen werden von Maxima in Rechnungen wie Symbole behandelt, was zu fehlerhaften Ergebnissen führt. Daher sollten unendliche Größen nur im Zusammenhang mit Grenzwerten `limit`, bestimmten Integralen `integrate` oder Reihen `sum` verwendet werden.

Konstante: minf

  `minf` repräsentiert einen negativen unendlichen Wert. Siehe auch `inf` und `infinity`.

  Die unendlichen Größen, aber auch die unbestimmten Größen `ind` und `und`, eignen sich nicht für das arithmetische Rechnen. Diese Größen werden von Maxima in Rechnungen wie Symbole behandelt, was zu fehlerhaften Ergebnissen führt. Daher sollten unendliche Größen nur im Zusammenhang mit Grenzwerten `limit`, bestimmten Integralen `integrate` oder Reihen `sum` verwendet werden.

Konstante: %phi

  `%phi` repräsentiert die Goldene Zahl (1 + sqrt(5))/2. Der Wert als Gleitkommazahl in doppelter Genauigkeit ist 1.618033988749895d0.

  Die Funktion `fibtophi` drückt Fibonacci-Zahlen `fib(n)` durch die Goldene Zahl `%phi` aus. Standardmäßig kennt Maxima keine algebraischen Eigenschaften der Konstanten `%phi`. Mit den Eingaben `tellrat(%phi^2-%phi-1)` und `algebraic: true` kann die Funktion `ratsimp` einige Vereinfachungen ausführen.

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

  Beispiele:

  Numerische Werte für `%phi`.

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

  `fibtophi` drückt Fibonacci-Zahlen `fib(n)` durch `%phi` aus.

      (%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 (%);

                  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

      (%i4) ratsimp (%);
      (%o4)                           0

  Mit den Eingaben `tellrat(%phi^2-%phi-1)` und `algebraic:true` kann die Funktion `ratsimp` einige Vereinfachungen für Ausdrücke ausführen, die `%phi` enthalten.

      (%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

Konstante: %pi

  `%pi` repräsentiert die Kreiszahl. Der numerische Wert als Gleitkommazahl in doppelter Genauigkeit ist `3.141592653589793d0`.

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

  Beispiele:

  Numerische Werte für `%pi`.

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

  Grenzwert und bestimmte Integrale, die `%pi` als Ergebnis haben.

      (%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)

Konstante: true

  `true` repräsentiert den logischen Wert `wahr`. Intern ist `true` als die Lisp-Konstante `T` implementiert.

  Siehe auch `false` für den logischen Wert `falsch`.

Konstante: und

  `und` repräsentiert ein nicht definiertes Ergebnis. Siehe auch `ind` und die Funktion `limit`.

  Beispiel:

      (%i1) limit (x*sin(x), x, inf);
      (%o1)                          und

Konstante: zeroa

  `zeroa` repräsentiert eine positive unendlich kleine Zahl. `zeroa` kann in Ausdrücken benutzt werden. Die Funktion `limit` vereinfacht Ausdrücke, die infinitesimale Größen enthalten.

  Siehe auch `zerob` und `limit`.

  Beispiele:

  `limit` vereinfacht Ausdrücke, die infinitesimale Größen enthalten.

      (%i1) limit(zeroa);
      (%o1)                           0
      (%i2) limit(x+zeroa);
      (%o2)                           x

Konstante: zerob

  `zerob` repräsentiert eine negative unendlich kleine Zahl. `zerob` kann in Ausdrücken benutzt werden. Die Funktion `limit` vereinfacht Ausdrücke, die infinitesimale Größen enthalten.

  Siehe auch `zeroa` und `limit`.

Next: Listen, Previous: Zeichenketten, Nach oben: Datentypen und Strukturen [Inhalt][Index]