Álgebra Y Cálculo Básicos¶
Sage puede efectuar cómputos relacionados al algebra y cálculo básicos: por ejemplo, encontrar soluciones de ecuaciones, diferenciación, integración y transformadas de Laplace. Véa la documentación «Construcciones En Sage» para más ejemplos.
Resolviendo Ecuaciones¶
Resolviendo Ecuaciones De Manera Exacta¶
La función solve resuelve ecuaciones. Para usarla, primero no olvides especificar
algunas variables. Los argumentos de solve son una ecuación (o un
sistema de ecuaciones), junto con las variables a resolver:
sage: x = var('x')
sage: solve(x^2 + 3*x + 2, x)
[x == -2, x == -1]
Puedes resolver ecuaciones en una variable respecto de las demás:
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)]
Puedes también resolver ecuaciones en varias variables:
sage: x, y = var('x, y')
sage: solve([x+y==6, x-y==4], x, y)
[[x == 5, y == 1]]
El siguiente ejemplo del uso de Sage para resolver un sistema de ecuaciones no-lineales fue proporcionado por Jason Grout: primero, resolvemos el sistema simbólicamente:
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(10) - 2/3], [p == 1, q == 8, x == 4/3*sqrt(10) - 2/3, y == -1/6*sqrt(10) - 2/3]]
Si queremos aproximaciones numéricas de las soluciones, podemos usar lo siguiente:
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]]
(La función n imprime una aproximación numérica, y el
argumento es el número de bits de precisión.)
Resolviendo Ecuaciones Numéricamente¶
A menudo, solve no podrá encontrar una solución exacta para
la ecuación o ecuaciones especificadas. Cuando falla, puedes usar
find_root para encontrar una solución numérica. Por ejemplo, solve no
devuelve nada interesante para la siguiente ecuación:
sage: theta = var('theta')
sage: solve(cos(theta)==sin(theta), theta)
[sin(theta) == cos(theta)]
Por otro lado, podemos usar find_root para encontrar una solución a la
ecuación de arriba en el rango \(0 < \theta < \pi/2\):
sage: phi = var('phi')
sage: find_root(cos(phi)==sin(phi),0,pi/2)
0.785398163397448...
Diferenciación, Integración, etc.¶
Sage sabe cómo diferenciar e integrar muchas funciones. Por ejemplo, para diferenciar \(\sin(u)\) con respecto a \(u\), haz lo siguiente:
sage: u = var('u')
sage: diff(sin(u), u)
cos(u)
Para calcular la cuarta derivada de \(\sin(x^2)\):
sage: diff(sin(x^2), x, 4)
16*x^4*sin(x^2) - 48*x^2*cos(x^2) - 12*sin(x^2)
Para calcular las derivadas parciales de \(x^2+17y^2\) con respecto a x e y, respectivamente:
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
También podemos calcular integrales, tanto indefinidas como definidas. Para calcular \(\int x\sin(x^2)\, dx\) y \(\int_0^1 \frac{x}{x^2+1}\, dx\)
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)
Para calcular la descomposición en fracciones simples de \(\frac{1}{x^2-1}\):
sage: f = 1/((1+x)*(x-1))
sage: f.partial_fraction(x)
-1/2/(x + 1) + 1/2/(x - 1)
Resolviendo Ecuaciones Diferenciales¶
Puedes usar a Sage para investigar ecuaciones diferenciales ordinarias. Para resolver la ecuación \(x'+x-1=0\):
sage: t = var('t') # defina una variable t
sage: x = function('x')(t) # defina x como una función de esa variable
sage: DE = diff(x, t) + x - 1
sage: desolve(DE, [x,t])
(_C + e^t)*e^(-t)
Esto utiliza el interfaz a Maxima de Sage [Max], por lo que el resultado puede diferir de otros resultados de Sage. En este caso, la salida nos dice que la solución general a la ecuación diferencial es \(x(t) = e^{-t}(e^{t}+c)\).
También puedes calcular transformadas de Laplace; la transformada de Laplace de \(t^2e^t -\sin(t)\) se calcula como sigue:
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
Veamos un ejemplo más complicado. El desplazamiento desde el punto de equilibrio de dos resortes acoplados, sujetos a una pared a la izquierda
|------\/\/\/\/\---|masa1|----\/\/\/\/\/----|masa2|
resorte1 resorte2
está modelado por el sistema de ecuaciones diferenciales de segundo órden
donde \(m_{i}\) es la masa del objeto i, \(x_{i}\) es el desplazamiento desde el equilibrio de la masa i, y \(k_{i}\) es la constante de elasticidad del resorte i.
Ejemplo: Utiliza Sage para resolver el problema de arriba con \(m_{1}=2\), \(m_{2}=1\), \(k_{1}=4\), \(k_{2}=2\), \(x_{1}(0)=3\), \(x_{1}'(0)=0\), \(x_{2}(0)=3\), \(x_{2}'(0)=0\).
Solución: Toma la transformada de Laplace de la primera ecuación (con la notación \(x=x_{1}\), \(y=x_{2}\)):
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)
El resultado puede ser difícil de leer, pero significa que
(donde la transformada de Laplace de una función en letra minúscula como \(x(t)\) es la función en letra mayúscula \(X(s)\)). Toma la transformada de Laplace de la segunda ecuación:
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
Esto dice
Introduce las condiciones iniciales para \(x(0)\), \(x'(0)\), \(y(0)\) y \(y'(0)\) y resuelve las dos ecuaciones resultantes:
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)]]
Ahora toma la transformada inversa de Laplace para obtener la respuesta:
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)
Por tanto, la solución es
La solución puede dibujarse paramétricamente usando
sage: t = var('t')
sage: P = parametric_plot((cos(2*t) + 2*cos(t), 4*cos(t) - cos(2*t) ),\
....: (0, 2*pi), rgbcolor=hue(0.9))
sage: show(P)
Los componentes individuales pueden dibujarse usando
sage: t = var('t')
sage: p1 = plot(cos(2*t) + 2*cos(t), 0, 2*pi, rgbcolor=hue(0.3))
sage: p2 = plot(4*cos(t) - cos(2*t), 0, 2*pi, rgbcolor=hue(0.6))
sage: show(p1 + p2)
REFERENCIAS: Nagle, Saff, Snider, Fundamentos De Ecuaciones Diferenciales, 6a ed, Addison-Wesley, 2004. (véase § 5.5).
Método De Euler Para Sistemas De Ecuaciones Diferenciales¶
En el siguiente ejemplo, ilustraremos el método de Euler para EDOs de primer y segundo órden. Primero, recordemos la idea básica para ecuaciones de primer órden. Dado un problema con valor inicial de la forma
queremos encontrar el valor aproximado de la solución en \(x=b\) con \(b>a\).
Recuerda de la definición de derivada que
donde \(h>0\) está dado y es pequeño. Esto, junto con la ED, dan \(f(x,y(x))\approx \frac{y(x+h)-y(x)}{h}\). Ahora resuelve para \(y(x+h)\):
Si llamamos a \(h f(x,y(x))\) el «término de corrección» (a falta de algo mejor), llamamos a \(y(x)\) «el valor viejo de y», y llamamos a \(y(x+h)\) el «nuevo valor de y», entonces, esta aproximación puede re-expresarse como
Si descomponemos el intervalo desde a a b en n pasos, de modo que \(h=\frac{b-a}{n}\), podemos guardar la información dada por este método en una tabla.
\(x\) |
\(y\) |
\(hf(x,y)\) |
|---|---|---|
\(a\) |
\(c\) |
\(hf(a,c)\) |
\(a+h\) |
\(c+hf(a,c)\) |
… |
\(a+2h\) |
… |
|
… |
||
\(b=a+nh\) |
??? |
… |
La meta es llenar todos los espacios de la tabla, una fila cada la vez, hasta que lleguemos a la casilla ???, que será la aproximación del método de Euler para \(y(b)\).
La idea para los sistemas de EDOs es similar.
Ejemplo: Aproxima numéricamente \(z(t)\) en \(t=1\) usando 4 pasos del método de Euler, donde \(z''+tz'+z=0\), \(z(0)=1\), \(z'(0)=0\).
Debemos reducir la EDO de segundo órden a un sistema de dos EDs de primer órden (usando \(x=z\), \(y=z'\)) y aplicar el método de Euler:
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
Por tanto, \(z(1)\approx 0.75\).
También podemos dibujar los puntos \((x,y)\) para obtener una representación
aproximada de la curva. La función que hace esto es eulers_method_2x2_plot.
Para poder usarla, necesitamos definir las funciones f y
g que toman un argumento con tres coordenadas: (t, x,*y*).
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)
A estas alturas, P está guardando dos gráficas: P[0], el gráfico de x
vs. t, y P[1], el gráfico de y vs. t. Podemos mostrar ámbas como sigue:
sage: show(P[0] + P[1])
Funciones Especiales¶
Se han implementado varios polinomios ortogonales y funciones especiales, utilizando tanto PARI [GAP] como Maxima [Max]. Estas funciones están documentadas en las secciones apropiadas («Polinomios Ortogonales» y «Funciones Especiales», respectivamente) del manual de referencia de Sage.
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() # los últimos digitos son al azar
0.16708949925104...
Hasta este punto, Sage únicamente ha encapsulado estas funciones para uso numérico. Para uso simbólico, por favor utiliza directamente la interfaz a Maxima, como en el siguiente ejemplo:
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'
- GAP
El Grupo GAP,
GAP - Grupos, Algorítmos y Programación, https://www.gap-system.org- Max(1,2)
Maxima, http://maxima.sf.net/