Next: Winkelfunktionen, Previous: Funktionen der Kombinatorik, Up: Mathematische Funktionen [Contents][Index]

### 10.4 Wurzel-, Exponential- und Logarithmusfunktion

Optionsvariable: %e_to_numlog

  Standardwert: `false`

  Hat die Optionsvariable `%e_to_numlog` den Wert `true`, wird ein Ausdruck mit der Exponentialfunktion `exp` der Form `%e^(r*log(x))` zu `x^r` vereinfacht, wenn `r` eine rationale Zahl ist. Ist `r` eine ganze Zahl, wird die Vereinfachung von der Optionsvariablen `logsimp` kontrolliert.

  Beispiel:

      (%i1) exp(1/2*log(x));
                                    log(x)
                                    ------
                                      2
      (%o1)                       %e
      (%i2) exp(1/2*log(x)), %e_to_numlog:true;
      (%o2)                        sqrt(x)

Optionsvariable: %emode

  Standardwert: `true`

  Die Optionsvariable `%emode` kontrolliert die Vereinfachung von Ausdrücken mit der Exponentialfunktion `exp` der Form `%e^(%pi %i x)`.

  Ist das Argument x eine ganze Zahl oder eine rationale Zahl, die ein Vielfaches von 1/2, 1/3, 1/4 oder 1/6 ist, dann wird der Ausdruck `%e^(%pi %i x)` zu einer reellen oder komplexen Zahl vereinfacht. Für Gleitkommazahlen wird diese Vereinfachung dann ausgeführt, wenn diese eine ganze Zahl oder halbzahlige rationale Zahl repräsentieren.

  Eine Summe im Exponenten wie zum Beispiel `%e^(%pi *%i (x+n))`, wobei n eine der oben genannten Zahlen und x ein allgemeiner Ausdruck ist, wird vereinfacht, indem der Faktor `%^(%pi %i n)` entsprechend vereinfacht wird.

  Hat `%emode` den Wert `false`, werden keine speziellen Vereinfachungen für den Ausdruck `%e^(%pi %i x)` vorgenommen.

  Beispiele:

      (%i1) exp([2*%pi*%i, 1/2*%pi*%i, 0.5*%pi*%i, 0.5b0*%pi*%i]);
      (%o1)               [1, %i, 1.0 %i, 1.0b0 %i]

      (%i2) exp([1/3*%pi*%i, 1/4*%pi*%i, 1/6*%pi*%i]);
               sqrt(3) %i   1    %i         1     %i   sqrt(3)
      (%o2)   [---------- + -, ------- + -------, -- + -------]
                   2        2  sqrt(2)   sqrt(2)  2       2

      (%i3) exp((1/3+x)*%pi*%i);
                          sqrt(3) %i   1    %i %pi x
      (%o3)              (---------- + -) %e
                              2        2

Optionsvariable: %enumer

  Standardwert: `false`

  Hat `%enumer` den Wert `true`, wird die Konstante `%e` immer dann durch ihren nummerischen Wert ersetzt, wenn die Optionsvariable `numer` den Wert `true` hat.

  Hat `%enumer` den Wert `false`, wird die Konstante `%e` nur dann durch ihren nummerischen Wert ersetzt, wenn der Exponent von `%e^x` zu einer Gleitkommazahl ausgewertet wird.

  Siehe auch `ev` und `numer`.

  Beispiel:

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

