aplicaÇÕes do maxima ao cÁlculo iii - ime.unicamp.brmarcio/ss2006/grupo12.pdf · ......

36
APLICAÇÕES DO MAXIMA AO CÁLCULO III Guilherme Ariolli Salustiano RA 043815 MA311 – Turma A Profº Márcio Antônio de Faria Rosa

Upload: trankien

Post on 10-Jan-2019

215 views

Category:

Documents


0 download

TRANSCRIPT

APLICAÇÕES DO MAXIMA AO CÁLCULO III

Guilherme Ariolli Salustiano RA 043815 MA311 – Turma A Profº Márcio Antônio de Faria Rosa

2

1.1 O Programa O Maxima é um sistema de álgebra computacional para manipulação de expressões simbólicas e numéricas, incluindo integração, diferenciação, séries de Taylor, transformadas de Laplace, sistemas de equações lineares, vetores e matrizes.O Maxima produz resultados precisos e pode trabalhar com funções e dados em duas ou três dimensões. Maxima é derivado do sistema Macsyma, desenvolvido no MIT nos anos de 1968 a 1982 como parte do Projeto MAC. MIT remanejou uma cópia do código fonte do Macsyma para o Departamento de Energia em 1982; aquela versão é agora conhecida como Macsyma DOE. Uma cópia do Macsyma DOE foi mantida pelo Professor William F. Schelter da Universidade do Texas de 1982 até sua morte em 2001. Em 1998, Schelter obteve permissão do Departamento de Energia para liberar o código fonte do Macsyma DOE sob a Licença Pública GNU, e em 2000 ele iniciou o projeto Maxima no SourceForge para manter e desenvolver o Macsyma DOE, agora chamado Maxima. É o único sistema baseado em Macsyma ainda publicamente disponível e com uma comunidade de usuários ativa. Trata-se de um software livre (ou seja, gratuito, podendo então ser usado sem necessidade de registro e pagamento) para cálculos matemáticos, semelhante ao Matlab e ao Mathematica. Está disponível para vários sistemas operacionais (incluindo Windows, Linux e MacOS X) e é um software útil para quem deseja trabalhar com funções e afins. 1.2 Como Obter? A versão do Maxima utilizada neste tutorial é a versão 5.10.0 para Windows e seu download pode ser feito através do seguinte link: http://ufpr.dl.sourceforge.net/sourceforge/maxima/maxima-5.10.0b.exe - Tamanho do arquivo: 15.5 MB - Espaço necessário em disco: 73.5 MB Após o download realizado, a instalação é simples. Basta seguir os passos, selecionando as opções de instalação oferecidas pelo programa. Caso queira obter mais informações sobre o software ou deseja obtê-lo para outras plataformas, acesse o site oficial do Maxima. Site Oficial: http://maxima.sourceforge.net/

3

2.1 Introdução ao Máxima Após à instalação do programa, clique no ícone criado por este, seja na Área de Trabalho ou no Menu Iniciar, e, assim, dará a inicialização do software. A primeira tela apresentada segue abaixo:

Ela é dividida em 2 partes: A superior, o terminal, onde serão realizados os comandos e o trabalho em si, em torno do Maxima, e a parte inferior, que contem o pequeno Help do programa, ou seja, um sistema de ajuda, que pode ser bem útil ao usuário iniciante. Para facilitar nossas operações, podemos escondê-lo, clicando em Options > Toggle Browser Visibility. Ficando assim apenas com o terminal, onde serão digitadas as operações.

4

No terminal, as linhas acima do ‘(%i1)’ podem ser desconsideradas, pois se tratam de informações sobre o programa (versão, sites, criadores, etc.). O ‘(%i1)’ representa a posição na memória de cada operação a ser realizada, para recomeçar a memória basta acessar File > Restart. 2.2 Principais Comandos Iniciando o trabalho com operações. Você sempre digitará a operação à frente do ‘(%ix)’, esse ‘i’ no meio significa INPUT, portanto sempre será entrada de informações. Logicamente a saída do programa será representada por ‘(%ox)’, com ‘o’ sendo OUTPUT. Depois de digitada a operação, para indicar ao programa que a expressão já pode ser resolvida, é necessário digitar um ‘; ’(ponto e vírgula) no fim da expressão, por exemplo: (%i1) 1 + 1; (INPUT – representada em azul no Maxima). (%o1) 2 (OUTPUT – representada em preto no Maxima). Note que nada irá acontecer quando você esquecer de colocar o ponto e vírgula. Maxima irá simplesmente esperar por entradas adicionais.

5

