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