SageMath (ou simplesmente Sage) é um sistema de computação algébrica. Dentre outras, algumas vantágens de usar sistemas desse tipo são:
Tópicos da aula de hoje
Você pode fazer o jupyter exibir as equações no formato LATEX digitando %display latex
em uma célula.
%display latex # outras opções são plane, ascii_art e unicode_art
reset() #inicializa todas as variáveis
No Sage as operações básicas com números reais, complexos, racionais, etc., são realizadas como nas calculadoras científicas. Frações e raízes são automaticamente simplificadas
15/25+3/2
sqrt(20)/pi
Aproximação numérica
sqrt(20).n()
sqrt(20.0)
Algumas operações e funções básicas do Sage:
Operação | Sintáxe |
---|---|
4 operações | a+b, a-b, a*b, a/b |
Potêmcia | a**b ou a^b |
Raiz quadrada | sqrt(a) |
Divisão inteira | a//b |
Resto na divisão | a%b |
Fatorial | factorial(a) |
Coeficiente binômial (ab) | binomial(a,b) |
Parte inteira | floor(a) |
Valor absoluto | abs(a) |
Aproximação numérica | N(a) ou a.n() |
Existem dois tipos básicos de variáveis no sage:
Variáveis simbólicas precisam ser declaradas. Exceto x
, que já vem pré-declarada.
var('u y w a b c')
Uma lista de varáveis simbólicas indexadas pode ser criada com:
X = var('x',n=4)
X
X[1]
Você pode tammbém definir o domínio e um nome LATEX para variáveis simbólicas.
var('alp_bar', latex_name=r'\bar{\alpha}', domain='real')
alp_bar
Variáveis simbólicas são usadas, por exemplo, para declarar funções.
f(u)=cos(u)^6 + sin(u)^6 + 3 * sin(u)^2 * cos(u)^2
f
Código LATEX
print(latex(f(u)))
\cos\left(u\right)^{6} + \sin\left(u\right)^{6} + 3 \, \cos\left(u\right)^{2} \sin\left(u\right)^{2}
Assim como Python, o Sage usa o paradigma de orientação ao objeto. Se você digitar .
após o nome de um objeto e apertar a tecla Tab, será exibda uma lista de métodos associados a este objeto.
_
__
___
_
Um ?
após o nome de uma função exibe uma descrição da mesma, geralmente com alguns exemplos.
Expressões simbólicas podem ser manipuladas de várias formas
p = (x+y)*(x+1)^2; p
p2 = p.expand(); p2
p2.collect(x) #potências da x
p2.factor()
Identidades trigonômétricas podem ser utilizadas com .expand_trig()
sin(x+y).expand_trig()
tanh(x+y).expand_trig()
Ou simplificadas usando trig_simplify()
f(u)
f(u).diff()
f(u).trig_simplify()
f(u).diff().trig_simplify()
Manipulação simbólica de polinômios:
Função | Comando |
---|---|
expandir | expand() |
polinômio em x |
collect(x) |
Fatorar | factor() |
Funções trigonométricas:
Função | Comando |
---|---|
Simplificação | trig_simplify() |
Linearização | reduce_trig() |
Expansão | expand_trig() |
Raízes e frações:
Função | Comando |
---|---|
Somar frações com o mesmo denominador | combine() |
Rotina de simplificações com raízes e frações(muito útil) | canonicalize_radical() |
Geral:
Função | Comando |
---|---|
Simplificação | simplify() |
Simplificação completa | full_simplify() |
Equações podem ser definidas por expressões simbólicas e guardadas em variáveis python e manipuladas.
var('phi')
eq0 = y**2 - 2/cos(phi)*y + 5/cos(phi)**2 - 4 == 0; eq0
eq1=(eq0*cos(phi)^2).expand(); eq1
Para extrair os lados da equação, .lhs()
ou .rhs()
eq1.lhs()
eq1.rhs()
Equações também podem ser resolvidas diretamente usando o comando solve
solve(eq1,y)
sol=solve(eq1,phi); sol
sol[0]
sol[0].rhs()
print(latex(sol[0].rhs()))
\pi - \arccos\left(-\frac{y}{y^{2} - 4} + \frac{2 \, \sqrt{-y^{2} + 5}}{y^{2} - 4}\right)
Você pode assumir expressões simbólicas que serão usadas nos cálculos simbólicos internamente com a função assume(expressão)
assume(phi^2<20)
assumptions()
O solve
também resolve sistemas de equações ou inequações
eq2 = x^2 + x*y + 2 == 0
eq3 = y^2 == x*(x+y)
(eq2, eq3)
sols = solve((eq2, eq3), x, y)
sols
sols[0]
sols[0][0]
solve(x^2+x-1 > 0, x)
Em alguns casos o solve não consegue encontar uma solução para a equação.
expr = sin(x) + sin(2 * x) + sin(3 * x)==0;expr
solve(expr, x)
Nesses casos podemos usar a função find_root
A função find_root(equação, min, max)
procura solução numérica para a equação no intervalo entre min e max.
find_root(expr,.1,pi)
Nesse caso particular, uma solução analítica poderia ser obtida simplificando a equação
expr2 = expr.simplify_trig().factor(); expr2
solve(expr2, x)
expr.lhs()
plot(expr.lhs(),(x,0,pi), gridlines=True)
Note que existem mais sluções do que o que o find_root
encontrou. Ele mostra a primeira que encontra.
Poderíamos encontar a outra restringindo o intervalo (min, max)
find_root(expr,.1,pi/2+.1)
Função | Sintáxe |
---|---|
Solução simbólica | solve(equação, variável) |
Solução numérica | find_root(equação, min, manx) |
Simples
diff(sin(x^2),x)
de ordem superior
diff(sin(x^2), x,3)
parcial
h(x,y) = x*y^2 + sin(x^2) + e^(-x); h(x,y)
diff(h(x,y), x)
diff(h(x,y), y)
g(x) = 1/(1+x^2)
integral(g(x),x, -infinity, infinity,hold=True)
integral(g(x),x, -infinity, infinity)
var('G M r c')
integrate(1-2*G*M/(c^2*r), r)
diff(_,r)
Para calcular numericamente uma integral usamos a função integral_numerical
.
Essa função retorna um par:
integral_numerical(sin(x)/x, 0, 1)
integral(sin(x)/x,x, 0, 1)
integral(sin(x)/x,x, 0, 1).n()
sin_integral?
taylor(f(x), x, 0, 3)
Função | Sintáxe |
---|---|
Limite | lim(f(x),x=a) ou limit(f(x),x=a) |
Derivada | diff(f(x), x) ou f(x).diff() |
n-ésima derivada | diff(f(x), x, n) |
Integral indefinida | integral(f(x), x) |
Integral definida | integral(f(x), x, lim_inf, lim_sup) |
Integral numérica | integral_numerical(f(x), lim_inf, lim_sup) |
Série de Taylor | taylor(f(x), x, x_0, ordem) |
Uma funcionalidade muito útil em cálculos simbólicos é a substituição de exprssões com o método .subs()
.
var('A B C D')
a = A+B;a
a.subs(A==D)
f(x) = A*x^2+B*x+C;f(x)
f(x).subs(A==1,B==5,C==9)
b = diff(f(x),x)+cos(x);b
b.subs(cos(x)==2)
Podemos introduzir funções com expressão não definida
h = function('h')(x);h
c = diff(h(x),x,2)+2*f(3*x)^2;c
c.subs(diff(h(x),x,2)==x/pi)
y = function('y')(x);y
ed_1 = diff(y,x) == (cos(y)-2*x)/(y+x*sin(y)); ed_1
Lembrando que para resolver equações diferenciais usamos desolve(equação, dvar, ivar=t)
, onde dvar
é a variável dependente e ivar=t
indica que a variável independente e t
sol_ed = desolve(ed_1, y); sol_ed
Podemos plotar a função usando o implicit_plot
O comando implicit_plot
recebe uma função de duas variáveis como entrada, f(x,y), e plota a curva f(x,y)=0 sobre os intervalo de x e y especificados. Sintáxe implicit_plot(f(x,y),(x,xmin,xmax),(y,ymin,ymax), *opções)
var('u')
sol_ed2 = sol_ed.lhs().subs(y(x)==u);sol_ed2
plot_sol = implicit_plot(sol_ed2, (x,-.5,1), (u,-.7,.7), color=(0,.5,1), axes_labels=['$x$','$u$']); plot_sol
Com campo
plot_campos = plot_slope_field(ed_1.rhs().subs({y(x):u}), (x,-1.5,2), (u,-1.5,1.5));plot_campos
plot_sol+plot_campos
var('y z r theta phi')
eqx = x == r*sin(theta)*cos(phi)
eqy = y == r*sin(theta)*sin(phi)
eqz = z == r*cos(theta)
Determine a expansão de até terceira ordem para a modificação em g a uma altura h acima da superfície da terra.