Os espaços não são necessários e não são considerados pelo programa. Apenas auxiliam na leitura As operações básicas são facilmente representadas por: Adição (+), Subtração (-), Multiplicação (*), Divisão (/), Exponenciação (^). Outras operações fundamentais são representadas como apresentadas abaixo: log(x) – logaritmo natural de x. sqrt(x) – raiz quadrado de x. x^n – potenciação n de x. exp(x) – exponencial de x. Para obter mais informações sobre determinados comandos, utilize o comando ‘describe’ para mostrar todos os comandos e variáveis contendo uma dada seqüência de caracteres, e opcionalmente sua documentação. O ponto de interrogação ‘?’ pode ser utilizado para a mesma função do ‘describe’: (%i1) describe (assunto a ser pesquisado); ou (%i1) ? (assunto a ser pesquisado); Como naturalmente usado, a ordem de preferência das operações deve ser demonstrada através de parênteses ‘( )’. (%i1) (10+10) * 3; (%o1) 60

Para usar um resultado em cálculos posteriores, você pode atribuir esse valor a uma variável ou referir-se a esse mesmo valor através de seu rótulo gerado automaticamente. Adicionalmente, ‘%’ refere-se ao último resultado calculado: (%i1) x: 5 + 3; (%o1) 8 (%i2) x + 2; (%o2) 10 (%i1) 2 * 5; (%o1) 10 (%i2) % - 8; (%o2) 2

Maxima tem conhecimento sobre números complexos e constantes numéricas:

6

(%i1) sin(%pi); (%o1) 0 (%i2) exp(%i*%pi); (%o2) - 1 A maioria das constantes como ‘pi’, ‘e’, ‘i’, deve ser apresentada ao Maxima na forma ‘%pi’ ou ‘%e’, por exemplo. Para resolver alguma equação, basta utilizar a função ‘solve’, da seguinte maneira: (%i1) solve (3*x^2–6*x-9=0); (%o1) [x = 3, x = - 1]

Esta função é bastante útil e pode ser usada de várias maneiras, como, por exemplo, resolver uma equação de duas incógnitas e deixar em função de uma delas, caso só exista uma equação. (%i1) solve(x+y-5=0, y); (%o1) [y = 5 - x] Caso contrário se o número de equações for igual ao número de incógnitas, a função ‘solve’ pode dar conta do trabalho também, como por exemplo: (%i2) solve([x+y+4*z=0, y-z+2*x=8, z+3*x-2*y=4]); 18 26 46 (%o1) [[z = - --, y = --, x = --]] 17 17 17

2.2.1 Funções

Para definirmos funções, a sintaxe utilizada no Maxima é muito parecida com à aplicada usualmente, com a única diferença no modo de atribuição, que é feita através de ‘:=” : (%i1) f(x):=x+5; (%o1) f(x) := x + 5 (%i2) f(10); (%o2) 15

Para funções de n variáveis, a sintaxe segue a mesma, explicitando essas variáveis entre virgulas na função: (%i1) g(x,y,z) := x - y + 2 * z; (%o1) g(x, y, z) := x - y + 2 z (%i2) g(1,2,3); (%o2) 5 Outro modo para definir uma função, é através do comando ‘define’: (%i6) define (H [x], sqrt (x));

7

(%o6) H := sqrt(x) x

2.2.2 Limites

Para cálculos de Limites no Máxima, utilizamos a sintaxe: limit(função, variável, valor que tende a variável, direção pela qual se aproxima do limite);

Sendo que este último parâmetro pode ser omitido, só deve ser utilizado quando se trata de Limites Laterais (daí utilizamos ‘minus’ quando esta aproximação se dá pela esquerda e ‘plus’ quando essa aproximação se dá pela direita). Símbolos especiais bastante utilizados em cálculos de Limite são: ‘inf’ (infinito positivo) e ‘minf’ (infinito negativo). Em saídas essa função pode também usar ‘und’ (undefined - não definido), ‘ind’ (indefinido mas associado) e ‘infinity’ (infinito complexo). Exemplos: (%i1) limit((t^2 + 6*t + 9)/(9 - t^2), t, -3); (%o1) 0 (%i2) limit(sin(x)/x, x, 0); (%o2) 1 (%i1) limit(1/x, x, 0, minus); (%o1) minf

