Tutorial do Sage - 03

Álgebra Básica e Cálculo

Resolvendo equações

Resolvendo Equações Exatamente

A função solve() resolve equações. Primeiro, devemos definir as variáveis a serem utilizadas, depois o argumento da função pode ser uma equação ou sistema de equações junto com as variáveis que queremos resolver. 

sage:  x = var('x')

sage: solve(2*x^2 + 5*x + 3, x)

[x == (-3/2), x == -1]

É possível resolver equações em termos de outras variáveis:


sage: x, a, b, c = var('x a b c')
sage: solve([a*x^2 + b*x + c == 0],x)
[x == -1/2*(b + sqrt(-4*a*c + b^2))/a, x == -1/2*(b - sqrt(-4*a*c + b^2))/a]

É possível obter solução para várias variáveis:

sage: x, y = var('x, y')
sage: solve([x+y==3, x-y==8], x, y)
[[x == (11/2), y == (-5/2)]]

O seguinte exemplo de uso do Sage para resolver um sistema de equações não linear foi feito por Jason Grout: primeiro resolvemos o sistema simbolicamente:

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(2)*sqrt(5) - 2/3], [p == 1, q == 8, x == 4/3*sqrt(10) - 2/3, y == -1/6*sqrt(2)*sqrt(5) - 2/3]]

Para obter aproximações numéricas das soluções, podemos usar:

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(2)*sqrt(5) - 2/3], [p == 1, q == 8, x == 4/3*sqrt(10) - 2/3, y == -1/6*sqrt(2)*sqrt(5) - 2/3]]

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

(a função n() mostra a aproximação numérica e o argumento é o número de bits de precisão.)

Resolvendo Equações Numericamente

Em algumas situações, a função solve não será apta a encontrar uma solução exata para equação especificada. Quando ela falha, você pode usar find_root para encontrar uma aproximação numérica. Por exemplo, solve não retorna nada em acréscimo para seguinte equação: 

sage: theta = var('theta')

sage: solve(cos(theta)==sin(theta), theta)

[sin(theta) == cos(theta)]

Usando find_root podemos encontrar a solução da equação acima em um alcance de $0<\theta< \pi/2$:

sage: find_root(cos(theta)==sin(theta),0,pi/2)

0.78539816339744839

Diferenciação, Integração, etc. 

O Sage sabe diferenciar e integrar muitas funções. Por exemplo diferenciar $\cos(u)$ em relação a $u$:

sage: u = var('u')

sage: diff(cos(u),u)

-sin(u)

Para computar a terceira derivada de $\sin(3x)$:

sage: diff(sin(3*x),x,3)

-27*cos(3*x)

Para computar as derivadas parciais de $ f(x,y) = x^3 + 5y^2 $ com respeito a $x$ e a $y$, respectivamente:

sage: var('x y')

(x, y)

sage: f = x^3 + 5*y^2

sage: f.diff(x)

3*x^2

sage: f.diff(y)

10*y

É possível resolver integrais definidas como $\int_0^2\frac{x}{x^2+1}dx$ ou indefinidas $\int x\sin(x^2)$


sage: integral(x*sin(x^2), x)
-1/2*cos(x^2)
sage: integral(x/(x^2+1), x, 0, 2)
1/2*log(5)


Para fazer a decomposição em frações parciais 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)

Resolvendo Equações Diferenciais 

Você pode usar o Sage para resolver equações diferenciais ordinárias. Para resolver a equação $x'+3x-2$:

sage: t = var('t') #define a variável t

sage: x = function('x',t) #define x como função de t

sage: eq = diff(x,t)+3*x-2

sage: desolve(eq,[x,t])

1/3*(3*c + 2*e^(3*t))*e^(-3*t)

O Sage usa sua interface para o Maxima e assim a sua saída pode ser um pouco diferente da saída do Sage. Neste caso, ele diz que a solução da equação diferencial é $x(t)=\frac{e^{-3t}}{3}(2e^{-3t}+3c)$

É possível calcular transformadas de Laplace com o Sage. Por exemplo, a transformada de $t^3-e^t\sin(t)$ é obtida da forma:

sage: s=var("s")
sage: t=var("t")
sage: f=t^3-exp(t)*sin(t)  
sage: f.laplace(t,s)     
-1/(s^2 - 2*s + 2) + 6/s^4