Maxima Manual: 18. Gleichungen

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 18. Gleichungen

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 18.1 Funktionen und Variablen für Gleichungen

Optionsvariable: %rnum

  Standardwert: `0`

  Wenn notwendig erzeugen die Funktionen `solve` und `algsys` freie Parameter, die in die Lösungen eingesetzt werden. Die Parameter haben den Namen `%r<num>`. Die Optionsvariable `%rnum` enthält die Nummer num, die an den Präfix `%r` angehängt wird. Maxima erhöht `%rnum` automatisch. Siehe auch die Systemvariable `%rnum_list` für eine Liste der Parameter einer Lösung.

Systemvariable: %rnum_list

  Standardwert: `[]`

  `%rnum_list` ist die Liste der freien Parameter, die von `solve` und `algsys` in Lösungen eingesetzt werden. Die Parameter werden der Liste `%rnum_list` in der Reihenfolge hinzugefügt, in der sie erzeugt werden.

  Beispiele:

      (%i1) solve ([x + y = 3], [x,y]);
      (%o1)              [[x = 3 - %r1, y = %r1]]
      (%i2) %rnum_list;
      (%o2)                       [%r1]
      (%i3) sol : solve ([x + 2*y + 3*z = 4], [x,y,z]);
      (%o3)   [[x = - 2 %r3 - 3 %r2 + 4, y = %r3, z = %r2]]
      (%i4) %rnum_list;
      (%o4)                     [%r2, %r3]
      (%i5) for i : 1 thru length (%rnum_list) do
              sol : subst (t[i], %rnum_list[i], sol)$
      (%i6) sol;
      (%o6)     [[x = - 2 t  - 3 t  + 4, y = t , z = t ]]
                           2      1           2       1

Optionsvariable: algexact

  Standardwert: `false`

  Die Optionsvariable `algexact` kontrolliert die Funktion `algsys` folgendermaßen:

  - Hat `algexact` den Wert `true`, wird von der Funktion `algsys` stets `solve` aufgerufen. Findet `solve` keine Lösung, wird die Funktion `realroots` aufgerufen.
  - Hat `algexact` den Wert `false`, wird die Funktion `solve` nur für Gleichungen aufgerufen, die von mehr als einer Variablen abhängen und für quadratische oder kubische Gleichungen.

  Der Wert `true` für `algexact` garantiert nicht, dass `algsys` nur exakte Lösungen findet. Findet `algsys` keine exakten Lösungen, versucht `solve` immer Näherungslösungen zu finden.

  Beispiele:

      (%i1) algexact:true$

      (%i2) algsys([x^5-1],[x]);
                                            sqrt(5)   5
                                     sqrt(- ------- - -)
                           sqrt(5)             2      2    1
      (%o2) [[x = 1], [x = ------- + ------------------- - -],
                              4               2            4
                            sqrt(5)   5
                     sqrt(- ------- - -)
           sqrt(5)             2      2    1
      [x = ------- - ------------------- - -],
              4               2            4
                            sqrt(5)   5
                       sqrt(------- - -)
             sqrt(5)           2      2    1
      [x = - ------- + ----------------- - -],
                4              2           4
                            sqrt(5)   5
                       sqrt(------- - -)
             sqrt(5)           2      2    1
      [x = - ------- - ----------------- - -]]
                4              2           4

      (%i3) algexact:false$

      (%i4) algsys([x^5-1],[x]);
      (%o4) [[x = 1], [x = - .5877852522924731 %i
       - .8090169943749475], [x = .5877852522924731 %i
       - .8090169943749475], [x = .3090169943749475
       - .9510565162951535 %i], [x = .9510565162951535 %i
       + .3090169943749475]]

  Auch wenn die Optionsvariable `algexact` den Wert `true` hat, gibt `algsys` numerische Näherungslösungen zurück, wenn `solve` keine Lösungen finden kann.

      (%i5) algexact:true$

      (%i6) algsys([x^5-x^3+1],[x]);
      (%o6) [[x = - 1.236505681818182],
      [x = - 0.785423103049449 %i - .3407948661970064],
      [x = 0.785423103049449 %i - .3407948661970064],
      [x = .9590477178927559 - .4283659562541893 %i],
      [x = .4283659562541893 %i + .9590477178927559]]

      (%i7) solve([x^5-x^3+1],[x]);
                                    5    3
      (%o7)                   [0 = x  - x  + 1]

  Für eine quadratische Gleichung wird immer eine exakte Lösung zurückgeben.

      (%i8) algsys:true$

      (%i9) algsys([x^2+x-1],[x]);
                       sqrt(5) - 1          sqrt(5) + 1
      (%o9)      [[x = -----------], [x = - -----------]]
                            2                    2
      (%i11) algsys:false$

      (%i12) algsys([x^2+x-1],[x]);
                        sqrt(5) - 1          sqrt(5) + 1
      (%o12)      [[x = -----------], [x = - -----------]]
                             2                    2

Optionsvariable: algepsilon

  Standardwert: `10^8`

  Kontrolliert die Genauigkeit einer numerischen Lösung der Funktion `algsys` für den Fall, dass die Optionsvariable `realonly` den Wert `true` hat, also nur die reellen Lösungen gesucht werden.

  Beispiele:

  Numerische Lösung der Gleichung `x^3-2` für zwei verschiedene Wert für `algepsilon`.

      (%i1) realonly:true$
      (%i2) algepsilon:10^2;
      (%o2)                          100
      (%i3) algsys([x^3-2],[x]);
      (%o3)                  [[x = 1.26171875]]
      (%i4) algepsilon: 10^8;
      (%o4)                       100000000
      (%i5) algsys([x^3-2],[x]);
      (%o5)               [[x = 1.259921095381759]]

  `algepsilon` hat keinen Einfluss auf die Genauigkeit der Lösung, wenn auch die komplexen Lösungen gesucht werden.

      (%i6) realonly:false$
      (%i7) algepsilon: 10^2;
      (%o7)                          100
      (%i8) algsys([x^3-2],[x]);
      (%o8) [[x = - 1.091123635971721 %i - .6299605249474366],
      [x = 1.091123635971721 %i - .6299605249474366],
      [x = 1.259921095381759]]