Funktion: exp (z)

  Ist die Exponentialfunktion. Die Exponentialfunktion `exp` wird von Maxima sofort zu `%e^z` vereinfacht und tritt in vereinfachten Ausdrücken nicht auf. Maxima vereinfacht die Exponentialfunktion daher wie die allgemeine Exponentiation `^`. Darüberhinaus kennt Maxima spezielle Regeln für die Vereinfachung der Exponentialfunktion.

  Ist das Argument z der Exponentialfunktion eine ganze oder rationale Zahl wird ein vereinfachter Ausdruck zurückgegeben. Ist das Argument z eine reelle oder komplexe Gleitkommazahl wird ein numerisches Ergebnis berechnet.

  Folgende Optionsvariablen kontrollieren die Vereinfachung der Exponentialfunktion:

  `%enumer`

    Hat die Optionsvariable `%enumer` den Wert `true`, vereinfacht Maxima die Eulersche Zahl `%e` immer dann zu ihrem numerischen Wert, wenn die Optionsvariable `numer` auch den Wert `true` hat.

  `%emode`

    Hat die Optionsvariable `%emode` den Wert `true`, wendet Maxima Regeln an, um Ausdrücke der Form `%e^(x*%i*%pi)` zu vereinfachen. Der Standardwert von `%emode` ist `true`. Wenn mit komplexen Zahlen in der Polarform gerechnet wird, kann es hilfreich sein, die Optionsvariable `%emode` auf den Wert `false` zu setzen.

  `%e_to_numlog`

    Hat die Optionsvariable `%e_to_numlog` den Wert `true`, vereinfacht Maxima einen Ausdruck `%e^(r*log(x)` zu `x^r`, wobei r eine rationale Zahl ist. Ist r eine ganze Zahl wird diese Vereinfachung von der Optionsvariablen `logsimp` kontrolliert. Für reelle oder komplexe Gleitkommazahlen wird diese Vereinfachung nicht ausgeführt.

  `radexpand`

    Die Optionsvariable `radexpand` kontrolliert die Vereinfachung von Ausdrücken der Form `(%e^a)^b`. Ist a ein reelles Argument vereinfacht Maxima immer zu einem Ausdruck `%e^(a*b)`. Ist a ein komplexes Argument, wird die Vereinfachung `%e^(a*b)` dann ausgeführt, wenn die Optionsvariable `radexpand` den Wert `all` hat.

  `logsimp`

    Die Optionsvariable `logsimp` kontrolliert die Vereinfachung der Exponentialfunktion für den Fall, dass im Argument expr die Logarithmusfunktion `log` auftritt. Hat die `logsimp` den Wert `true`, wird ein Ausdruck `%e^(n*log(x)` zu `x^n` vereinfacht, wenn n eine ganze Zahl ist. Mit der Optionsvariablen `%e_to_numlog` wird diese Vereinfachung für eine rationale Zahl n kontrolliert.

  `demoivre`

    Ist eine Optionsvariable und eine Funktion, die auch als Auswertungsschalter `evflag` definiert ist. Hat die Optionsvariable `demoivre` den Wert `true`, wird ein Ausdruck `%e^(x + %i y)` zu `%e^x (cos(y) + %i sin(y))` vereinfacht. Siehe auch die Optionsvariable `exponentialize`.

  Maxima kennt viele spezielle unbestimmte und bestimmte Integrale mit der Exponentialfunktion.

