[ < ] [ > ]   [ << ] [ 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:

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 Jaime Villate on Oktober, 14 2014 using texi2html 1.76.