Funktion: algsys ([expr_1, …, expr_m], [x_1, …, x_n])
Funktion: algsys ([eqn_1, …, eqn_m], [x_1, …, x_n])

  Löst ein Gleichungssystem mit den Polynomen expr_1, …, expr_m oder den Gleichungen eqn_1, …, eqn_m für die Variablen x_1, …, x_n. Werden Polynome expr_i als Argument übergeben, werden diese als Gleichungen `expr_i = 0` interpretiert. Die Anzahl der Gleichungen und Variablen kann verschieden sein.

  `algsys` gibt eine Liste mit den Lösungen zurück. Jede Lösung ist wiederum eine Liste mit den Lösungen für die einzelnen Variablen x_i, die als Gleichungen angegeben sind. Kann `algsys` keine Lösung finden, wird eine leere Liste `[]` zurückgegeben.

  Haben die Lösungen freie Parameter, setzt `algsys` die Symbole `%r1`, `%r2`, … in die Lösungen ein. Die freien Parameter werden der Liste `%rnum_list` hinzugefügt. Siehe `%rnum_list`.

  Die Funktion `algsys` führt die folgenden Schritte aus, um Lösungen eines Gleichungssystems zu finden:

  1. Die Gleichungen werden faktorisiert und in Teilsysteme S_i aufgeteilt.
  2. Für jedes Teilsystem S_i werden eine Gleichung E, die den niedrigsten von Null verschiedenen Grad hat und eine Variable x ausgewählt. Dann wird die Resultante der Gleichungen E und E_j für die Variable x sowie allen verbleibenden Gleichungen E_j des Teilsystems S_i berechnet. Dieses Verfahren eliminiert die Variable x und hat ein neues Teilsystem S_i' als Ergebnis. Der Algorithmus wiederholt dann den 1. Schritt.
  3. Besteht das Teilsystem nur noch aus einer Gleichung, hat diese Gleichung mehrere Variablen und enthält diese keine Gleitkommazahlen, dann wird `solve` aufgerufen, um eine exakte Lösung zu finden.

     Es kann sein, dass `solve` keine Lösung oder einen sehr großen Ausdruck als Lösung findet.

     Auch für Gleichungen, die nur eine Variable enthalten und die entweder linear, quadratisch oder quartisch sind sowie keine Gleitkommazahlen enthalten, wird `solve` aufgerufen, um eine exakte Lösung zu finden. Trifft dies nicht zu, wird in dem Fall, dass die `realonly` den Wert `true` hat, die Funktion `realroots`. Ansonsten wird die Funktion `allroots` aufgerufen. Die Funktion `realroots` sucht reelle Lösungen der Gleichung, während die Funktion `allroots` auch komplex Lösungen sucht.

     Für den Fall, dass `realonly` den Wert `true` hat, wird die Genauigkeit einer numerischen Lösung von der Optionsvariablen `algepsilon` kontrolliert.

     Hat die Optionsvariable `algexact` den Wert `true`, wird immer die Funktion `solve` aufgerufen.

  4. Zuletzt werden die erhaltenen Lösungen in das betrachtete Teilsystem eingesetzt und der Lösungsalgorithmus mit dem 1. Schritt fortgesetzt.

  Tritt beim Lösen des Gleichungssystems eine Gleichung auf, die von mehreren Variablen abhängt und Gleitkommazahlen enthält, dann wird der Algorithmus mit der Meldung `algsys cannot solve - system too complicated."` abgebrochen. Ein Näherung mit Gleitkommazahlen kann in vorgehenden Schritten auftreten, wenn keine exakten Lösungen auffindbar sind.

  Ist das Argument der Funktion `allroots` kein Polynom, gibt Maxima eine Fehlermeldung aus. Die Lösungen eines Gleichungssystems können sehr große Ausdrücke sein. Obwohl die Lösung reell ist, kann die imaginäre Einheit `%i` in den Lösungen enthalten sein. Für die weitere Bearbeitung der Lösungen können die Funktionen `pickapart` oder `reveal` hilfreich sein.

  Beispiele:

      (%i1) e1: 2*x*(1 - a1) - 2*(x - 1)*a2;
      (%o1)              2 (1 - a1) x - 2 a2 (x - 1)
      (%i2) e2: a2 - a1;
      (%o2)                        a2 - a1
      (%i3) e3: a1*(-y - x^2 + 1);
                                         2
      (%o3)                   a1 (- y - x  + 1)
      (%i4) e4: a2*(y - (x - 1)^2);
                                             2
      (%o4)                   a2 (y - (x - 1) )
      (%i5) algsys ([e1, e2, e3, e4], [x, y, a1, a2]);
      (%o5) [[x = 0, y = %r1, a1 = 0, a2 = 0],

                                        [x = 1, y = 0, a1 = 1, a2 = 1]]
      (%i6) e1: x^2 - y^2;
                                    2    2
      (%o6)                        x  - y
      (%i7) e2: -1 - y + 2*y^2 - x + x^2;
                               2        2
      (%o7)                 2 y  - y + x  - x - 1
      (%i8) algsys ([e1, e2], [x, y]);
                       1            1
      (%o8) [[x = - -------, y = -------],
                    sqrt(3)      sqrt(3)

              1              1             1        1
      [x = -------, y = - -------], [x = - -, y = - -], [x = 1, y = 1]]
           sqrt(3)        sqrt(3)          3        3

