Sage kann viele zur elementaren Algebra und Analysis gehörende Probleme lösen. Zum Beispiel: Lösungen von Gleichungen finden, Differentiation, Integration, und Laplace-Transformationen berechnen. Lesen Sie die Sage Constructions Dokumentation um weitere Beispiele zu finden.
Die solve Funktion löst Gleichungen. Legen Sie zunächst Variablen an, bevor Sie diese benutzen; Die Argumente von solve sind eine Gleichung (oder ein System von Gleichungen) zusammen mit den Variablen, nach welchen Sie auflösen möchten:
sage: x = var('x')
sage: solve(x^2 + 3*x + 2, x)
[x == -2, x == -1]
Sie können eine Gleichung nach einer Variablen, in Abhängigkeit von den anderen, auflösen:
sage: x, b, c = var('x b c')
sage: solve([x^2 + b*x + c == 0],x)
[x == -1/2*b - 1/2*sqrt(b^2 - 4*c), x == -1/2*b + 1/2*sqrt(b^2 - 4*c)]
Sie können auch nach mehreren Variablen auflösen:
sage: x, y = var('x, y')
sage: solve([x+y==6, x-y==4], x, y)
[[x == 5, y == 1]]
Das folgende Beispiel, in dem Sage benutzt wird um ein System von nichtlinearen Gleichungen zu lösen, stammt von Jason Grout. Zunächst lösen wir das System symbolisch:
sage: var('x y p q')
(x, y, p, q)
sage: eq1 = p+q==9
sage: eq2 = q*y+p*x==-6
sage: eq3 = q*y^2+p*x^2==24
sage: solve([eq1,eq2,eq3,p==1],p,q,x,y)
[[p == 1, q == 8, x == -4/3*sqrt(10) - 2/3, y == 1/6*sqrt(5)*sqrt(2) - 2/3],
[p == 1, q == 8, x == 4/3*sqrt(10) - 2/3, y == -1/6*sqrt(5)*sqrt(2) - 2/3]]
Um eine numerische Approximation der Lösungen zu erhalten können Sie stattdessen wie folgt vorgehen:
sage: solns = solve([eq1,eq2,eq3,p==1],p,q,x,y, solution_dict=True)
sage: [[s[p].n(30), s[q].n(30), s[x].n(30), s[y].n(30)] for s in solns]
[[1.0000000, 8.0000000, -4.8830369, -0.13962039],
[1.0000000, 8.0000000, 3.5497035, -1.1937129]]
(Die Funktion n gibt eine numerische Approximation zurück, ihr Argument ist die Anzahl der Bits an Genauigkeit.)
Oftmals kann solve keine exakte Lösung der angegebenen Gleichung bzw. Gleichungen finden. Wenn dies passiert können Sie find_root verwenden um eine numerische Approximation zu finden. Beispielsweise gibt solve bei folgender Gleichung nichts brauchbares zurück:
sage: theta = var('theta')
sage: solve(cos(theta)==sin(theta), theta)
[sin(theta) == cos(theta)]
Wir können jedoch find_root verwenden um eine Lösung der obigen
Gleichung im Bereich zu finden:
sage: phi = var('phi')
sage: find_root(cos(phi)==sin(phi),0,pi/2)
0.785398163397448...
Sage weiß wie man viele Funktionen differenziert und integriert. Zum
Beispiel können Sie folgendes eingeben um nach
abzuleiten:
sage: u = var('u')
sage: diff(sin(u), u)
cos(u)
Um die vierte Ableitung zu berechnen:
sage: diff(sin(x^2), x, 4)
16*x^4*sin(x^2) - 48*x^2*cos(x^2) - 12*sin(x^2)
Um die partiellen Ableitungen von nach
beziehungsweise
zu berechnen:
sage: x, y = var('x,y')
sage: f = x^2 + 17*y^2
sage: f.diff(x)
2*x
sage: f.diff(y)
34*y
Wir machen weiter mit Integralen, sowohl bestimmt als auch
unbestimmt. Die Berechnung von und
:
sage: integral(x*sin(x^2), x)
-1/2*cos(x^2)
sage: integral(x/(x^2+1), x, 0, 1)
1/2*log(2)
Die Partialbruchzerlegung von :
sage: f = 1/((1+x)*(x-1))
sage: f.partial_fraction(x)
-1/2/(x + 1) + 1/2/(x - 1)
Sie können Sage verwenden um gewöhnliche Differentialgleichungen zu
berechnen. Die Gleichung berechnen Sie wie folgt:
sage: t = var('t') # definiere die Variable t
sage: x = function('x',t) # definiere x als Funktion dieser Variablen
sage: DE = diff(x, t) + x - 1
sage: desolve(DE, [x,t])
(_C + e^t)*e^(-t)
Dies benutzt Sages Schnittstelle zu Maxima [Max], daher kann sich die
Ausgabe ein wenig von anderen Ausgaben in Sage unterscheiden. In
diesem Fall wird mitgeteilt, dass
die allgemeine Lösung der Differentialgleichung ist.
Sie können auch Laplace-Transformationen berechnen:
Die Laplace-Transformation von wird wie folgt
berechnet:
sage: s = var("s")
sage: t = var("t")
sage: f = t^2*exp(t) - sin(t)
sage: f.laplace(t,s)
-1/(s^2 + 1) + 2/(s - 1)^3
Hier ist ein komplizierteres Beispiel. Die Verschiebung des Gleichgewichts einer verkoppelten Feder, die an der linken Wand befestigt ist,
|------\/\/\/\/\---|Masse1|----\/\/\/\/\/----|Masse2|
Feder1 Feder2
wird durch dieses System der Differentialgleichungen zweiter Ordnung modelliert,
wobei die Masse des Objekts i,
die
Verschiebung des Gleichgewichts der Masse i und
die
Federkonstante der Feder i ist.
Beispiel: Benutzen Sie Sage um das obige Problem mit folgenden
Werten zu lösen:
,
,
,
,
,
,
,
.
Lösung: Berechnen Sie die Laplace-Transformierte der ersten Gleichung
(mit der Notation ,
):
sage: de1 = maxima("2*diff(x(t),t, 2) + 6*x(t) - 2*y(t)")
sage: lde1 = de1.laplace("t","s"); lde1
2*(-?%at('diff(x(t),t,1),t=0)+s^2*'laplace(x(t),t,s)-x(0)*s)-2*'laplace(y(t),t,s)+6*'laplace(x(t),t,s)
Das ist schwierig zu lesen, es besagt jedoch, dass
(wobei die Laplace-Transformierte der Funktion mit kleinem
Anfangsbuchstaben die Funktion mit großem
Anfangsbuchstaben
ist). Berechnen Sie die
Laplace-Transformierte der zweiten Gleichung:
sage: de2 = maxima("diff(y(t),t, 2) + 2*y(t) - 2*x(t)")
sage: lde2 = de2.laplace("t","s"); lde2
-?%at('diff(y(t),t,1),t=0)+s^2*'laplace(y(t),t,s)+2*'laplace(y(t),t,s)-2*'laplace(x(t),t,s)-y(0)*s
Dies besagt
Setzen Sie die Anfangsbedingungen für ,
,
und
ein, und lösen die beiden Gleichungen,
die Sie so erhalten:
sage: var('s X Y')
(s, X, Y)
sage: eqns = [(2*s^2+6)*X-2*Y == 6*s, -2*X +(s^2+2)*Y == 3*s]
sage: solve(eqns, X,Y)
[[X == 3*(s^3 + 3*s)/(s^4 + 5*s^2 + 4),
Y == 3*(s^3 + 5*s)/(s^4 + 5*s^2 + 4)]]
Berechnen Sie jetzt die inverse Laplace-Transformierte um die Antwort zu erhalten:
sage: var('s t')
(s, t)
sage: inverse_laplace((3*s^3 + 9*s)/(s^4 + 5*s^2 + 4),s,t)
cos(2*t) + 2*cos(t)
sage: inverse_laplace((3*s^3 + 15*s)/(s^4 + 5*s^2 + 4),s,t)
-cos(2*t) + 4*cos(t)
Also ist die Lösung:
Die kann folgenderweise parametrisiert geplottet werden:
sage: t = var('t')
sage: P = parametric_plot((cos(2*t) + 2*cos(t), 4*cos(t) - cos(2*t) ),\
... (t, 0, 2*pi), rgbcolor=hue(0.9))
sage: show(P)
Die einzelnen Komponenten können so geplottet werden:
sage: t = var('t')
sage: p1 = plot(cos(2*t) + 2*cos(t), (t,0, 2*pi), rgbcolor=hue(0.3))
sage: p2 = plot(4*cos(t) - cos(2*t), (t,0, 2*pi), rgbcolor=hue(0.6))
sage: show(p1 + p2)
Um mehr über das Plotten zu erfahren lesen Sie Plotten. Lesen Sie Abschnitt 5.5 von [NagleEtAl2004] um weitere Informationen über Differentialgleichungen zu erhalten.
Im nächsten Beispiel illustrieren wir das Euler-Verfahren für ODEs erster und zweiter Ordnung. Wir rufen zunächst die grundlegende Idee für Differentialgleichungen erster Ordnung in Erinnerung. Sei ein Anfangswertproblem der Form
gegeben. Wir möchten eine Approximation des Wertes der Lösung bei
mit
finden.
Machen Sie sich anhand der Definition der Ableitung klar, dass
wobei vorgegeben und klein ist. Zusammen mit der
Differentialgleichung gibt dies
. Jetzt lösen wir nach
auf:
Wenn wir den “Korrekturterm”,
den “alten Wert von
” und
den “neuen Wert von
”
nennen, kann diese Approximation neu ausgedrückt werden als:
Wenn wir das Intervall von bis
in
Teilintervalle
aufteilen, so dass
gilt, können wir die
Information in folgender Tabelle festhalten.
![]() |
![]() |
![]() |
---|---|---|
![]() |
![]() |
![]() |
![]() |
![]() |
... |
![]() |
... | |
... | ||
![]() |
??? | ... |
Unser Ziel ist zeilenweise alle leeren Einträge der Tabelle
auszufüllen, bis wir den Eintrag ??? erreichen, welcher die
Approximation des Euler-Verfahrens für ist.
Die Idee für Systeme von ODEs ist ähnlich.
Wir müssen die ODE zweiter Ordnung auf ein System von zwei
Differentialgleichungen erster Ordnung reduzieren (wobei ,
) und das Euler-Verfahren anwenden:
sage: t,x,y = PolynomialRing(RealField(10),3,"txy").gens()
sage: f = y; g = -x - y * t
sage: eulers_method_2x2(f,g, 0, 1, 0, 1/4, 1)
t x h*f(t,x,y) y h*g(t,x,y)
0 1 0.00 0 -0.25
1/4 1.0 -0.062 -0.25 -0.23
1/2 0.94 -0.12 -0.48 -0.17
3/4 0.82 -0.16 -0.66 -0.081
1 0.65 -0.18 -0.74 0.022
Also ist .
Wir können auch die Punkte plotten um ein ungefähres
Bild der Kurve zu erhalten. Die Funktion eulers_method_2x2_plot
macht dies; um sie zu benutzen, müssen wir die Funktionen
und
definieren, welche ein Argument mit drei Koordinaten (
,
,
)
erwarten.
sage: f = lambda z: z[2] # f(t,x,y) = y
sage: g = lambda z: -sin(z[1]) # g(t,x,y) = -sin(x)
sage: P = eulers_method_2x2_plot(f,g, 0.0, 0.75, 0.0, 0.1, 1.0)
Zu diesem Zeitpunkt enthält P die beiden Plots P[0] (der Plot
von nach
) und P[1] (der Plot von
nach
). Wir können
beide wie folgt anzeigen:
sage: show(P[0] + P[1])
(Um mehr über das Plotten zu erfahren, lesen Sie Plotten.)
Mehrere orthogonale Polynome und spezielle Funktionen sind implementiert, wobei sowohl PARI [GP] als auch Maxima [Max] verwendet wird. Sie sind in den dazugehörigen Abschnitten (“Orthogonal polynomials” beziehungsweise “Special functions”) des Sage Referenzhandbuchs dokumentiert.
sage: x = polygen(QQ, 'x')
sage: chebyshev_U(2,x)
4*x^2 - 1
sage: bessel_I(1,1).n(250)
0.56515910399248502720769602760986330732889962162109200948029448947925564096
sage: bessel_I(1,1).n()
0.565159103992485
sage: bessel_I(2,1.1).n()
0.167089499251049
Zum jetzigen Zeitpunkt, enthält Sage nur Wrapper-Funktionen für numerische Berechnungen. Um symbolisch zu rechen, rufen Sie die Maxima-Schnittstelle bitte, wie im folgenden Beispiel, direkt auf
sage: maxima.eval("f:bessel_y(v, w)")
'bessel_y(v,w)'
sage: maxima.eval("diff(f,w)")
'(bessel_y(v-1,w)-bessel_y(v+1,w))/2'