[ < ] [ > ]   [ << ] [ 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 Parameter, die in die Lösungen eingesetzt werden. Die Parameter haben den Namen %r<num>. %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 Parameter, die von solve und algsys in Lösungen eingesetzt werden. Die Parameter werden der Liste %rnum_list hinzugefügt, in der Reihenfolge in der sie erzeugt werden.

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

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 die Funktion Näherungslösungen zu finden.

Optionsvariable: algepsilon

Standardwert: 10^8

Kontrolliert die Genauigkeit einer numerischen Lösung der Funktion algsys.

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

Löst ein Gleichungsystem 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 x_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. 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 Parameter werden der Liste %rnum_list hinzugefügt. Siehe %rnum_list.

Die Funktion algsys verwendet die folgenden Schritte, um Lösungen eines Gleichungsystems zu finden:

  1. Die Gleichungen werden faktorisiert und in Teilsysteme aufgeteilt.
  2. Für jedes Teilsystem S_i werden eine Gleichung E und eine Variable x ausgewählt, die den niedrigsten von Null verschiedenen Grad hat. 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 nun 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 die Funktion realroots aufgerufen, wenn der Schalter realonly den Wert true hat. Ansonsten wird die Funktion allroots aufgerufen. Die Funktion realroots sucht reelle Lösung der Gleichung, während die Funktion allroots auch komplex Lösungen sucht.

    Die Genauigkeit einer numerischen Lösung wird 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. 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 reval nützlich 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 Variable.

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 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. Hat die Optionsvariable polyfactor den Wert true, wird ein äquivalenter, faktorisierter Ausdruck zurückgegeben, der die Näherungen für die Nullstellen enthält.

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 mit einer Variable.

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

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.

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

Haben die Optionsvariablen programmode und breakup den Wert true, werden Zwischenmarken für gemeinsame Terme in Lösungen von kubischen und quartischen Gleichungen 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 Dimensionsanalysis. 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, die erzeugt werden, wenn die Optionsvariable programmmode den Wert false hat.

Funktion: funcsolve (eqn, g(t))

Das Argument ist eine Gleichung eqn, 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.

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

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

Optionsvariable: globalsolve

Standardwert: false

Hat globalsolve den Wert true, werden den unbekannten Variablen eines linearen Gleichungssystems die Werte der Lösung 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. 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 der Form p(x) = q( x, p(x), 'integrate(w(x,u,p(x),p(u)),u,a(x),b(x)) ) (zweiter Art, secondkind) und 'integrate(w(x,u,p(u)),u,a(x),b(x)) = f(x) (erster Art, firstkind). load ("inteqn") lädt dieses Paket.

ie ist die Integralgleichung; unk ist die unbekannte Funktion einschließlich angegebener Abhängigkeit; tech ist die Technik, die zur Lösung angewendet werden soll (tech = first bedeutet, dass die verfügbaren Lösungstechniken der Reihe nach angewandt werden und das Ergebnis der ersten erfolgreichen Lösung wird zurückgegeben; tech = all bedeutet, dass alle Techniken angewandt werden); n ist die maximale Anzahl an Termen, die für taylor, neumann, firstkindseries oder fredseries verwendet werden (es ist ebenso die maximale Tiefe der Rekursion für die Differentiationsmethode); guess ist der Startwert für neumann oder firstkindseries.

Standardwerte für den 2ten bis 5ten Parameter sind:

unk: p(x), wobei p die als erste im Integranden aufgefundene Funktion ist, die für Maxima unbekannt ist, und x ist die Variable, die im Falle einer secondkind-Gleichung als Argument des ersten p außerhalb des Integrals vorgefunden wird, oder im Falle einer firstkind-Gleichung die einzige andere Variable neben der Integrationsvariable. Wenn der Versuch, x zu finden, fehlschlägt, wird der Nutzer gefragt, eine unabhängige Variable anzugeben.

tech: first

n: 1

guess: none, was bewirkt, dass neumann und firstkindseries f(x) als Startwert verwenden.

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

Optionsvariable: ieqnprint

Standardwert: true

ieqnprint regelt die Darstellung des Ergebnisses, das durch den Befehl ieqn zurückgegeben wird. Wenn ieqnprint true ist, ist die von der ieqn-Funktion zurückgegebene Liste von der Form

[solution, technique used, nterms, flag]

wobei flag nicht vorkommt, wenn die Lösung exakt ist.

Andernfalls ist approximate bzw. incomplete das Wort, das sich auf eine nicht exakte bzw. nicht geschlossene Form der Lösung bezieht. Wird eine Reihenmethode angewandt, gibt nterms die Anzahl der verwendeten Terme (die kleiner als das in ieqn angegebene n sein kann, wenn ein Fehler die Erzeugung weiterer Terme verhindert).

Funktion: lhs (expr)

Gibt die linke Seite, das ist das erste Argument, 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 deklariert durch infix deklariert wurde.

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 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 globalsolve den Wert true, werden die Lösungen des Gleichungssystems den angegebenen Variablen zugewiesen.

Hat 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 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 programmode den Wert false, gibt linsolve die Lösungen mit Hilfe von Zwischenmarken %t aus. Die Zwischenmarken werden als Liste zurückgegeben.

(%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 linsolve gegebenenfalls die Meldung "Dependent equations eliminated" aus.

Optionsvariable: linsolve_params

Standardwert: true

Hat 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.

Systemvariable: multiplicities

Standardwert: not_set_yet

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

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.

(%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 den ganzen Zahlen zurück, so dass q^n = p gilt. Existiert kein derartiges Polynom q gibt Maxima eine Fehlermeldung. Diese Funktion ist wesentlich schneller als 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, für reelle Polynome, und die komplexen Zahlen, für komplexe Polynome, faktorisiert.

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, das ist das zweite Argument, 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.

Wenn expr ein Atom ist oder sein Operator ein anderer als oben aufgelistet, hat rhs 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 Variable 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:

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) mal die N-te Einheitswurzel.

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.

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.

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

multiplicities ist 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 die Liste mit den Variablen entfallen.

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

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

Hat 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.

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

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

Siehe algsys and %rnum_list für mehr Informationen.

Optionsvariable: solvedecomposes

Standardwert: true

Hat solvedecomposes den Wert true, ruft solve die Funktion polydecomp auf, um Polynome zu lösen.

Optionsvariable: solveexplicit

Standardwert: false

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

Optionsvariable: solvefactors

Standardwert: true

Hat solvefactors den Wert false, versucht solve nicht, den Ausdruck zu faktorisieren.

Optionsvariable: solvenullwarn

Standardwert: true

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

Optionsvariable: solveradcan

Standardwert: false

Hat solveradcan den Wert true, ruft solve die Funktion radcan auf, um Ausdrücke zu vereinfachen.

Optionsvariable: solvetrigwarn

Standardwert: true

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


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

This document was generated by Robert Dodier on April, 4 2011 using texi2html 1.76.