Funktion: allroots (expr)
Funktion: allroots (eqn)

  Berechnet numerische Näherungen der reellen und komplexen Wurzeln des Polynoms expr oder der Polynomgleichung eqn mit einer Variablen.

  Hat der Schalter `polyfactor` den Wert `true`, wird das Polynom über die reellen oder komplexen Zahlen faktorisiert.

  Für den Fall mehrfacher Wurzeln kann `allroots` ungenaue Ergebnisse liefern. Ist das Polynom reell, kann es sein, dass `allroots(%i*p)`) genauere Approximationen liefern als `allroots (p)`, da `allroots` in diesem Fall einen anderen Algorithmus verwendet.

  Der Zähler des Arguments der Funktion `allroots` muss nach Anwendung der Funktion `rat` ein Polynom sein und darf im Nenner höchstens eine komplexe Zahl enthalten. Ist das Argument der Funktion `allroots` kein Polynom, gibt Maxima eine Fehlermeldung. Daher wird von der Funktion `allroots` immer ein äquivalenter, jedoch faktorisierter Ausdruck zurückgegeben, wenn die Optionsvariable `polyfactor` den Wert `true` hat.

  Für komplexe Polynome wird ein Algorithmus von Jenkins und Traub verwendet (Algorithm 419, Comm. ACM, vol. 15, (1972), p. 97). Für reelle Polynome wird ein Algorithmus von Jenkins verwendet (Algorithm 493, ACM TOMS,vol. 1, (1975), p.178).

  Beispiele:

      (%i1) eqn: (1 + 2*x)^3 = 13.5*(1 + x^5);
                                  3          5
      (%o1)              (2 x + 1)  = 13.5 (x  + 1)
      (%i2) soln: allroots (eqn);
      (%o2) [x = .8296749902129361, x = - 1.015755543828121,

      x = .9659625152196369 %i - .4069597231924075,

      x = - .9659625152196369 %i - .4069597231924075, x = 1.0]
      (%i3) for e in soln
              do (e2: subst (e, eqn), disp (expand (lhs(e2) - rhs(e2))));
                            - 3.5527136788005E-15

                           - 5.32907051820075E-15

               4.44089209850063E-15 %i - 4.88498130835069E-15

              - 4.44089209850063E-15 %i - 4.88498130835069E-15

                             3.5527136788005E-15

      (%o3)                         done
      (%i4) polyfactor: true$
      (%i5) allroots (eqn);
      (%o5) - 13.5 (x - 1.0) (x - .8296749902129361)

                                 2
       (x + 1.015755543828121) (x  + .8139194463848151 x

       + 1.098699797110288)

Funktion: bfallroots (expr)
Funktion: bfallroots (eqn)

  Berechnet numerische Näherungen der reellen und komplexen Wurzeln des Polynoms expr oder der Polynomgleichung eqn in einer Variable.

  `bfallroots` entspricht der Funktion `allroots` mit dem Unterschied, dass die Funktion `bfallroots` die Näherungen mit großen Gleitkommazahlen berechnet. Siehe `allroots`.

  Beispiel:

  Dasselbe Beispiel wie für die Funktion `allroots`. Die Ergebnisse sind große Gleitkommazahlen.

      (%i1) eqn: (1 + 2*x)^3 = 13.5*(1 + x^5);
                                  3          5
      (%o1)              (2 x + 1)  = 13.5 (x  + 1)
      (%i2) soln: bfallroots(eqn);
      (%o2) [x = 8.296749902129362b-1, x = - 1.015755543828121b0,
      x = 9.65962515219637b-1 %i - 4.069597231924075b-1,
      x = - 9.65962515219637b-1 %i - 4.069597231924075b-1, x = 1.0b0]

Optionsvariable: backsubst

  Standardwert: `true`

  Hat `backsubst` den Wert `false`, werden die Lösungen der Funktion `linsolve` nicht rücksubstituiert. Dies kann hilfreich sein, wenn die Rücksubstitution zu sehr großen Ausdrücken führt.

  Beispiele:

      (%i1) eq1 : x + y + z = 6$
      (%i2) eq2 : x - y + z = 2$
      (%i3) eq3 : x + y - z = 0$
      (%i4) backsubst : false$
      (%i5) linsolve ([eq1, eq2, eq3], [x,y,z]);
      (%o5)             [x = z - y, y = 2, z = 3]
      (%i6) backsubst : true$
      (%i7) linsolve ([eq1, eq2, eq3], [x,y,z]);
      (%o7)               [x = 1, y = 2, z = 3]

