| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 18.1 Funktionen und Variablen für Gleichungen |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
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
Standardwert: false
algexact kontrolliert die Funktion algsys folgendermaßen:
algexact den Wert true, wird von der Funktion algsys
stets solve aufgerufen. Findet solve keine Lösung, wird die
Funktion realroots aufgerufen.
algexact den Wert false, wird die Funktion solve für
Gleichungen aufgerufen, die von mehr als einer Variablen abhängen oder 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 die Funktion Näherungslösungen zu finden.
Standardwert: 10^8
Kontrolliert die Genauigkeit einer numerischen Lösung der Funktion
algsys.
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:
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.
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
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)
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.
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]
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]
dimen ist ein Paket für die Dimensionsanalysis. load(dimen)
lädt dieses Paket. demo(dimen) zeigt eine kleine Demonstration.
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.
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.
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
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.
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).
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
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]
Standardwert: true
Hat linsolvewarn den Wert true, gibt linsolve
gegebenenfalls die Meldung "Dependent equations eliminated" aus.
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.
Standardwert: not_set_yet
multiplicities ist die Liste der Vielfachheiten der
Lösungen, die von solve, realroots oder allroots
zurückgegeben werden.
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
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.
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.
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.
Standardwert: false
Hat realonly den Wert true, gibt algsys nur Lösungen
zurück, die nicht die imaginäre Einheit %i enthalten.
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]
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
Standardwert: 1.0e-7
rootsepsilon ist die Toleranz, die den Vertrauensbereich für die von
der Funktion realroots gefundenen Wurzeln festsetzt.
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.
Standardwert: true
Hat solvedecomposes den Wert true, ruft solve die Funktion
polydecomp auf, um Polynome zu lösen.
Standardwert: false
Hat solveexplicit den Wert true, gibt solve keine
impliziten Lösungen der Form F(x) = 0 zurück.
Standardwert: true
Hat solvefactors den Wert false, versucht solve nicht, den
Ausdruck zu faktorisieren.
Standardwert: true
Hat solvenullwarn den Wert true, gibt solve eine
Warnmeldung aus, wenn keine Gleichungen oder keine Variablen als Argument
übergeben wurden.
Standardwert: false
Hat solveradcan den Wert true, ruft solve die Funktion
radcan auf, um Ausdrücke zu vereinfachen.
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.