Funktion: log (z)

  Ist der natürliche Logarithmus zur Basis e. Die Logarithmusfunktion ist für das numerische und symbolische Rechnen geeignet.

  Maxima hat keine vordefinierte Logarithmusfunktion zur Basis 10 oder anderen Basen. Eine einfache Definition ist zum Beispiel `log10(x) := log(x)/log(10)`. Mit dem Kommando `load(log10)` kann ein Paket geladen werden, dass eine dekadische Logarithmusfunktion `log10` definiert.

  Ist das Argument z der Logarithmusfunktion eine ganze oder rationale Zahl wird ein vereinfachter Ausdruck zurückgegeben. Ist das Argument z eine reelle oder komplexe Gleitkommazahl wird ein numerisches Ergebnis berechnet.

  Die folgenden Optionsvariablen kontrollieren die Vereinfachung und Auswertung der Logarithmusfunktion:

  `logexpand`

    Hat die Optionsvariable `logexpand` den Wert `true`, dann wird `log(a^b)` zu `b*log(a)` vereinfacht. Hat `logexpand` den Wert `all`, wird zusätzlich `log(a*b)` zu `log(a)+log(b)` vereinfacht. Mit den Wert `super` vereinfacht Maxima weiterhin `log(a/b)` zu `log(a)-log(b)`, wobei `a/b` eine rationale Zahl ist. `log(1/b` wird für eine ganze Zahl `b` immer vereinfacht. Hat die Optionsvariable `logexpand` den Wert `false` werden alle obigen Vereinfachungen ausgeschaltet.

  `logsimp`

    Hat die Optionsvariable `logsimp` den Wert `false`, werden Exponentialfunktionen `exp`, die Logarithmusfunktionen im Exponenten enthalten, nicht vereinfacht.

  `lognegint`

    Hat die Optionsvariable `lognegint` den Wert `true`, wird `log(-n)` zu `log(n)+%i*%pi` für positive `n` vereinfacht.

  `%e_to_numlog`

    Hat die Optionsvariable `%e_to_numlog` den Wert `true`, wird ein Ausdruck `%e^(r*log(x))` zu `x^r` vereinfacht. Dabei sind `r` eine rationale Zahl und `x` ein beliebiger Ausdruck. Die Funktion `radcan` führt diese Vereinfachung ebenfalls aus.

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

  Beispiele:

  Verschiedene Beispiele mit der Logarithmusfunktion.

      (%i1) log(%e);
      (%o1)                           1
      (%i2) log(100.0);
      (%o2)                   4.605170185988092
      (%i3) log(2.5+%i);
      (%o3)       .3805063771123649 %i + .9905007344332917
      (%i4) taylor(log(1+x),x,0,5);
                             2    3    4    5
                            x    x    x    x
      (%o4)/T/          x - -- + -- - -- + -- + . . .
                            2    3    4    5
      (%i5) rectform(log(x+%i*y));
                             2    2
                        log(y  + x )
      (%o5)             ------------ + %i atan2(y, x)
                             2
      (%i6) limit(log(x),x,0,plus);
      (%o6)                         minf
      (%i7) integrate(log(z)^n,z);

                                                          - n - 1
      (%o7) - gamma_incomplete(n + 1, - log(z)) (- log(z))
                                                                  n + 1
                                                            log(z)

      (%i8) laplace(log(t),t,s);

                              - log(s) - %gamma
      (%o8)                   -----------------
                                      s

      (%i9) depends(y,x);
      (%o9)                        [y(x)]
      (%i10) ode2(diff(y,x)+log(y)+1,y,x);
                  - 1
      (%o10)    %e    expintegral_e(1, - log(y) - 1) = x + %c

Optionsvariable: logabs

  Standardwert: `false`

  Treten bei der unbestimmten Integration Logarithmusfunktionen im Ergebnis auf, so wird der Betrag der Argumente der Logarithmusfunktionen gebildet, wenn die Optionsvariable `logabs` den Wert `true` hat.

  Beispiele:

      (%i1) logabs:true;
      (%o1)                         true
      (%i2) integrate(1/x,x);
      (%o2)                      log(abs(x))
      (%i3) integrate(1/(1+x^3),x);
                                                         2 x - 1
                  ! 2        !                      atan(-------)
              log(!x  - x + 1!)   log(abs(x + 1))        sqrt(3)
      (%o3) - ----------------- + --------------- + -------------
                      6                  3             sqrt(3)

Funktion: logarc (expr)
Optionsvariable: logarc

  Hat die Optionsvariable `logarc` den Wert `true`, werden inverse Winkel- und Hyperbelfunktionen durch Logarithmusfunktionen ersetzt. Der Standardwert von `logarc` ist `false`.

  Die Funktion `logarc(expr)` führt diese Ersetzung aus, ohne dass die Optionsvariable `logarc` gesetzt wird.

  Beispiele:

      (%i1) logarc(asin(x));
                                           2
      (%o1)             - %i log(sqrt(1 - x ) + %i x)
      (%i2) logarc:true;
      (%o2)                         true
      (%i3) asin(x);
                                           2
      (%o3)             - %i log(sqrt(1 - x ) + %i x)

Optionsvariable: logconcoeffp

  Standardwert: `false`

  Der Optionsvariablen `logconcoeffp` kann eine Aussagefunktion mit einem Argument zugewiesen werden, die kontrolliert, welche Koeffizienten von der Funktion `logcontract` zusammengezogen werden. Sollen zum Beispiel Wurzeln generiert werden, kann folgende Aussagefunktion definiert werden:

      logconcoeffp:'logconfun$
      logconfun(m) := featurep(m,integer) or ratnump(m)$

  Das Kommando `logcontract(1/2*log(x))` liefert nun das Ergebnis `log(sqrt(x))`.