Optionsvariable: breakup

  Standardwert: `true`

  Hat die Optionsvariablen `programmode` den Wert `false` und die Optionsvariable `breakup` den Wert `true`, dann werden für gemeinsame Terme in Lösungen von kubischen und quartischen Gleichungen Zwischenmarken erzeugt.

  Beispiele:

      (%i1) programmode: false$
      (%i2) breakup: true$
      (%i3) solve (x^3 + x^2 - 1);

                              sqrt(23)    25 1/3
      (%t3)                  (--------- + --)
                              6 sqrt(3)   54
      Solution:

                                            sqrt(3) %i   1
                                            ---------- - -
                      sqrt(3) %i   1            2        2   1
      (%t4)    x = (- ---------- - -) %t3 + -------------- - -
                          2        2            9 %t3        3

                                            sqrt(3) %i   1
                                          - ---------- - -
                    sqrt(3) %i   1              2        2   1
      (%t5)    x = (---------- - -) %t3 + ---------------- - -
                        2        2             9 %t3         3

                                         1     1
      (%t6)                  x = %t3 + ----- - -
                                       9 %t3   3
      (%o6)                    [%t4, %t5, %t6]
      (%i6) breakup: false$
      (%i7) solve (x^3 + x^2 - 1);
      Solution:

                   sqrt(3) %i   1
                   ---------- - -
                       2        2        sqrt(23)    25 1/3
      (%t7) x = --------------------- + (--------- + --)
                   sqrt(23)    25 1/3    6 sqrt(3)   54
                9 (--------- + --)
                   6 sqrt(3)   54

                                                    sqrt(3) %i   1    1
                                                 (- ---------- - -) - -
                                                        2        2    3

                 sqrt(23)    25 1/3  sqrt(3) %i   1
      (%t8) x = (--------- + --)    (---------- - -)
                 6 sqrt(3)   54          2        2

                                                  sqrt(3) %i   1
                                                - ---------- - -
                                                      2        2      1
                                            + --------------------- - -
                                                 sqrt(23)    25 1/3   3
                                              9 (--------- + --)
                                                 6 sqrt(3)   54

                  sqrt(23)    25 1/3             1             1
      (%t9)  x = (--------- + --)    + --------------------- - -
                  6 sqrt(3)   54          sqrt(23)    25 1/3   3
                                       9 (--------- + --)
                                          6 sqrt(3)   54
      (%o9)                    [%t7, %t8, %t9]

Funktion: dimension (eqn)
Funktion: dimension (eqn_1, …, eqn_n)

  `dimen` ist ein Paket für die Dimensionsanalyse. `load(dimen)` lädt dieses Paket. `demo(dimen)` zeigt eine kleine Demonstration.

Optionsvariable: dispflag

  Standardwert: `true`

  Hat `dispflag` den Wert `false`, werden Ausgaben der Funktion `solve` unterdrückt.

Funktion: funcsolve (eqn, g(t))

  Das Argument eqn ist eine Gleichung, die ein Polynom erster Ordnung in den Funktionen `g(t)` und `g(t+1)` ist. `funcsolve` sucht die rationale Funktion `g(t)`, die Lösung der Gleichung eqn ist.

  Warnung: Die Funktion ist nur sehr rudimentär implementiert. Offensichtliche Verallgemeinerungen fehlen.

  Beispiel:

      (%i1) eqn: (n + 1)*f(n) - (n + 3)*f(n + 1)/(n + 1) =
            (n - 1)/(n + 2);
                                  (n + 3) f(n + 1)   n - 1
      (%o1)        (n + 1) f(n) - ---------------- = -----
                                       n + 1         n + 2
      (%i2) funcsolve (eqn, f(n));

      Dependent equations eliminated:  (4 3)
                                         n
      (%o2)                f(n) = ---------------
                                  (n + 1) (n + 2)

Optionsvariable: globalsolve

  Standardwert: `false`

  Hat `globalsolve` den Wert `true`, werden den unbekannten Variablen eines linearen Gleichungssystems die Werte der Lösungen der Funktionen `linsolve` und `solve` zugewiesen.

  Hat `globalsolve` den Wert `false`, werden den unbekannten Variablen eines linearen Gleichungssystems keine Werte zugewiesen. Die Lösungen werden als Gleichungen mit den unbekannten Variablen ausgedrückt.

  Für andere als lineare Gleichungssysteme wird der Wert von `globalsolve` ignoriert. Die Funktion `algsys` ignoriert `globalsolve` immer.

  Beispiele:

      (%i1) globalsolve: true$
      (%i2) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]);
      Solution

                                       17
      (%t2)                        x : --
                                       7

                                         1
      (%t3)                        y : - -
                                         7
      (%o3)                     [[%t2, %t3]]
      (%i3) x;
                                     17
      (%o3)                          --
                                     7
      (%i4) y;
                                       1
      (%o4)                          - -
                                       7
      (%i5) globalsolve: false$
      (%i6) kill (x, y)$
      (%i7) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]);
      Solution

                                       17
      (%t7)                        x = --
                                       7

                                         1
      (%t8)                        y = - -
                                         7
      (%o8)                     [[%t7, %t8]]
      (%i8) x;
      (%o8)                           x
      (%i9) y;
      (%o9)                           y

Funktion: ieqn (ie, unk, tech, n, guess)

  `inteqn` ist ein Paket zur Lösung von Integralgleichungen zweiter Art der Form

                             b(x)
                            /
                            [
          p(x) = q(x, p(x), I     w(x, u, p(x), p(u)) du)
                            ]
                            /
                             a(x)

  und von Integralgleichungen erster Art der Form

                  b(x)
                 /
                 [
          f(x) = I     w(x, u, p(u)) du
                 ]
                 /
                  a(x)

  Das Kommando `load(inteqn)` lädt das Paket.

  Das erste Argument ie ist die Integralgleichung und das Argument unk die unbekannte Funktion. Mit dem Argument tech wird die Methode angegeben, die zur Lösung der Integralgleichung angewendet werden soll. Erhält das Argument tech den Wert `first`, wird das Ergebnis der ersten erfolgreichen Methode zurückgegeben. Mit `all` werden alle Methoden angewendet. Das Argument n gibt die maximale Anzahl an Termen an, die von den Methoden `taylor`, `neumann`, `firstkindseries` oder `fredseries` verwendet werden. n ist auch die maximale Tiefe der Rekursion für der Differentiationsmethode. Das Argument guess ist der Startwert der Methoden `neumann` oder `firstkindseries`.

  Die Standardwerte der Argumente sind:

  `unk`

    `p(x)`, wobei p die erste im Integranden aufgefundene Funktion ist, die Maxima unbekannt ist, und x die Variable ist, die im Falle einer Integralgleichung der zweiten Art als Argument der Funktion p außerhalb des Integrals vorgefunden wird, oder im Falle einer Integralgleichung der ersten Art die einzige andere Variable neben der Integrationsvariable ist. Wenn der Versuch fehlschlägt, die Variable x zu finden, wird der Nutzer nach der unabhängigen Variablen gefragt.

  `tech`

    `first`

  `n`

    `1`

  `guess`

    `none`, bewirkt, dass der Ansatz `f(x)` als Startwert der Lösungsmethoden `neumann` und `firstkindseries` verwendet wird.

  Siehe `share/integequations/inteqn.usg` für weitere Informationen.

