Aplicação à Física - 01 (Sistema massa-mola com duas massas acopladas)

Vamos utilizar o Sage para resolução de um problema de Física. Considerando um sistema de duas massas acopladas por molas de constantes elásticas diferentes, como representado abaixo:

 onde obtemos as equações para as forças atuando nas massas $m_1$ e $m_2$, respectivamente:

$F_1=-k_1x_1+k_2(x_2-x_1)$
$F_2=-k_2(x_2-x_1)$

assim, usando a segunda lei de Newton (para massa constante) $F=mx''$, chegamos as equações:

$m_1x_1''+(k_1+k_2)x_1-k_2x_2=0 \quad (1)$
$m_2x_2''+k_2x_2-k_2x_1=0 \quad (2)$

Agora, escrevemos a Eq. (1) no Sage:

sage: var('m1,x1,k1,m2,x2,k2')                         
(m1, x1, k1, m2, x2, k2)
sage: eq1=maxima("m1*diff(x1(t),t,2)+(k1+k2)*x1(t)-k2*x2(t)")

onde maxima( ) diz ao Sage para usar a interface do Maxima para cálculos algébricos.

Calculando a transformada de Laplace:

sage: leq1=eq1.laplace("t","s");leq1                
m1*(-?%at('diff(x1(t),t,1),t=0)+s^2*'laplace(x1(t),t,s)-x1(0)*s)-k2*'laplace(x2(t),t,s)+(k2+k1)*'laplace(x1(t),t,s)

Isso quer dizer que encontramos:

$${\it m_1}\,\left(-\left.{{{\it \partial}}\over{{\it \partial}\,t}}  \,{\it x_1}\left(t\right)\right|_{t=0}+s^2\,\mathcal{L}\left(  {\it x_1}\left(t\right) , t , s\right)-{\it x_1}\left(0\right)\,s  \right)-{\it k_2}\,\mathcal{L}\left({\it x_2}\left(t\right) , t , s  \right)+\left({\it k_2}+{\it k_1}\right)\times\,\times\mathcal{L}\left({\it x_1}  \left(t\right) , t , s\right) \quad (3)$$

Para equação (2), temos:

sage: eq2=maxima("m2*diff(x2(t),t,2)+k2*(x2(t)-x1(t))")  
sage: leq2=eq2.laplace("t","s");leq2
m2*(-?%at('diff(x2(t),t,1),t=0)+s^2*'laplace(x2(t),t,s)-x2(0)*s)+k2*('laplace(x2(t),t,s)-'laplace(x1(t),t,s))

ou seja:

$$ {\it m_2}\,\left(-\left.{{{\it \partial}}\over{{\it \partial}\,t}}  \,{\it x_2}\left(t\right)\right|_{t=0}+s^2\,\mathcal{L}\left(  {\it x_2}\left(t\right) , t , s\right)-{\it x_2}\left(0\right)\,s  \right)+{\it k_2}\,\left(\mathcal{L}\left({\it x_2}\left(t\right) ,   t , s\right)-\mathcal{L}\left({\it x_1}\left(t\right) , t , s\right)  \right) \quad (4)$$

Agora, considerando os seguintes valores: $m_1=2$, $m_2=1$, $k_1=4$, $k_2=2$ nas equações (3) e (4) para as massas e constantes elásticas, respectivamente:

$$-2x_1'(0)+2s^2\mathcal{L}_1(s)-2sx_1(0)-2\mathcal{L}_2(s)+6\mathcal{L}_1(s) \quad (5)$$
$$-x_2'(0)+s^2\mathcal{L}_2(s)-sx_2(0)+2\mathcal{L}_2(s)-2\mathcal{L}_1(s) \quad (6)$$

e as condições iniciais $x_1(0)=3$, $x_1'(0)=0$, $x_2(0)=3$, $x_2'(0)=0$, obtemos:

$$2s^2\mathcal{L}_1(s)-6s-2\mathcal{L}_2(s)+6\mathcal{L}_1(s) \quad (7)$$
$$s^2\mathcal{L}_2(s)-3s+2\mathcal{L}_2(s)-2\mathcal{L}_1(s) \quad (8)$$

Vamos definir no Sage o sistema de equações com (7) e (8), e usar a função solve() para resolvê-lo:


sage: var('s L1 L2')
(s, L1, L2)
sage: eqs = [(2*s^2+6)*L1-2*L2 == 6*s, (s^2+2)*L2 - 2*L1 == 3*s]
sage: solve(eqs,L1,L2)
[[L1 == 3*(s^3 + 3*s)/(s^4 + 5*s^2 + 4), L2 == 3*(s^3 + 5*s)/(s^4 + 5*s^2 + 4)]]


Por fim, tomamos a transformada de Laplace inversa utilizando a função inverse_laplace() para obter a resposta:


sage: var('s t')
(s, t)
sage: inverse_laplace(3*(s^3 + 3*s)/(s^4 + 5*s^2 + 4),s,t)
cos(2*t) + 2*cos(t)
sage: inverse_laplace(3*(s^3 + 5*s)/(s^4 + 5*s^2 + 4),s,t)
-cos(2*t) + 4*cos(t)


Assim, a solução é:

$$x_1=\cos(2t)+2\cos(t), \quad x_2=-\cos(2t)+4\cos(t).$$

É possível obter um gráfico do comportamento das soluções passando os seguintes comandos para o Sage:


sage: p1 = plot(cos(2*t) + 2*cos(t), (t,0, 2*pi), rgbcolor=hue(0.3), legend_label='\$x_1(t)\$', axes_labels=['\$t\$','\$x\$'])
sage: p2 = plot(4*cos(t) - cos(2*t), (t,0, 2*pi), rgbcolor=hue(0.6), legend_label='\$x_2(t)\$', axes_labels=['\$t\$','\$x\$'])
sage: show(p1 + p2)

futuramente explicarei os parâmetros utilizados na função plot().

Referências

[1] Sage Tutorial v5.7 - Solving Differencial Equations. 
[2] Spiegel, Murray R. Transformadas de Laplace. Coleção Schaum. São Paulo: Mc Graw Hill, 1979.
[3] Lima, Paulo Cupertino de. Equações Diferenciais A. (notas de aula). Departamento de Matemática - UFMG.
[4] Nussenzveig, H. M. Curso de Fisica Basica 2 - Fluidos, Oscilacões e Ondas, Calor. 4ª Ed. EDGARD BLUCHER, 2002.

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

Tutorial do Sage - 02

Obtendo ajuda

Para obter informações sobre uma função ou constante (por exemplo) é só digitar o seu nome seguido do símbolo de interrogação: 

sage: pi?

Type:           Expression

Base Class:     <type 'sage.symbolic.expression.Expression'>

String Form:    pi

Namespace:      Interactive

Length:         0

File:           /opt/sage-4.8/local/lib/python2.6/site-packages/sage/symbolic/expression.so

Definition:     pi(self, *args, **kwds)

Docstring:

       Nearly all expressions are created by calling

       new_Expression_from_*, but we need to make sure this at least

       doesn't leave self._gobj uninitialized and segfault.

    

       TESTS:

Type:           Expression

Base Class:     <type 'sage.symbolic.expression.Expression'>

Type:           Expression

Base Class:     <type 'sage.symbolic.expression.Expression'>

String Form:    pi

Namespace:      Interactive

Length:         0

File:           /opt/sage-4.8/local/lib/python2.6/site-packages/sage/symbolic/expression.so

Definition:     pi(self, *args, **kwds)

Docstring:

       Nearly all expressions are created by calling

       new_Expression_from_*, but we need to make sure this at least

       doesn't leave self._gobj uninitialized and segfault.

    

       TESTS:

    

          sage: sage.symbolic.expression.Expression(SR)

          0

          sage: sage.symbolic.expression.Expression(SR, 5)

          5

    

       We test subclassing "Expression":

    

          sage: from sage.symbolic.expression import Expression

          sage: class exp_sub(Expression): pass

          sage: f = function('f')

          sage: t = f(x)

          sage: u = exp_sub(SR, t)

          sage: u.operator()

          f

Constructor Docstring:

       Nearly all expressions are created by calling

       new_Expression_from_*, but we need to make sure this at least

       doesn't leave self._gobj uninitialized and segfault.

.

.

.

sage: sin?

Type:           Function_sin

Base Class:     <class 'sage.functions.trig.Function_sin'>

String Form:    sin

Namespace:      Interactive

File:           /opt/sage-4.8/local/lib/python2.6/site-packages/sage/functions/trig.py

Definition:     sin(self, *args, coerce=True, hold=False, dont_call_method_on_arg=False)

Docstring:

       The sine function.

    

       EXAMPLES:

    

          sage: sin(0)

          0

          sage: sin(x).subs(x==0)

          0

          sage: sin(2).n(100)

          0.90929742682568169539601986591

          sage: loads(dumps(sin))

          sin

    

       We can prevent evaluation using the "hold" parameter:

    

          sage: sin(0,hold=True)

          sin(0)

    

       To then evaluate again, we currently must use Maxima via

       "sage.symbolic.expression.Expression.simplify()":

    

          sage: a = sin(0,hold=True); a.simplify()

          0

    

       TESTS:

    

          sage: conjugate(sin(x))

          sin(conjugate(x))

Constructor Docstring:

       The sine function.

    

       EXAMPLES:

    

          sage: sin(0)

          0

.

.

.

é possível completar as funções/comandos do Sage usando a tecla TAB.

Funções, Indentação e  Contagem

Para definir uma função no Sage utiliza-se o comando def e dois pontos após a lista de variáveis definidas. Ex: 

sage: def par(n):

....:     return n%2==0

....: 

sage: par(3)

False

sage: par(6)

True

Não é necessário especificar o tipo de qualquer argumento de entrada e as funções podem ter múltiplos argumentos. Cada argumento pode ter um valor padrão, que é usado caso não for passado nenhum outro valor. Ex:

sage: def divisivel_por(numero,divisor=3):

....:     return numero%divisor==0

....: 

sage: divisivel_por(4,2)

True

sage: divisivel_por(4)

False

sage: divisivel_por(6)

True

Como o Sage é uma interface em Python, os blocos de código não são indicados por chaves ou qualquer sinalizador de inicio e fim mas sim pela própria indentação. Ex

(sem erro de indentação)

sage: def pares_ate(n):

....:     v=[]

....:     for i in range(3,n):

....:         if i%2==0:

....:             v.append(i)

....:     return v

....: 

sage: pares_ate(12)

[4, 6, 8, 10]

(com erro de indentação)

sage: def pares_ate(n):

....:     v=[]

....:     for i in range(3,n):

....:         if i%2==0:

....:             v.append(i)

....: return v    

------------------------------------------------------------

   File "<ipython console>", line 6

     return v

          ^

SyntaxError: invalid syntax

Ponto e virgula (;) no final de atribuições de variáveis, por exemplo, não é necessário, quando as declarações são feitas em linhas separadas. No caso de fazer mais de uma declaração na mesma linha é preciso usar o ponto e vírgula. 

sage: a=3  

sage: b=a+2

sage: b

5

sage: a=4; b=a-1; b

3

Caso queira que uma linha de código continue na próxima, é só usar a barra invertida (\):

sage: 5 + \

....: 6

11

No Sage é possível fazer uma contagem iterando no domínio dos inteiros. Por exemplo, a iteração for(i=0; i<5; i++) no C++ ou Java, no Sage, fica:

sage: for i in range(5):

....:     print i

....:     

0

1

2

3

4

Se quisermos que a iteração comece de um número diferente de zero:

sage: for i in range(3,5):           

....:     print i

....:     

3

4

Se quisermos especificar também o passo da iteração, acrescentamos mais um argumento: 

sage: for i in range(2,7,2):             

....:     print i

....:     

2

4

6

A estrutura mais básica no Sage é uma lista. Um lista pode ser criada, por exemplo, pelo comando range:

sage: range(1,10)

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Uma lista pode ser armazenada em uma variável e ela pode ter não só números, mas textos e funções, por exemplo:

sage: w = [3, "oi", 5/3, tan(x^2)]

sage: w

[3, 'oi', 5/3, tan(x^2)]

A indexação da lista começa do zero:

sage: w[0]

3

Use len(w) para obter o comprimento de w, use w.append(obj) para acrescentar um novo objeto no final da lista w, e use del w[i] para deletar a i-ésima entrada de w.

sage: len(w)

4

sage: w.append(e^2)

sage: w

[3, 'oi', 5/3, tan(x^2), e^2]

sage: del w[3]

sage: w

[3, 'oi', 5/3, e^2]

Outra estrutura de dados importante é o dicionário. Ele funciona como uma lista, exceto que pode ser indexado por quase qualquer objeto e é delimitado por chaves: 

sage: k = {'oi':5, 9.9:e, pi:'teste'}

sage: k[9.9]

e

sage: k['oi']

5

sage: k[pi]

'teste'

Sage para o android

Já tinha instalado no celular uma versão similar do octave/matlab para android chamada addi, que roda nativamente, e hoje resolvi procurar se já tinham feito uma versão do Sage. E não é que já existe!

O Sage para android não roda nativamente, é um cliente que acessa o servidor do Sage e roda comandos nele, mostrando o resultado na tela do smartphone! Isso é de grande valia para facilitar o aprendizado, já que podemos estar com o software sempre a mãos para aprender e treinar os comandos. Para instalar você pode procurar por "Sage Math" na Play Store do seu android ou baixar pelo link direto: https://play.google.com/store/apps/details?id=org.sagemath.droid

Caso queira acessar oflline o Sage pelo smarthphone, pode fazer igual o cara desse blog: http://neutraldrifts.blogspot.com.br/2009/02/carl-witty-does-sage-on-g1.html e passar em torno de 15 dias compilando no celular!

Ainda não cheguei nesse nível de loucura, por enquanto o cliente do Sage já está sendo-me muito útil!

Tutorial do Sage - 01

Seguindo o tutorial oficial do Sage vamos começar!

Atribuição, igualdade e aritmética 

Pra quem já conhece Python, vai ficar fácil, o Sage usa as expressões dessa linguagem nas construções matemáticas, mas quem não conhece, é fácil aprender. Para atribuições usamos o  = em comparações, usamos ==,  <=, >=, < e >, Ex:

Atribuindo o valor 3 para variável a:

sage: a = 3
sage: a
3

(Depois de atribuir, quando é digitado a variável o Sage fornece o seu valor como resposta.)

Fazendo comparações entre números:

sage: 3>2
True
sage: 5<=5
True
sage: 1<0
False
sage: 7==2
False

(O Sage fornece como resultado das comparações as palavras True (verdadeiro) e False (falso).)

Operações matemáticas:

sage: 4**2
16
sage: 4^2
16

(para exponenciação, tanto faz utilizar o ** ou o ^)

sage: 10%4
2

(o operador % para argumentos inteiros fornece o resto da divisão dos números)

sage: 8/6
4/3
sage: 8//6
1

(o operador / fornece a divisão dos números. Quando duplicado, em argumentos inteiros o // retorna o coeficiente inteiro da divisão.)

A ordem de precedência (da menor para a maior) dos operadores matemáticos é:

+, - adição, subtração *, /, % multiplicação, divisão, resto **, ^ exponenciação. Assim

sage: 2*3^2+4%3

19

O Sage calcula primeiro 3^2, depois multiplica 2*9 depois obtém o resto de 4%3 e, por fim, faz a soma 18+1.

Algumas funções matemáticas:

sage: sqrt(5.2)

2.28035085019828

(raiz quadrada de 5.2)

sage: sin(4.1)

-0.818277111064410

(seno de 4.1. Vale frisar que o argumento é em radianos)

O Sage fornece respostas 'exatas' em vez de aproximações numéricas, quando possível. Ex.

sage: sin(pi/3)
1/2*sqrt(3)
sage: exp(2)
e^2

Existem duas formas de obter uma aproximação numérica com o Sage: usando a função n( ) ou o método .n( ). O "n" pode ser maiúsculo e pode ser usado também o nome completo da função/método: numerical_approx. Ex.


sage: n(pi)
3.14159265358979
sage: pi.n()
3.14159265358979
sage: N(pi)
3.14159265358979
sage: pi.N() 
3.14159265358979

sage: numerical_approx(pi)

3.14159265358979

sage: pi.numerical_approx()

3.14159265358979

Outra opção para função ou o método n são os argumentos prec (especifica o número de bits de precisão; padrão 53 bits) e digits (especifica o número de digitos decimais de precisão):


sage: n(e^2)  
7.38905609893065
sage: n(e^2,prec=100)
7.3890560989306502272304274606

sage: n(e^2,digits=50) 
7.3890560989306502272304274605750078131803155705518
sage: e^2.n(prec=100)
7.3890560989306502272304274606
sage: e^2.n(digits=50)
7.3890560989306502272304274605750078131803155705518

O valor atribuído a uma variável tem um tipo associado a ele e esse vai ser o tipo da variável . Podemos verificar o tipo de cada variável da forma:


sage: a=7    # valor inteiro atribuído
sage: type(a)
<type 'sage.rings.integer.Integer'>
sage: a=7/4  # agora "a" é um número racional
sage: type(a)
<type 'sage.rings.rational.Rational'>
sage: a='aprender' # por fim, "a" agora é uma string (texto)
sage: type(a)     
<type 'str'>

Observação final: tudo que é escrito depois do "jogo da velha" # não é interpretado pelo Sage. Esse símbolo é usado para acrescentar comentários nos códigos. 

Instalando o Sage

A instalação do Sage pode ser feita a partir do código fonte do programa ou utilizando o pacote binário pré-compilado. Como bom usuário do Linux Gentoo, preferi a primeira opção e compilei o Sage otimizado para o meu hardware. Aqueles que preferirem a praticidade em vez da eficiência, podem utilizar o guia da instalação do Sage pré-compilado: http://www.sagemath.org/doc/installation/binary.html. No link tem também a instrução para instalação no Micro\$oft Window\$ que eu não abordarei aqui.

• Passos para instalação pelo código fonte:

1. Clique no link: http://www.sagemath.org/download-source.html, selecione o espelho mais próximo (no caso do Brasil: http://sagemath.c3sl.ufpr.br/src/index.html) e faça download do arquivo sage-x.y.z.tar. (O arquivo tar contém o código fonte do Sage e de todos os programas que o Sage depende. Depois de fazer download mova o tar para o diretório que você queira que o Sage seja instalado.)

2. Extraia: tar xvf sage-x.y.z.tar

3. Isto criará o diretório sage-x.y.z

4. Entre no diretório criado: cd sage-x.y.z/

5. Opcional (mas altamente recomendado): leia o arquivo README.txt

6. Caso o seu sistema for 64-bit, como o meu, digite no terminal: 

SAGE64=yes

export SAGE64

7. Digite: make (aperte a tecla < enter > e tenha paciência!) 

Nessa parte seu computador vai estar compilando o Sage e todas as suas dependências. Não é necessário (e nem deve-se!) logar como root para compilar o Sage.

8. Para iniciar o Sage, dentro do diretório instalado, digite:

./sage

Isso fará com que apareça o prompt de comandos do Sage, que é uma de suas interfaces e a que eu pretendo abordar nesse blog. No caso da minha versão atual (4.8) aparece:

Para que você possa chamar o Sage de qualquer lugar no terminal, basta acrescentar o caminho da sua instalação no arquivo ~/.bashrc. No meu caso, instalei o Sage no diretório: /opt/sage-4.8/

Assim, acrescentei no meu .bashrc a linha: export PATH=$PATH:/opt/sage-4.8/ 

No caso de você ter instalado em outro diretório, basta alterar o caminho!