Funktion: logcontract (expr)

  Der Ausdruck expr wird rekursiv nach Ausdrücken der Form `a1*log(b1) + a2*log(b2) + c` durchsucht. Diese werden zu `log(ratsimp(b1^a1 * b2^a2)) + c` transformiert.

      (%i1) 2*(a*log(x) + 2*a*log(y))$
      (%i2) logcontract(%);
                                       2  4
      (%o2)                     a log(x  y )

  Wird die Variable n mit dem Kommando `declare(n, integer)` als eine ganze Zahl deklariert, dann wird `logcontract(2*a*n*log(x))` zu `a*log(x^(2*n))` vereinfacht. Die Koeffizienten, die zusammengezogen werden, sind in diesem Fall die Zahl 2 und die Variable n, welche die folgende Aussage erfüllen `featurep(coeff, integer)`. Der Nutzer kann kontrollieren, welche Koeffizienten zusammengezogen werden. Dazu wird der Optionsvariablen `logconcoeffp` eine Aussagefunktion mit einem Argument zugewiesen. Sollen zum Beispiel Wurzeln generiert werden, kann folgende Definition verwendet: `logconcoeffp: 'logconfun$ logconfun(m) := featurep(m,integer) or ratnump(m)$`. Dann hat das Kommando `logcontract(1/2*log(x))` das Ergebnis `log(sqrt(x))`.

Optionsvariable: logexpand

  Standardwert: `true`

  Die Optionsvariable `logexpand` kontrolliert die Vereinfachung der Logarithmusfunktion `log`.

  Hat `logexpand` den Wert `true`, wird `log(a^b)` zu `b*log(a)` vereinfacht. Hat `logexpand` den Wert `all`, wird zusätzlich `log(a*b)` zu `log(a)+log(b)` vereinfacht. Mit dem Wert `super` vereinfacht Maxima weiterhin `log(a/b)` zu `log(a)-log(b)`, wobei `a/b` eine rationale Zahl ist. `log(1/b` wird für eine ganze Zahl `b` immer vereinfacht. Hat die Optionsvariable `logexpand` den Wert `false` werden alle obigen Vereinfachungen ausgeschaltet.

Optionsvariable: lognegint

  Standardwert: `false`

  Hat die Optionsvariable `lognegint` den Wert `true`, wird `log(-n)` zu `log(n)+%i*%pi` für positive `n` vereinfacht.

Optionsvariable: logsimp

  Standardwert: `true`

  Hat die Optionsvariable `logsimp` den Wert `false`, werden Exponentialfunktionen `exp`, die Logarithmusfunktionen im Exponenten enthalten, nicht vereinfacht.

Funktion: plog (x)

  Gibt den Hauptwert des komplexen natürlichen Logarithmus im Intervall `-%pi` < `carg(x)` <= `+%pi` zurück.

Optionsvariable: rootsconmode

  Standardwert: `true`

  `rootsconmode` kontrolliert das Verhalten der Funktion `rootscontract`. Siehe die Funktion `rootscontract` für Details.