Optionsvariable: ieqnprint

  Standardwert: `true`

  `ieqnprint` kontrolliert die Ausgabe des Ergebnisses der Funktion `ieqn`. Hat die Optionsvariable `ieqnprint` den Wert `true`, dann hat das Ergebnis der Funktion `ieqn` die Form `[solution, technique used, nterms, flag]`. Ist die Lösung exakt, tritt das Element `flag` nicht auf. Ansonsten erhält das Element `flag` den Wert `approximate` für eine nicht exakte Lösung und den Wert `incomplete` für eine nicht geschlossene Lösung. Wurde die Lösung mit einer Methode gefunden, die einen Reihenansatz verwendet, enthält nterms die Anzahl der Terme der Entwicklung.

Funktion: lhs (expr)

  Gibt die linke Seite des Ausdrucks expr zurück, wenn der Operator von expr einer der relationalen Operatoren `< <= = # equal notequal >= >`, einer der Zuweisungsoperatoren `:= ::= : ::` oder ein nutzerdefinierter binärer Infix-Operator ist, der mit der Funktion `infix` deklariert wurde. Die linke Seite des Ausdrucks ist für die hier genannten Operatoren das erste Argument.

  Wenn expr ein Atom ist oder sein Operator ein anderer als oben aufgelistet, gibt `lhs` den Ausdruck expr zurück. Siehe auch `rhs`.

  Beispiele:

      (%i1) e: aa + bb = cc;
      (%o1)                     bb + aa = cc
      (%i2) lhs (e);
      (%o2)                        bb + aa
      (%i3) rhs (e);
      (%o3)                          cc
      (%i4) [lhs (aa < bb), lhs (aa <= bb), lhs (aa >= bb),
             lhs (aa > bb)];
      (%o4)                   [aa, aa, aa, aa]
      (%i5) [lhs (aa = bb), lhs (aa # bb), lhs (equal (aa, bb)),
             lhs (notequal (aa, bb))];
      (%o5)                   [aa, aa, aa, aa]
      (%i6) e1: '(foo(x) := 2*x);
      (%o6)                     foo(x) := 2 x
      (%i7) e2: '(bar(y) ::= 3*y);
      (%o7)                    bar(y) ::= 3 y
      (%i8) e3: '(x : y);
      (%o8)                         x : y
      (%i9) e4: '(x :: y);
      (%o9)                        x :: y
      (%i10) [lhs (e1), lhs (e2), lhs (e3), lhs (e4)];
      (%o10)               [foo(x), bar(y), x, x]
      (%i11) infix ("][");
      (%o11)                         ][
      (%i12) lhs (aa ][ bb);
      (%o12)                         aa

Funktion: linsolve ([expr_1, …, expr_m], [x_1, …, x_n])

  Löst das lineare Gleichungssystem mit den Gleichungen oder Polynomen [expr_1, …, expr_m] und den Variablen [x_1, …, x_n]. Jede Gleichung muss ein Polynom in den angegebenen Variablen sein.

  Hat die Optionsvariable `globalsolve` den Wert `true`, werden die Lösungen des Gleichungssystems den angegebenen Variablen zugewiesen.

  Hat die Optionsvariable `backsubst` den Wert `false`, führt `linsolve` keine Rücksubstitutionen aus. Dies kann hilfreich sein, wenn die Rücksubstitution zu sehr großen Ausdrücken führt.

  Hat die Optionsvariable `linsolve_params` den Wert `true`, setzt `linsolve` für ein unterbestimmtes Gleichungssystem freie Parameter in die Lösungen ein, die mit `%r`-Symbolen bezeichnet werden. Siehe auch `%rnum` und `%rnum_list`.

  Hat die Optionsvariable `programmode` den Wert `false`, werden die Lösungen von `linsolve` Zwischenmarken `%t` zugewiesen. Die Zwischenmarken werden als Liste zurückgegeben.

  Beispiele:

      (%i1) e1: x + z = y;
      (%o1)                       z + x = y
      (%i2) e2: 2*a*x - y = 2*a^2;
                                             2
      (%o2)                   2 a x - y = 2 a
      (%i3) e3: y - 2*z = 2;
      (%o3)                      y - 2 z = 2
      (%i4) [globalsolve: false, programmode: true];
      (%o4)                     [false, true]
      (%i5) linsolve ([e1, e2, e3], [x, y, z]);
      (%o5)            [x = a + 1, y = 2 a, z = a - 1]
      (%i6) [globalsolve: false, programmode: false];
      (%o6)                    [false, false]
      (%i7) linsolve ([e1, e2, e3], [x, y, z]);
      Solution

      (%t7)                       z = a - 1

      (%t8)                        y = 2 a

      (%t9)                       x = a + 1
      (%o9)                    [%t7, %t8, %t9]
      (%i9) ''%;
      (%o9)            [z = a - 1, y = 2 a, x = a + 1]
      (%i10) [globalsolve: true, programmode: false];
      (%o10)                    [true, false]
      (%i11) linsolve ([e1, e2, e3], [x, y, z]);
      Solution

      (%t11)                      z : a - 1

      (%t12)                       y : 2 a

      (%t13)                      x : a + 1
      (%o13)                 [%t11, %t12, %t13]
      (%i13) ''%;
      (%o13)           [z : a - 1, y : 2 a, x : a + 1]
      (%i14) [x, y, z];
      (%o14)                 [a + 1, 2 a, a - 1]
      (%i15) [globalsolve: true, programmode: true];
      (%o15)                    [true, true]
      (%i16) linsolve ([e1, e2, e3], '[x, y, z]);
      (%o16)           [x : a + 1, y : 2 a, z : a - 1]
      (%i17) [x, y, z];
      (%o17)                 [a + 1, 2 a, a - 1]

Optionsvariable: linsolvewarn

  Standardwert: `true`

  Hat `linsolvewarn` den Wert `true`, gibt die Funktion `linsolve` gegebenenfalls die Meldung `Dependent equations eliminated` aus.

Optionsvariable: linsolve_params

  Standardwert: `true`

  Hat `linsolve_params` den Wert `true`, setzt die Funktion `linsolve` für ein unterbestimmtes Gleichungssystem freie Parameter in die Lösungen ein, die mit `%r`-Symbolen bezeichnet werden. Siehe auch `%rnum` und `%rnum_list`.

Systemvariable: multiplicities

  Standardwert: `not_set_yet`

  `multiplicities` ist die Liste der Vielfachheiten der Lösungen, die von `solve`, `realroots` oder `allroots` zurückgegeben werden.

  Beispiel:

      (%i1) solve(x^2*(x+1)^2, x);
      (%o1)                   [x = - 1, x = 0]
      (%i2) multiplicities;
      (%o2)                        [2, 2]

Funktion: nroots (p, low, high)

  Gibt die Anzahl der reellen Wurzeln des reellen univariaten Polynoms p im halboffenen Intervall `(low, high]` zurück. Die Grenzen des Intervalls können auch negativ unendlich `minf` oder positiv unendlich `inf` sein.

  `nroots` verwendet die Methode der Sturm-Sequenzen.

  Beispiel:

      (%i1) p: x^10 - 2*x^4 + 1/2$
      (%i2) nroots (p, -6, 9.1);
      (%o2)                           4

Funktion: nthroot (p, n)

  Das Argument p ist ein Polynom mit ganzzahligen Koeffizienten und das Argument n eine positive ganze Zahl. `nthroot` gibt ein Polynom q über die ganzen Zahlen zurück, so dass q^n = p gilt. Existiert kein derartiges Polynom q gibt Maxima eine Fehlermeldung aus. `nthroot` ist wesentlich schneller als die Funktionen `factor` oder `sqfr`.

Optionsvariable: polyfactor

  Standardwert: `false`

  Hat die Optionsvariable `polyfactor` den Wert `true`, werden die Lösungen der Funktionen `allroots` und `bfallroots` über die reellen Zahlen faktorisiert, wenn das Polynom reell ist, und über die komplexen Zahlen, wenn das Polynome komplex ist.

  Siehe `allroots` für ein Beispiel.

Optionsvariable: programmode

  Standardwert: `true`

  Hat `programmode` den Wert `true`, geben die Funktionen `solve`, `realroots`, `allroots`, `bfallroots` und `linsolve` die Lösungen als Elemente einer Liste zurück.

  Hat `programmode` den Wert `false`, werden die Lösungen der oben genannten Funktionen Zwischenmarken `%t` zugewiesen. Die Rückgabe der Funktionen ist in diesem Fall eine Liste der Zwischenmarken.

Optionsvariable: realonly

  Standardwert: `false`

  Hat `realonly` den Wert `true`, gibt `algsys` nur Lösungen zurück, die nicht die imaginäre Einheit `%i` enthalten.

Funktion: realroots (expr, bound)
Funktion: realroots (eqn, bound)
Funktion: realroots (expr)
Funktion: realroots (eqn)

  Computes rational approximations of the real roots of the polynomial expr or polynomial equation eqn of one variable, to within a tolerance of bound. Coefficients of expr or eqn must be literal numbers; symbol constants such as `%pi` are rejected.

  `realroots` assigns the multiplicities of the roots it finds to the global variable `multiplicities`.

  `realroots` constructs a Sturm sequence to bracket each root, and then applies bisection to refine the approximations. All coefficients are converted to rational equivalents before searching for roots, and computations are carried out by exact rational arithmetic. Even if some coefficients are floating-point numbers, the results are rational (unless coerced to floats by the `float` or `numer` flags).

  When bound is less than 1, all integer roots are found exactly. When bound is unspecified, it is assumed equal to the global variable `rootsepsilon`.

  When the global variable `programmode` is `true`, `realroots` returns a list of the form `[x = x_1, x = x_2, ...]`. When `programmode` is `false`, `realroots` creates intermediate expression labels `%t1`, `%t2`, ..., assigns the results to them, and returns the list of labels.

  Examples:

      (%i1) realroots (-1 - x + x^5, 5e-6);
                                     612003
      (%o1)                     [x = ------]
                                     524288
      (%i2) ev (%[1], float);
      (%o2)                 x = 1.167303085327148
      (%i3) ev (-1 - x + x^5, %);
      (%o3)                - 7.396496210176905E-6

      (%i1) realroots (expand ((1 - x)^5 * (2 - x)^3 * (3 - x)), 1e-20);
      (%o1)                 [x = 1, x = 2, x = 3]
      (%i2) multiplicities;
      (%o2)                       [5, 3, 1]

Funktion: rhs (expr)

  Gibt die rechte Seite des Ausdrucks expr zurück, wenn der Operator von expr einer der relationalen Operatoren `< <= = # equal notequal >= >`, einer der Zuweisungsoperatoren `:= ::= : ::` oder ein nutzerdefinierter binärer Infixoperator ist, der mit der Funktion `infix` deklariert wurde. Die rechte Seite des Ausdrucks ist für die hier genannten Operatoren das zweite Argument.

  Ist expr ein Atom oder hat der Ausdruck expr einen anderen Operator als oben angegeben, dann ist das Ergebnis `0`. Siehe auch `lhs`.

  Beispiele:

      (%i1) e: aa + bb = cc;
      (%o1)                     bb + aa = cc
      (%i2) lhs (e);
      (%o2)                        bb + aa
      (%i3) rhs (e);
      (%o3)                          cc
      (%i4) [rhs (aa < bb), rhs (aa <= bb), rhs (aa >= bb),
             rhs (aa > bb)];
      (%o4)                   [bb, bb, bb, bb]
      (%i5) [rhs (aa = bb), rhs (aa # bb), rhs (equal (aa, bb)),
             rhs (notequal (aa, bb))];
      (%o5)                   [bb, bb, bb, bb]
      (%i6) e1: '(foo(x) := 2*x);
      (%o6)                     foo(x) := 2 x
      (%i7) e2: '(bar(y) ::= 3*y);
      (%o7)                    bar(y) ::= 3 y
      (%i8) e3: '(x : y);
      (%o8)                         x : y
      (%i9) e4: '(x :: y);
      (%o9)                        x :: y
      (%i10) [rhs (e1), rhs (e2), rhs (e3), rhs (e4)];
      (%o10)                  [2 x, 3 y, y, y]
      (%i11) infix ("][");
      (%o11)                         ][
      (%i12) rhs (aa ][ bb);
      (%o12)                         bb

Optionsvariable: rootsepsilon

  Standardwert: `1.0e-7`

  `rootsepsilon` ist die Toleranz, die den Vertrauensbereich für die von der Funktion `realroots` gefundenen Wurzeln festsetzt.

Funktion: solve (expr, x)
Funktion: solve (expr)
Funktion: solve ([eqn_1, …, eqn_n], [x_1, …, x_n])

  Löst eine algebraische Gleichung expr nach der Variablen x auf. Wenn expr keine Gleichung ist, wird die Gleichung `expr = 0` angenommen. x kann eine Funktion wie zum Beispiel `f(x)`) sein oder ein allgemeiner Ausdruck. Ausgenommen sind Summen und Produkte. Hat die Gleichung nur eine Variable, braucht diese nicht angegeben zu werden. expr kann ein rationaler Ausdruck sein und trigonometrische Funktionen, Exponentialfunktionen und andere Funktionen enthalten. Zur Lösung wird die folgende Methode verwendet:

  1. Sei E ein Ausdruck und X die Variable. Ist E linear in X, dann kann die Gleichung sofort nach der Variablen `X` aufgelöst werden. Hat E die Form `A*X^N + B`, dann ist das Ergebnis `(-B/A)^1/N)` multipliziert mit der `N`-ten Einheitswurzel.
  2. Ist E nicht linear in X, wird der größte gemeinsame Teiler N der Exponenten der Variable X bestimmt. Die Exponenten der Variablen werden durch N dividiert und die Multiplizität der Lösungen mit N multipliziert. `solve` wird erneut für den Ausdruck aufgerufen. Kann E faktorisiert werden, wird `solve` für jeden Faktor aufgerufen. Zuletzt prüft `solve`, ob einer der Algorithmen für quadratische, kubische oder quartische Gleichungen angewendet werden kann.
  3. Ist E ein Polynom in einer Funktion `F(X)` mit X als der Variablen, wird zunächst die Lösung des Polynoms für `F(X)` gesucht. Ist C eine solche Lösung, kann die Gleichung `F(X)=C` gelöst werden, wenn die Umkehrfunktion zu `F(X)` bekannt ist.

  Hat die Optionsvariable `breakup` den Wert `false`, werden die Lösungen von kubischen und quartischen Gleichungen nicht in gemeinsame Teilausdrücke zerlegt.

  Die Systemvariable `multiplicities` enthält eine Liste mit den Vielfachheiten der einzelnen Lösungen.

  `solve ([eqn_1, ..., eqn_n], [x_1, ..., x_n])` löst ein Gleichungssystem mit den Polynomen eqn_1, …, eqn_n für die Variablen x_1, …, x_n. Die Polynome können linear oder nichtlinear sein. Um das System zu lösen, werden die Funktionen `linsolve` oder `algsys` aufgerufen. Das Ergebnis ist eine Liste mit den Lösungen. Ist die Anzahl der Gleichungen gleich der Anzahl der Variablen des Systems, kann das Argument mit der Liste der Variablen entfallen.

  Hat die Optionsvariable `programmode` den Wert `false` ist, zeigt `solve` die Lösungen mit Hilfe von Zwischenmarken (`%t`) an und gibt die Liste der Marken zurück.

  Hat die Optionsvariable `globalsolve` den Wert `true`, werden den unbekannten Variablen eines linearen Gleichungssystems die Werte der Lösung der Funktionen `linsolve` und `solve` zugewiesen.

  Beispiele:

      (%i1) solve (asin (cos (3*x))*(f(x) - 1), x);

      SOLVE is using arc-trig functions to get a solution.
      Some solutions will be lost.
                                  %pi
      (%o1)                  [x = ---, f(x) = 1]
                                   6
      (%i2) ev (solve (5^f(x) = 125, f(x)), solveradcan);
                                      log(125)
      (%o2)                   [f(x) = --------]
                                       log(5)
      (%i3) [4*x^2 - y^2 = 12, x*y - x = 2];
                            2    2
      (%o3)             [4 x  - y  = 12, x y - x = 2]
      (%i4) solve (%, [x, y]);
      (%o4) [[x = 2, y = 2], [x = .5202594388652008 %i

       - .1331240357358706, y = .0767837852378778

       - 3.608003221870287 %i], [x = - .5202594388652008 %i

       - .1331240357358706, y = 3.608003221870287 %i

       + .0767837852378778], [x = - 1.733751846381093,

      y = - .1535675710019696]]
      (%i5) solve (1 + a*x + x^3, x);
                                             3
                    sqrt(3) %i   1   sqrt(4 a  + 27)   1 1/3
      (%o5) [x = (- ---------- - -) (--------------- - -)
                        2        2      6 sqrt(3)      2

              sqrt(3) %i   1
             (---------- - -) a
                  2        2
       - --------------------------, x =
                    3
            sqrt(4 a  + 27)   1 1/3
         3 (--------------- - -)
               6 sqrt(3)      2

                                3
       sqrt(3) %i   1   sqrt(4 a  + 27)   1 1/3
      (---------- - -) (--------------- - -)
           2        2      6 sqrt(3)      2

               sqrt(3) %i   1
            (- ---------- - -) a
                   2        2
       - --------------------------, x =
                    3
            sqrt(4 a  + 27)   1 1/3
         3 (--------------- - -)
               6 sqrt(3)      2
               3
       sqrt(4 a  + 27)   1 1/3               a
      (--------------- - -)    - --------------------------]
          6 sqrt(3)      2                  3
                                    sqrt(4 a  + 27)   1 1/3
                                 3 (--------------- - -)
                                       6 sqrt(3)      2
      (%i6) solve (x^3 - 1);
                   sqrt(3) %i - 1        sqrt(3) %i + 1
      (%o6)   [x = --------------, x = - --------------, x = 1]
                         2                     2
      (%i7) solve (x^6 - 1);
                 sqrt(3) %i + 1      sqrt(3) %i - 1
      (%o7) [x = --------------, x = --------------, x = - 1,
                       2                   2

                           sqrt(3) %i + 1        sqrt(3) %i - 1
                     x = - --------------, x = - --------------, x = 1]
                                 2                     2
      (%i8) ev (x^6 - 1, %[1]);
                                            6
                            (sqrt(3) %i + 1)
      (%o8)                 ----------------- - 1
                                   64
      (%i9) expand (%);
      (%o9)                           0
      (%i10) x^2 - 1;
                                    2
      (%o10)                       x  - 1
      (%i11) solve (%, x);
      (%o11)                  [x = - 1, x = 1]
      (%i12) ev (%th(2), %[1]);
      (%o12)                          0

  Die Symbole `%r` bezeichnen freie Konstanten einer Lösung. Siehe `algsys` und `%rnum_list` für mehr Informationen.

      (%i1) solve([x+y=1,2*x+2*y=2],[x,y]);

      solve: dependent equations eliminated: (2)
      (%o1)                      [[x = 1 - %r1, y = %r1]]

Optionsvariable: solvedecomposes

  Standardwert: `true`

  Hat `solvedecomposes` den Wert `true`, ruft `solve` die Funktion `polydecomp` auf, um Polynome zu zerlegen.

Optionsvariable: solveexplicit

  Standardwert: `false`

  Hat `solveexplicit` den Wert `true`, gibt die Funktion `solve` keine impliziten Lösungen der Form `F(x) = 0` zurück.

  Beispiel:

      (%i1) solveexplicit:false;
      (%o1)                         false
      (%i2) solve(gamma(x)*x^3-1);
                                 3      1
      (%o2)                    [x  = --------]
                                     gamma(x)
      (%i3) solveexplicit:true;
      (%o3)                         true
      (%i4) solve(gamma(x)*x^3-1);
      (%o4)                          []

Optionsvariable: solvefactors

  Standardwert: `true`

  Hat `solvefactors` den Wert `false`, versucht die Funktion `solve` nicht, den Ausdruck zu faktorisieren. Das Setzen der Optionsvariable `solvefactors` auf den Wert `false` kann notwendig sein, wenn die Faktorisierung nicht benötigt wird, damit `solve` eine Lösung findet.

Optionsvariable: solvenullwarn

  Standardwert: `true`

  Hat `solvenullwarn` den Wert `true`, gibt die Funktion `solve` eine Warnmeldung aus, wenn keine Gleichungen oder keine Variablen als Argument übergeben wurden.

  Beispiel:

      (%i1) solvenullwarn:true;
      (%o1)                         true
      (%i2) solve(x^2*y+1,[]);

      solve: variable list is empty, continuing anyway.
      (%o2)                          []
      (%i3) solvenullwarn:false;
      (%o3)                         false
      (%i4) solve(x^2*y+1,[]);
      (%o4)                          []

Optionsvariable: solveradcan

  Standardwert: `false`

  Hat `solveradcan` den Wert `true`, ruft `solve` die Funktion `radcan` auf, um Ausdrücke zu vereinfachen, die Exponentialfunktionen und Logarithmen enthalten.

Optionsvariable: solvetrigwarn

  Standardwert: `true`

  Hat `solvetrigwarn` den Wert `true`, gibt die Funktion `solve` eine Warnung aus, wenn inverse trigonometrische Funktionen genutzt werden, um Lösungen zu finden. In diesem Fall können Lösungen verloren gehen.

  Beispiel:

      (%i1) solvetrigwarn:true;
      (%o1)                         true
      (%i2) solve(cos(x)+1);

      solve: using arc-trig functions to get a solution.
      Some solutions will be lost.
      (%o2)                       [x = %pi]
      (%i3) solvetrigwarn:false;
      (%o3)                         false
      (%i4) solve(cos(x)+1);
      (%o4)                       [x = %pi]

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by Robert Dodier on Dezember, 29 2019 using texi2html 1.76.