[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
18.1 Funktionen und Variablen für Gleichungen |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Standardwert: 0
Wenn notwendig erzeugen die Funktionen solve
algsys
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
Standardwert: []
%rnum_list
ist die Liste der freien Parameter, die von solve
algsys
%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
Funktion realroots
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
realonly
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
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
Funktion realroots
.
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
Hat die Optionsvariable algexact
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
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
reveal
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
ü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
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
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
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
solve
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
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
.
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
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
Lösungen des Gleichungssystems den angegebenen Variablen zugewiesen.
Hat die Optionsvariable backsubst
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
linsolve
für ein unterbestimmtes Gleichungssystem freie Parameter in
die Lösungen ein, die mit %r
-Symbolen bezeichnet werden. Siehe auch
%rnum
%rnum_list
.
Hat die Optionsvariable programmode
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
aus.
Standardwert: true
Hat linsolve_params
den Wert true
, setzt die Funktion
linsolve
die Lösungen ein, die mit %r
-Symbolen bezeichnet werden. Siehe auch
%rnum
%rnum_list
.
Standardwert: not_set_yet
multiplicities
ist die Liste der Vielfachheiten der
Lösungen, die von solve
,
realroots
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
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
Standardwert: true
Hat programmode
den Wert true
, geben die Funktionen
solve
,
realroots
,
allroots
,
bfallroots
linsolve
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
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
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
Lösungen von kubischen und quartischen Gleichungen nicht in gemeinsame
Teilausdrücke zerlegt.
Die Systemvariable multiplicities
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
algsys
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
solve
die Lösungen mit Hilfe von Zwischenmarken (%t
) an und
gibt die Liste der Marken zurück.
Hat die Optionsvariable globalsolve
unbekannten Variablen eines linearen Gleichungssystems die Werte der Lösung
der Funktionen linsolve
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
%rnum_list
(%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
polydecomp
Standardwert: false
Hat solveexplicit
den Wert true
, gibt die Funktion
solve
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
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
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
radcan
und Logarithmen enthalten.
Standardwert: true
Hat solvetrigwarn
den Wert true
, gibt die Funktion
solve
werden, um Lösungen zu finden. In diesem Fall können Lösungen verloren
gehen.
Beispiel:
(%i1) solvetrigwarn:true; (%o1) true (%i2) solve(cos(x)+1); solve: using arc-trig functions to get a solution. Some solutions will be lost. (%o2) [x = %pi] (%i3) solvetrigwarn:false; (%o3) false (%i4) solve(cos(x)+1); (%o4) [x = %pi]
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Robert Dodier on Oktober, 11 2013 using texi2html 1.76.