Funktion: rootscontract (expr)

  Konvertiert Produkte von Wurzeln in Wurzeln von Produkten. Zum Beispiel hat `rootscontract(sqrt(x)*y^(3/2))` das Ergebnis `sqrt(x*y^3)`.

  Hat die Optionsvariable `radexpand` den Wert `true` und die Optionsvariable `domain` den Wert `real`, das sind die Standardwerte, wird `abs(x)` zu `sqrt(x^2)` vereinfacht. Zum Beispiel hat `rootscontract(abs(x) * sqrt(y))` das Ergebnis `sqrt(x^2*y)`.

  Die Optionsvariable `rootsconmode` kontrolliert das Ergebnis folgendermaßen:

      Problem             Wert             Ergebnis
                          rootsconmode     rootscontract

      x^(1/2)*y^(3/2)     false            sqrt(x*y^3)
      x^(1/2)*y^(1/4)     false            sqrt(x)*y^(1/4)
      x^(1/2)*y^(1/4)     true             sqrt(x*sqrt(y))
      x^(1/2)*y^(1/3)     true             sqrt(x)*y^(1/3)
      x^(1/2)*y^(1/4)     all              (x^2*y)^(1/4)
      x^(1/2)*y^(1/3)     all              (x^3*y^2)^(1/6)

  Hat `rootsconmode` den Wert `false`, kontrahiert `rootscontract` nur Faktoren mit rationalen Exponenten, die den gleichen Nenner haben. Hat `rootsconmode` den Wert `all`, wird das kleinste gemeinsame Vielfache des Nenners der Faktoren verwendet, um die Faktoren zusammenzufassen.

  Ähnlich wie bei der Funktion `logcontract` werden von `rootscontract` die Argumente unter der Wurzel mit der Funktion `ratsimp` vereinfacht.

  Beispiele:

      (%i1) rootsconmode: false$
      (%i2) rootscontract (x^(1/2)*y^(3/2));
                                         3
      (%o2)                      sqrt(x y )
      (%i3) rootscontract (x^(1/2)*y^(1/4));
                                         1/4
      (%o3)                     sqrt(x) y
      (%i4) rootsconmode: true$
      (%i5) rootscontract (x^(1/2)*y^(1/4));
      (%o5)                    sqrt(x sqrt(y))

      (%i6) rootscontract (x^(1/2)*y^(1/3));
                                         1/3
      (%o6)                     sqrt(x) y

      (%i7) rootsconmode: all$
      (%i8) rootscontract (x^(1/2)*y^(1/4));
                                    2   1/4
      (%o8)                       (x  y)
      (%i9) rootscontract (x^(1/2)*y^(1/3));
                                   3  2 1/6
      (%o9)                      (x  y )
      (%i10) rootsconmode: false$
      (%i11) rootscontract (sqrt(sqrt(x) + sqrt(1 + x))
                          *sqrt(sqrt(1 + x) - sqrt(x)));
      (%o11)                          1
      (%i12) rootsconmode: true$
      (%i13) rootscontract (sqrt(5+sqrt(5)) - 5^(1/4)*sqrt(1+sqrt(5)));
      (%o13)                          0

Funktion: sqrt (z)

  Ist die Wurzelfunktion. Die Wurzelfunktion wird von Maxima sofort zu `x^(1/2)` vereinfacht und tritt in Ausdrücken nicht auf.

  Die Wurzelfunktion ist für das numerische und symbolische Rechnen geeignet. Ist das Argument z der Wurzelfunktion eine Gleitkommazahl, wird ein numerisches Ergebnis zurückgegeben. Für ganze und rationale Zahlen wird die Wurzelfunktion vereinfacht. Die numerische Berechnung kann mit den Optionsvariablen und Auswertungsschaltern `numer` und `float` kontrolliert werden.

  Hat die Optionsvariable `radexpand` den Wert `true`, werden die n-ten Wurzeln von Faktoren unter einer Wurzel aus der Wurzel herausgezogen. So wird zum Beispiel `sqrt(16*x^2)` nur dann zu `4*x` vereinfacht, wenn `radexpand` den Wert `true` hat.

  Siehe auch die Funktionen `rootscontract` und `sqrtdenest` für die Vereinfachung von Ausdrücken, die die Wurzelfunktion enthalten.

  Beispiele:

  Verschiedene Beispiele mit der Wurzelfunktion.

      (%i1) sqrt(4);
      (%o1)                           2
      (%i2) sqrt(24);
      (%o2)                       2 sqrt(6)
      (%i3) sqrt(2.0);
      (%o3)                   1.414213562373095
      (%i4) taylor(sqrt(1+x),x,0,5);
                             2    3      4      5
                        x   x    x    5 x    7 x
      (%o4)/T/      1 + - - -- + -- - ---- + ---- + . . .
                        2   8    16   128    256
      (%i5) rectform(sqrt(x+%i*y));
                 2    2 1/4     atan2(y, x)
      (%o5) %i (y  + x )    sin(-----------)
                                     2
                                            2    2 1/4     atan2(y, x)
                                        + (y  + x )    cos(-----------)
                                                                2
      (%i6) integrate(sqrt(t)*(t+1)^-2,t,0,1);
                                   %pi - 2
      (%o6)                        -------
                                      4

Next: Winkelfunktionen, Previous: Funktionen der Kombinatorik, Up: Mathematische Funktionen [Contents][Index]