2.2.3 Derivadas A diferenciação pode ser obtida, no Maxima, através da expressão: diff (função, variável, n'ésima derivada)

Para a primeira derivada, não há a necessidade da declaração do termo referente à ‘n'ésima derivada’. Exemplos: (%i1) diff(log(x), x); 1 (%o1) - x (%i2) diff(sin(x), x); (%o2) cos(x) Derivadas de ordem superiores: (%i1) f(x) := x^3+2*x^2+5*x+1; 3 2 (%o1) f(x) := x + 2 x + 5 x + 1

8

(%i2) diff(f(x), x); 2 (%o2) 3 x + 4 x + 5 (primeira derivada f´(x) ) (%i3) diff(f(x), x, 2); (%o3) 6 x + 4 (segunda derivada f´´(x)) (%i4) diff(f(x), x, 4); (%o4) 0 (quarta derivada f´´´´(x))

2.2.4 Integrais Para integrar funções no Máxima, utilizamos a função: integrate(função, variável) ;

para integrais indefinidas, e integrate(função, variável, início, fim);

para integrais com intervalos definidos, onde ‘início’ e ‘fim’ são os limites de integração. Se ‘início’ é igual a ‘fim’, integrate retorna zero. Exemplos: - Integrais indefinidas (%i1) integrate(x^3*((1 + x^4)^5), x); 4 6 (x + 1) (%o1) --------- 24 (%i2) integrate(x^2*cos(4*x^3), x); 3 sin(4 x ) (%o2) --------- 12

- Integrais definidas (%i1) integrate((1+sqrt(t))^2/sqrt(t), t, 1, 4); 38 (%o1) -- 3 (%i2) integrate(6 - x^2 -x, x, -3, 2); 125 (%o2) --- 6

No caso de funções descontínuas no intervalo dado, o programa acusará o seguinte erro: (%i1) integrate(1/x, x, -1, 0); Integral is divergent -- an error. Quitting. To debug this try debugmode(true);

9

Nesse caso utilize os recursos de limites para verificar a condição de continuidade. 2.2.5 Gráficos Os gráficos gerados pelo Maxima aparecem em um programa anexo à ele, o gnuplot graph. Para duas dimensões, a função mais utilizada para traçar os gráficos é a ‘plot2d’, que deve ser implementada da seguinte forma: plot2d(função, [eixo,início,final]);

Exemplos: (%i1) plot2d(sin(x),[x,0,2*%pi]); (%o1)

Para plotar duas funções em um mesmo gráfico, fornecemos ao programa as características de ambas, com o comando: plot2d([função1, função2], [eixo,início,final]); Como, por exemplo: (%i1) plot2d([sin(x), cos(x)], [x, -2*%pi, 2*%pi]); (%o1)

10

Para implementação de gráficos em três dimensões não é muito diferente. A função a ser usada é a ‘plot3d’, que se assemelha muito com a ‘plot2d’. plot3d(função,[eixo1,início1,fim1],[eixo2,início2, fim2]); O programa gerador de gráficos, gnuplot, permite que em gráficos de três dimensões, possa ser feito o manuseio do gráfico gerado de acordo com o usuário, bastando apenas clicar em cima do gráfico e girá-lo ao seu gosto, podendo assim obter a perspectiva que achar melhor. Você pode também remanejar a escala, bastando apenas clicar com o botão 3 (o do meio) do mouse. Exemplo: (%i1) plot3d(x^2+y^2,[x,-2,2],[y,-2,2]); (%o1)

11

(%i2) plot3d(cos[(y)*(x)],[x,-2,2],[y,-2,2]); (%o2)

Rotacionando o gráfico:

12

Rotacionando o gráfico novamente:

Várias particularidades do gráfico, como escala, cores, etc, podem ser modificadas através de comandos na própria linha de comando. Esses são os principais comandos para a manipulação de dados no Maxima. Agora, abordaremos os comandos específicos para uso em problemas propostos em Cálculo III.

13

3.1 Solução de Equações Diferenciais e Sistemas

Em matemática, uma equação diferencial é uma equação cuja incógnita é uma função que aparece na equação sob a forma das respectivas derivadas.

As equações diferenciais dividem-se em dois tipos:

• Uma equação diferencial ordinária (EDO) contém apenas funções de uma variável e derivadas daquela mesma variável.

• Uma equação diferencial parcial (EDP) contém funções com mais do que uma variável e suas derivadas parciais.

A ordem da equação diferencial é a ordem da mais alta derivada da função incógnita que ocorre na equação. Grau é o valor do expoente para a derivada mais alta da equação, quando a equação tem a forma de um polinômio na função incógnita e em suas derivadas.

Uma Equação Diferencial Ordinária é uma equação da forma:

F(x,y'(x),y"(x),y'''(x), ... ,y(n)(x)) = 0

envolvendo uma função incógnita y=y(x) e suas derivadas ou suas diferenciais. x é a variável independente e y é a variável dependente.

Se a função F depende linearmente da variável y(x), ela é chamada de equação linear de ordem n (primeira, segunda, terceira, n’-ésima, etc).

Iniciaremos pelo estudo das equações diferenciais de primeira ordem.

No Cálculo III aprendemos varias maneiras de resolver uma equação diferencial de primeira ordem. Cada método tem suas facilidades e se tornam úteis de acordo com o tipo de equação dada. Entre elas, as Equações Separáveis, Homogêneas, Exatas e Lineares e Não-Lineares.

Tomemos um exemplo:

dy/dx + 2y = 3

14

Declaramos no Máxima o termo ‘dy/dx’ através do comando ‘diff(y,t). Logo, temos:

(%i1) 'diff(y,x)+ 2*y = 3; dy (%o1) -- + 2 y = 3 dx

Para resolvermos equações diferenciais ordinárias de primeira ou até mesmo de segunda ordem, utilizamos a função ‘ode2’. Este comando é declarado da seguinte forma:

ode2 (EDO, variável dependente, variável independente)

Quando obtém sucesso, retorna uma solução (explícita ou implícita) para a variável dependente. ‘%c’ é usado para representar a constante, no caso de equações de primeira ordem. Se ‘ode2’ não pode obter a solução por alguma razão, retorna ‘false’, seguido, às vezes, de uma mensagem de erro. O método implementado para equações diferenciais de primeira ordem na seqüência na qual eles são testados são: linear, separável, exato - talvez requerendo um fator de integração, homogêneos, equação de Bernoulli, e um método homogêneo geral. Aplicando, temos:

(%i2) ode2(%,y,x); 2 x

- 2 x 3 %e (%o2) y = %e (------- + %c) 2

Nessas horas, se faz útil o uso de um comando, o ‘ratexpand’. Este comando expande a expressão dada, multiplicando para fora produtos de somas e somas exponenciadas, combinando frações sobre um denominador comum, cancelando o máximo divisor comum entre o numerador e o denominador, então quebrando o numerador (se for uma soma) dentro de suas respectivas parcelas divididas pelo denominador. Ela retorna uma expressão geral da expressão dada. Então, aplicando-o:

(%i3) ratexpand (%); - 2 x 3 (%o3) y = %c %e + - 2

Em outros casos, outro comando pode deixar a solução de uma forma mais apresentável. O comando é o ‘ratsimp’, que simplifica a expressão dada e todas as suas subexpressões, incluindo os argumentos para funções não racionais. Nesse caso, vemos que o comando não ajuda muito:

15

(%i4) ratsimp (%); - 2 x 2 x %e (3 %e + 2 %c) (%o4) y = ------------------------ 2

Essa é uma solução geral para a equação diferencial dada. Se tivermos um valor da função em um ponto qualquer, podemos determinar o valor da constante ‘c’ obtida. Esse valor é chamado de condição inicial e a equação diferencial junto com a condição inicial forma um problema de valor inicial (PVI).

Vamos aplicar um PVI ao Maxima. Tomando a solução dada, vamos aplicar o valor y(0)= 0. A função utilizada para resolver PVI é ‘ic1’ (para PVI de segunda ordem, utiliza-se o comando ‘ic2’). A sintaxe do comando é:

ic1 (solução geral, valor da variável independente, valor da variável dependente)

Os valores das variáveis independente e dependente são colocados na forma x = x0 e y = y0. Então:

(%i5) ic1 (%o4, x=0, y=0); - 2 x 2 x %e (3 %e - 3) (%o5) y = --------------------- 2 (%i6) ratexpand (%); - 2 x 3 3 %e (%o6) y = - - --------- 2 2

Vamos aplicar outro exemplo, agora com uma equação homogênea:

dy/dx = (x² - 3y²) / 2xy y(1) = 0

(%i1) 'diff(y,x) = (x^2 - 3*y^2) / (2*x*y); 2 2 dy x - 3 y (%o1) -- = --------- dx 2 x y

16

(%i2) ode2(%,y,x); 3 2 5 5 x y - x (%o2) ------------ = %c 5 (%i3) ratexpand (%); 5 3 2 x (%o3) x y - -- = %c 5 (%i4) ic1 (%o3, x=1, y=0); 3 2 5 5 x y - x 1 (%o4) ------------ = - - 5 5

Para as equações diferenciais de segunda ordem, o processo não é muito diferente. Também utilizamos a função ‘ode2’ que, quando obtém sucesso, retorna uma solução (explícita ou implícita) para a variável dependente com ‘%k1’ e ‘%k2’ como constantes. O método implementado para equações diferenciais de segunda ordem na seqüência na qual eles são testados são: coeficiente constante, exato, linear homogêneo com coeficientes não-constantes os quais podem ser transformados para coeficientes constates, o Euler ou equação equidimensional, o método de variação de parâmetros, e equações as quais são livres ou da variável independente ou da dependente de modo que elas possam ser reduzidas duas equações lineares de primeria ordem para serem resolvidas seqüêncialmente. Vejamos um exemplo:

4y´´ - 8y´ + 3y = 0 y(0) = 2, y´(0) = ½

Para derivadas de ordem superior, o comando ‘diff(y,t) necessitada ser aplicado citando a grau da derivada, sendo aplicado da forma ‘diff(y,t,n). Nesse caso temos uma segunda derivada da função, logo:

(%i1) 4*'diff(y,x,2) - 8*'diff(y,x) + 3*y = 0; 2 d y dy (%o1) 4 --- - 8 -- + 3 y = 0 2 dx dx (%i2) ode2(%,y,x); 3 x --- 2 x/2 (%o2) y = %k1 %e + %k2 %e

17

Como o problema sugerido é um PVI de segunda ordem, a função utilizada para resolve-lo é ‘ic2’. Este possui um parâmetro a mais que o ‘ic1’ utilizado para as equações de primeira ordem. A sintaxe do comando é:

ic2 (solução geral, valor da variável independente, valor da variável dependente, valor da derivada da variável dependente com relação à variável independente avaliada no ponto do segundo parâmetro)

Aplicando, temos:

(%i3) ic2(%o2,x=0,y=2,'diff(y,x)=1/2); 3 x --- x/2 2 5 %e %e (%o3) y = ------- - ----- 2 2

Muitas vezes, uma só equação diferencial não é suficiente para expressar um fenômeno a ser analisado. Quando o problema envolve duas ou mais equações associadas de determinada maneira, nos utilizamos um sistema de equações diferenciais, que com certa manipulação, sempre podem ser escritas como equações de primeira ordem.

Vamos realizar um exemplo. Vamos calcular duas funções, f(x) e g(x), que satisfazem o sistema. Tomamos um sistema de duas equações:

dg(x) / dx + d²f(x) / dx² + 3 f(x) = 15ex f(0) = 35 f´(0) = -48 d²g(x) / dx² - 4 [df(x) / dx] + 3 g(x) = 15 sen (2x) g(0) = 27 g´(0) = -55 Primeiro definimos as equações. Atribuiremos o conteúdo delas à variáveis, para facilitar o uso destas durante todo o processo: (%i1) diff_eq1: 'diff(f(x),x,2) + 'diff(g(x),x) + 3*f(x) = 15*exp(-x); 2 d d - x (%o1) -- (g(x)) + --- (f(x)) + 3 f(x) = 15 %e dx 2 dx (%i2) diff_eq2: 'diff(g(x), x, 2) - 4*'diff(f(x), x) + 3*g(x) = 15*sin(2*x);

18

2 d d (%o2) --- (g(x)) - 4 (-- (f(x))) + 3 g(x) = 15 sin(2 x) 2 dx dx Agora formaremos um sistema com estas equações. Chamaremos-o de sistema: (%i3) sistema: [diff_eq1, diff_eq2]; 2 d d - x (%o3) [-- (g(x)) + --- (f(x)) + 3 f(x) = 15 %e , dx 2 dx 2 d d --- (g(x)) - 4 (-- (f(x))) + 3 g(x) = 15sin(2 x)] 2 dx dx

Agora, para atribuirmos os valores desse PVI, utilizaremos o comando ‘atvalue’. Este possui a sintaxe:

atvalue (função, [x_1 = a_1, ..., x_m = a_m], valor)

Então:

(%i4) atvalue (f(x), x=0, 35); (%o4) 35 (%i5) atvalue ('diff(f(x),x),x=0, -48); (%o5) - 48 (%i6) atvalue (g(x), x=0, 27); (%o6) 27 (%i7) atvalue ('diff(g(x), x), x=0, -55); (%o7) - 55

Agora, aplicaremos a função ‘desolve’, que é a função que resolve sistemas de equações diferenciais ordinárias lineares. A sintaxe do comando é:

desolve ([n equações diferenciais (ou o sistema)], [n variáveis dependentes])

19

Com ela obtemos, na saída, a resolução do sistema proposto:

(%i10) desolve(ode_syst, [f(x), g(x)]); - x (%o10) [f(x) = - 15 sin(3 x) + 2 cos(2 x) + 30 cos(x) + 3 %e , - x g(x) = 30 cos(3 x) + sin(2 x) - 60 sin(x) - 3 %e ]

20

3.2 Campos de Direções e Trajetórias

Campos de Direções são ferramentas úteis no estudo de soluções de equações diferenciais da forma:

dy/dt = f (t, y)

onde f é uma função dada de duas variáveis, t e y, algumas vezes chamada de função de taxa de variação.

Um Campo de Direções útil pode ser construído calculando-se f em cada ponto de uma malha retangular consistindo em, pelo menos, algumas centenas de pontos. Então, em cada ponto da malha desenha-se um pequeno segmento de reta cujo coeficiente angular (y’=dy/dx) é o valor da função f naquele ponto. Dessa forma, cada segmento de reta é tangente ao gráfico de uma solução contendo aquele ponto. Um campo de direções desenhado em uma malha razoavelmente fina fornece uma boa idéia do comportamento global das soluções de uma equação diferencial. A construção de um campo de direções é, muitas vezes, um primeiro ponto bastante útil na investigação sobre uma equação diferencial.

O comando utilizado para criar um Campo de Direções em duas dimensões, é o ‘plotdf’. Sua sintaxe é:

plotdf ([derivada(s)(coeficiente angular)], opções)

Antes de aplicar tal comando, sempre devemos aplicar o comando ‘load("plotdf")’ para assim disponibilizar o uso de gráficos de campo de direções. O ‘plotdf’ pode ser dado realizado sem as opções citadas. Mostramos um exemplo:

(%i1) load("plotdf")$ (%i2) plotdf(exp(-x)*y); (%o2)

21

Essas opções dadas dentro do comando, também podem ser incorporadas no menu que aparecerá quando o canto superior esquerdo da janela do gráfico. Essas opções contêm uma lista de dois ou mais artigos. O primeiro artigo é o nome da opção e o restante compreende o valor ou os valores atribuído à opção. As opções que são reconhecidas pelo ‘plotdf’ são as seguintes:

• tstep: define o comprimento dos incrementos na variável independente, usado computar uma curva integral.

Ex: [tstep,0.05]

O valor de default é 0.1;

• nsteps: definem o número das etapas do ‘tstep’ que serão usadas para a variável independente, para computar uma curva integral.

Ex: [nsteps, 300]

O valor de default é 100;

• direction: define o sentido da variável independente, que será seguida para computar uma curva integral. Os valores possíveis são ‘forward’, que faz com que a variável independente incremente o ‘nsteps’ ao mesmo tempo que incrementa o ‘tstep’; ‘backward’, que faz a diminuição da variável independente, ou ‘both’ que conduzirão uma curva integral que estenda ‘nsteps’ para a frente e para trás.

22

Os comandos ‘right’ e ‘left’ podem ser usados com as mesmas finalidades de ‘forward’ e ‘backward’.

Ex: [direction,forward]

O valor de default é ‘both’.

• tinitial: define o valor inicial da variável t, utilizada para computar as curvas integrais.

Ex: [tinitial,2.7]

O valor de default é 0.

• versus_t: é usado criar uma segunda janela de plotagem, com um lote de curva integrais, como duas funções x, y, em função a variável independente t. Se o ‘versus_t’ for dado algum valor diferente de 0, a segunda janela será aberta. A segunda janela do lote inclui um outro menu, similar ao menu da janela principal do lote.

Ex: [versus_t, 1]

(%i3) plotdf(exp(-x)*(-y),[versus_t,1]); (%o3)

23

O valor de default é 0.

• trajectory_at: define as coordenadas x-inicial e y-inicial para o ponto inicial de uma curva integral.

Ex: [trajectory_at, 0.1, 2.2]

O valor de default é empty.

24

• parameters: define uma lista de parâmetros, e seus valores numéricos, usados na definição das equações diferenciais. O nome e os valores dos parâmetros devem ser dados em uma expressão, separando por virgulas, e aos pares com ‘nome=valor’.

Ex: [parâmetros, “k=1.1, m=2.5”];

• sliders: define uma lista de parâmetros que serão alterados interativamente e a escala de variação desses parâmetros. Os nomes e as escalas dos parâmetros devem ser dados em uma expressão na seqüência, separada por virgulas, e na forma: nome = valor mínimo: valor máximo

Ex: [sliders,"k=0:5,m=1:3"]

• xradius e yradius: é metade do comprimento da escala dos valores que serão mostrados no sentido de x, para ‘xradius’, e y, para ‘yradius’.

Ex: [xradius, 17.5]

O valor de default é 10, para ambos;

• xcenter e ycenter: determinam a coordenada x (xcenter) e y (ycenter) do centro da plotagem

Ex: [ycenter, 2.5]

O valor de default é 0, para ambos;

• width e height: definem a largura (width) e a altura (height) da janela de plotagem do gráfico (valores em pixels).

Ex: [widht, 800]

O valor de default é 500, para ambos;

Agora tomaremos exemplos, englobando os comandos dados:

(%i4) plotdf(4*x-y^2,[xfun,"sqrt(x);-sqrt(x)"], [trajectory_at,-1,3], [direction,forward],[yradius,5], [xcenter,6]); (%o4)

25

(%i5) plotdf([y,-k*x/m],[parameters,"m=2,k=6"], [sliders,"m=1:5"], [trajectory_at,5,0]); (%o5)

Variando ‘m’ de 1 a 5, na barra no canto inferior esquerdo, temos:

26

(%i9) plotdf([y,-g*cos(x)/l - b*y/m/l], [parameters,"g=9.8,l=0.5,m=0.3,b=0.05"],

[trajectory_at,1.05,-9],[tstep,0.01],

[xradius,6],[yradius,14],

[xcenter,-4],[direction,forward],[nsteps,300],

[sliders,"m=0.1:1"], [versus_t,1]);

(%o9)

27

28

3.3 Solução de Equações Diferenciais por Transformadas de Laplace

Uma das principais ferramentas na resolução de equações diferenciais ordinárias é a Transformada de Laplace. Ela é definida como:

O princípio é simples:

• A equação diferencial é associada a uma equação linear algébrica. • A equação da associação é resolvida. • A solução da equação algébrica é associada de volta sobre a solução da equação

diferencial dada.

Para resoluções de EDO’s no Maxima pelo método de Transformada de Laplace existe um comando especial para a tranformada e para a Transformada Inversa de Laplace.

Para a Transformada de Laplace, usamos:

laplace (função, variável, parâmetro de transformação)

e para a Tranformada Inversa de Laplace:

ilt (função, variável, parâmetro de transformação)

‘laplace’ reconhece em função as funções delta, exp, log, sin, cos, sinh (seno hiperbólico), cosh (co-seno hiperbólico), também derivative, integrate, sum (somatório), e ilt. Se algumas outras funções estiverem presente, Laplace pode não ser habilitada a calcular a transformada. função pode também ser uma equação linear, diferencial de coeficiente constante no qual caso o ‘atvalue’ da variável dependente é usado. O requerido ‘atvalue’ pode ser fornecido ou antes ou depois da transformada ser calculada. Uma vez que as condições iniciais devem ser especificadas em zero, se um teve condições de limite impostas em qualquer outro lugar ele pode impor essas sobre a solução geral e eliminar as constantes resolvendo a solução geral para essas e substituindo seus valores de volta.

29

Existe uma tabela com as principais Transformadas de Laplace. Vamos testar os comando com estas transformadas conhecidas, para verificar sua eficácia:

(%i1) laplace (sin (5*t), t, s); 5 (%o1) ------- 2 s + 25

(%i2) laplace (%e^(-3*t), t, s); 1 (%o2) ----- s + 3

Agora, vamos fazer um exemplo de aplicação da Transformada de Laplace em uma EDO:

y´´ + y´ = sen 2t y(0) = 2, y´(0) = 1. (%i1) edo: 'diff(y(t), t, 2) + 'diff(y(t), t) = sin(t); 2 d d (%o1) --- (y(t)) + -- (y(t)) = sin(t) 2 dt dt

A seguir, especificamos as condições iniciais. Fazemos isso, novamente, com a função ‘atvalue’:

(%i2) atvalue(y(t), t=0, 2); (%o2) 2 (%i3) atvalue('diff(y(t), t), t= 0, 1); (%o3) 1

30

Agora vamos calcular a transformada de Laplace da EDO:

(%i4) lap_edo:laplace(edo,t,s); 2 1 (%o4) s laplace(y(t), t, s) + s laplace(y(t), t, s) - 2 s - 3 = ---- 2 s + 1

Obtivemos na saída uma equação linear na desconhecida laplace(y(t), t, s). Resolveremos esta com o comando ‘solve’:

(%i5) sol: solve(%, 'laplace(y(t), t, s)); 3 2 2 s + 3 s + 2 s + 4 (%o5)[laplace(y(t), t, s) = ---------------------] 4 3 2 s + s + s + s

É importante não se esquecer de tem denotar a desconhecida com um apóstrofo. Sem o apóstrofo, o Maxima tentará resolver a expressão laplace(y(t), t, s).

Agora, podemos aplicar a Transformada Inversa de Laplace. Para aplicar uma transformação aos elementos de uma lista, temos que usar o comando map:

(%i6) map( lambda( [eq], ilt(eq, s, t)), sol); - t sin(t) cos(t) 3 %e (%o6) [y(t) = - ------ - ------ - ------- + 4] 2 2 2

Transformadas de Laplace também podem ser aplicadas à sistemas de EDO’s. Vamos tomar o mesmo sistema resolvido em 3.1.1 e aplicar a Transformada de Laplace na resolução e verificar se o resultado obtido foi o mesmo: dg(x) / dx + d²f(x) / dx² + 3 f(x) = 15ex f(0) = 35 f´(0) = -48 d²g(x) / dx² - 4 [df(x) / dx] + 3 g(x) = 15 sen (2x) g(0) = 27 g´(0) = -55 Antes de tudo, vamos avisar ao Máxima que o ‘s’ da Transformada é positivo, para evitar complicações futuras (não avisando, ele pode errar no calculo ou, apenas, perguntar futuramente quais valores ‘s’ pode possuir). (%i1) assume(s>0); (%o1) [s > 0]

31

Agora definimos as equações, atribuiremos o conteúdo delas à variáveis, como feito anteriormente: (%i2) diff_eq1: 'diff(f(x),x,2) + 'diff(g(x),x) + 3*f(x) = 15*exp(-x); 2 d d - x (%o2) -- (g(x)) + --- (f(x)) + 3 f(x) = 15 %e dx 2 dx (%i3) diff_eq2: 'diff(g(x), x, 2) - 4*'diff(f(x), x) + 3*g(x) = 15*sin(2*x); 2 d d (%o3) --- (g(x)) - 4 (-- (f(x))) + 3 g(x) = 15 sin(2 x) 2 dx dx

Atribuindo valores do PVI:

(%i4) atvalue (f(x), x=0, 35); (%o4) 35 (%i5) atvalue ('diff(f(x),x),x=0, -48); (%o5) - 48 (%i6) atvalue (g(x), x=0, 27); (%o6) 27 (%i7) atvalue ('diff(g(x), x), x=0, -55); (%o7) - 55

Já podemos calcular as Transformadas de Laplace: (%i8) lap_eq1:laplace(diff_eq1,x,s); 2 (%o8) s laplace(g(x), x, s) + s laplace(f(x), x, s) + 3 laplace(f(x), x, s) 15 - 35 s + 21 = ----- s + 1 (%i9) lap_eq2:laplace(diff_eq2,x,s); 2 (%o9) s laplace(g(x), x, s) + 3 laplace(g(x), x, s) 30 - 4 (s laplace(f(x), x, s) - 35) - 27 s + 55 = ----- 2 s + 4

32

Essas são duas equações lineares nas desconhecidas laplace(f(x),x, s) e laplace(g(x), x, s). Resolvemos isso com linsolve (possui a mesma função do ‘solve’, mas agora aplicado à sistemas de equações): (%i10) linsolve([lap_eq1,lap_eq2],['laplace(f(x),x,s),'laplace(g(x),x,s)]); (%o10) [laplace(f(x), x, s) = 6 5 4 3 2 35 s - 13 s + 407 s + 185 s + 1020 s + 918 s - 72 ------------------------------------------------------, 7 6 5 4 3 2 s + s + 14 s + 14 s + 49 s + 49 s + 36 s + 36 6 5 4 3 2 27 s - 28 s + 50 s - 610 s - 787 s - 2022 s - 2250 laplace(g(x), x, s) = ----------------------------------------------] 7 6 5 4 3 2 s + s + 14 s + 14 s + 49 s + 49 s + 36 s + 36

Os denominadores das soluções são polinômios em ‘s’ de grau 7. O cálculo da inversa da Transformação de Laplace não realiza tal cálculo. Ele necessita que os denominadores sejam decompostos em fatores lineares e quadráticos. A função ilt não fatora sempre denominadores, então fazemos isso como o comando apropriado para a fatoração, o ‘factor’: (%i11) fatorada: map(lambda( [eq], factor(eq)), %); (%o11) [laplace(f(x), x, s) = 6 5 4 3 2 35 s - 13 s + 407 s + 185 s + 1020 s + 918 s - 72 ------------------------------------------------------, 2 2 2 (s + 1) (s + 1) (s + 4) (s + 9) 6 5 4 3 2 27 s - 28 s + 50 s - 610 s - 787 s - 2022 s – 2250 laplace(g(x), x, s) = ----------------------------------------------] 2 2 2 (s + 1) (s + 1) (s + 4) (s + 9) Agora, através da Transformação Inversa de Laplace em ambas equações, obtemos:

33

(%i12) sol: map(lambda( [eq], ilt(eq, s, x)), fatorada); - x (%o12) [f(x) = - 15 sin(3 x) + 2 cos(2 x) + 30 cos(x) + 3 %e , - x g(x) = 30 cos(3 x) + sin(2 x) - 60 sin(x) - 3 %e ] Que foi a mesma expressão obtida anteriormente, o que mostra a eficácia do método.

34

3.4 Solução de Equações Diferenciais por Séries Outro método para resolução de equações diferenciais ordinárias é realizando a expansão dessas equações em séries de potencia. Fazemos isso, substituindo a função incógnita procurada por uma série de potencias do tipo:

y = a0 + a1 (x – x0) + ... + an (x – xn)n + ...

No Maxima, o comando utilizado para expandir uma expressão em expansão de séries de potência é o ‘powerseries’. Sua sintaxe é da forma: powerseries (função, variável, ponto singular)

Tomando um exemplo: (%i1) powerseries (cos(x)/x, x, 0); In the first simplification we have returned: cos(x) ------ x trying to do a rational function expansion of 1 - x inf ==== i10 2 i10 \ (- 1) x > --------------- / (2 i10)! ==== i10 = 0 (%o1) ----------------------- x

Se o ‘powerseries’ é incapaz de expandir a função dada, nos utilizamos de outro comando: ‘taylor’, que apresenta os primeiros muitos termos da série. A sintaxe de Taylor é: taylor (função, variável, ponto singular, número de termos)

Exemplo:

35

(%i2) taylor (sqrt (tan(x) + a*x + 10), x, 0, 3); (sqrt(10) a + sqrt(10)) x (%o2)/T/ sqrt(10) + ------------------------- 20 2 2 (sqrt(10) a + 2 sqrt(10) a + sqrt(10)) x - ------------------------------------------ 800 3 2 3 (3 sqrt(10) a + 9 sqrt(10) a + 9 sqrt(10) a + 803 sqrt(10)) x + ---------------------------------------------------------------- + 48000 . . . Assim, substituindo a equação dada por sua expansão em série, e em seguida, aplicando os métodos de resolução de equações citados, podemos obter facilmente soluções para os problemas apresentados. Assim, encontramos uma infinidade de maneiras de manipulação com as euqações diferenciais.

36

4.1 Bibliografia e Links Consultados

��Equações Diferenciais Elementares e Problemas de Valores de Contorno Boyce, William E. e DiPrima, Richard C. Sétima Edição LTC Editora

��Maxima Tutorial: http://maxima.sourceforge.net/docs/tutorial/pt/gaertner-tutorial-revision/Contents.htm

��Manual do Maxima: http://maxima.sourceforge.net/docs/manual/pt/maxima.html

��Laplace no Mathematica: http://www.ime.unicamp.br/~marcio/ps2006/lap/laprace.html

��Matemática Essencial: Superior: Roteiro Geral:

http://pessoal.sercomtel.com.br/matematica/superior/superior.htm

��Links na Wikipédia: http://pt.wikipedia.org/