Vorige: Gleichungen, Nach oben: Gleichungen [Inhalt][Index]
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.
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
Standardwert: false
Die Optionsvariable 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
nur
für Gleichungen aufgerufen, die von mehr als einer Variablen abhängen und
für quadratische oder kubische Gleichungen.
Der Wert true
für algexact
garantiert nicht, dass algsys
nur exakte Lösungen findet. Findet algsys
keine exakten
Lösungen, versucht solve
immer Näherungslösungen zu finden.
Beispiele:
(%i1) algexact:true$ (%i2) algsys([x^5-1],[x]); sqrt(5) 5 sqrt(- ------- - -) sqrt(5) 2 2 1 (%o2) [[x = 1], [x = ------- + ------------------- - -], 4 2 4 sqrt(5) 5 sqrt(- ------- - -) sqrt(5) 2 2 1 [x = ------- - ------------------- - -], 4 2 4 sqrt(5) 5 sqrt(------- - -) sqrt(5) 2 2 1 [x = - ------- + ----------------- - -], 4 2 4 sqrt(5) 5 sqrt(------- - -) sqrt(5) 2 2 1 [x = - ------- - ----------------- - -]] 4 2 4 (%i3) algexact:false$ (%i4) algsys([x^5-1],[x]); (%o4) [[x = 1], [x = - .5877852522924731 %i - .8090169943749475], [x = .5877852522924731 %i - .8090169943749475], [x = .3090169943749475 - .9510565162951535 %i], [x = .9510565162951535 %i + .3090169943749475]]
Auch wenn die Optionsvariable algexact
den Wert true
hat, gibt
algsys
numerische Näherungslösungen zurück, wenn solve
keine Lösungen finden kann.
(%i5) algexact:true$ (%i6) algsys([x^5-x^3+1],[x]); (%o6) [[x = - 1.236505681818182], [x = - 0.785423103049449 %i - .3407948661970064], [x = 0.785423103049449 %i - .3407948661970064], [x = .9590477178927559 - .4283659562541893 %i], [x = .4283659562541893 %i + .9590477178927559]] (%i7) solve([x^5-x^3+1],[x]); 5 3 (%o7) [0 = x - x + 1]
Für eine quadratische Gleichung wird immer eine exakte Lösung zurückgeben.
(%i8) algsys:true$ (%i9) algsys([x^2+x-1],[x]); sqrt(5) - 1 sqrt(5) + 1 (%o9) [[x = -----------], [x = - -----------]] 2 2 (%i11) algsys:false$ (%i12) algsys([x^2+x-1],[x]); sqrt(5) - 1 sqrt(5) + 1 (%o12) [[x = -----------], [x = - -----------]] 2 2
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]]
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:
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.
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
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)
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]
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]
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]
dimen
ist ein Paket für die Dimensionsanalyse. 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.
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)
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
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.
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.
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
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]
Standardwert: true
Hat linsolvewarn
den Wert true
, gibt die Funktion
linsolve
gegebenenfalls die Meldung Dependent equations eliminated
aus.
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
.
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]
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
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
.
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.
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 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
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 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:
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.
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.
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]]
Standardwert: true
Hat solvedecomposes
den Wert true
, ruft solve
die Funktion
polydecomp
auf, um Polynome zu zerlegen.
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) []
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.
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) []
Standardwert: false
Hat solveradcan
den Wert true
, ruft solve
die Funktion
radcan
auf, um Ausdrücke zu vereinfachen, die Exponentialfunktionen
und Logarithmen enthalten.
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]
Vorige: Gleichungen, Nach oben: Gleichungen [Inhalt][Index]