curso7.mw

Capítulo 7  Equações Diferenciais Ordinárias (EDOs) 

Introdução 

O  comando dsolve é o principal comando para resolver analiticamente equações diferenciais ordinárias. As páginas do help on line estão bem escritas, especialmente as páginas dsolve/details , e muito do que segue abaixo está diretamente baseado nelas. A sintaxe do comando dsolve é 

 

    dsolve(EDO) 

    dsolve(EDO, y(x), extra_args) 

 

onde  

 

     EDO é uma equação diferencial ordinária 

     y(x) é uma função indeterminada de um única variável 

     extra_args é um ou mais argumentos opcionais que dependem do tipo de problema a ser resolvido 

 

Para resolver uma  equação diferencial ordinária com condições iniciais 

 

    dsolve({EDO, CI's}, y(x), extra_args) 

 

onde CI's são as condicões iniciais. Para resolver um sistema de  equações diferenciais ordinárias 

 

    dsolve({seq_de_EDOs, CI's}, {y(x), z(x), ...}, extra_args) 

 

onde  

    seq_de_EDOs é um conjunto de EDO's 

    {y(x), z(x), ...}  é um conjunto de funções indeterminadas de uma única variável 

 

Por exemplo, vamos usar a seguinte equação diferencial ordinária não linear de segunda ordem como exemplo: 

> restart

> EDO := `+`(`*`(`^`(x, 4), `*`(diff(y(x), x, x))), `*`(`^`(`+`(`*`(x, `*`(diff(y(x), x))), `-`(y(x))), 3))) = 0
`+`(`*`(`^`(x, 4), `*`(diff(diff(y(x), x), x))), `*`(`^`(`+`(`*`(x, `*`(diff(y(x), x))), `-`(y(x))), 3))) = 0 (1.1.1)
 

Uma outra maneira equivalente de digitar esta EDO é 

> EDO := `+`(`*`(`^`(x, 4), `*`(diff(y(x), x, x))), `*`(`^`(`+`(`*`(x, `*`(diff(y(x), x))), `-`(y(x))), 3)))
`+`(`*`(`^`(x, 4), `*`(diff(diff(y(x), x), x))), `*`(`^`(`+`(`*`(x, `*`(diff(y(x), x))), `-`(y(x))), 3))) (1.1.2)
 

Nesta forma, diversas nuances foram assumidas, fica a cargo do usuário verificar se a entrada está correta. Note que temos que dar um espaço entre x e diff(y(x), x) caso contrário teríamos  

> diff(xy(x), x)
diff(xy(x), x) (1.1.3)
 

que é uma nova variável de nome xy que foi diferenciada e que pode confudir diversos usuários que podem ficar reclamando do Maple. Esta EDO é resolvida explicitamente com o simples comando 

> sol := dsolve(EDO)
y(x) = `*`(`+`(`-`(arctan(`/`(1, `*`(`^`(`+`(`*`(_C1, `*`(`^`(x, 2))), `-`(1)), `/`(1, 2)))))), _C2), `*`(x)), y(x) = `*`(`+`(arctan(`/`(1, `*`(`^`(`+`(`*`(_C1, `*`(`^`(x, 2))), `-`(1)), `/`(1, 2)))))... (1.1.4)
 

Note que a resposta é uma sequência de dois operandos cujos tipos são equações. Vamos verificar que o primeiro operando da sequência de fato é solução. 

> simplify(algsubs(sol[1], EDO))
0 (1.1.5)
 

Observe a presença das duas constates arbitrárias _C1 e _C2. Essa constantes são determinadas pelas condições iniciais. Por exemplo, se as condições iniciais são 

> CI := y(1) = 1.3, (D(y))(1) = 3.4
y(1) = 1.3, (D(y))(1) = 3.4 (1.1.6)
 

então a sintaxe nesse caso é  

> sol2 := dsolve({CI, EDO}, y(x))
y(x) = `*`(`+`(`-`(arctan(`/`(1, `*`(`^`(`+`(`*`(`/`(541, 441), `*`(`^`(x, 2))), `-`(1)), `/`(1, 2)))))), `/`(13, 10), arctan(`/`(21, 10))), `*`(x)) (1.1.7)
 

Neste caso a solução é única. Novamente vamos verificar que a solução está correta (compare com o comando odetest). 

> simplify(algsubs(sol2, EDO)); 1; evalf(algsubs(x = 1, sol2), 2); 1; evalf((D(map(unapply, sol2, x)))(1), 2)
 

 

0
y(1) = 1.3
(D(y))(1) = 3.4 (1.1.8)
 

No último comando, mapeamos o comando unapply porque sol2 é uma equação, obtivemos uma equação de funções (em vez de expressões algébricas). O comando D, quando aplicado a uma equação, é mapeado automaticamente, explicando o porquê de não usar map. Uma alternativa correta para obter o mesmo resultado é 

> evalf((map(`@`(D, unapply), sol2, x))(1))
(D(y))(1) = 3.400000000 (1.1.9)
 

O sistema não linear de EDO's 

> sistema := {diff(f(x), x) = g(x), diff(g(x), x) = `+`(`-`(exp(f(x)))), diff(h(x), x, x) = `/`(`*`(g(x)), `*`(f(x)))}
{diff(diff(h(x), x), x) = `/`(`*`(g(x)), `*`(f(x))), diff(f(x), x) = g(x), diff(g(x), x) = `+`(`-`(exp(f(x))))} (1.1.10)
 

é resolvido da seguinte forma 

> dsolve(sistema, {f(x), g(x), h(x)})
[{g(x) = `/`(`*`(tan(`+`(`/`(`*`(`/`(1, 2), `*`(`+`(x, _C4), `*`(`^`(2, `/`(1, 2))))), `*`(_C3)))), `*`(`^`(2, `/`(1, 2)))), `*`(_C3))}, {f(x) = ln(`+`(`-`(diff(g(x), x))))}, {h(x) = `+`(Int(Int(`/`(`... (1.1.11)
 

Note que a solução explícita só foi dada para a função g(x), enquanto que f(x) é determinada a partir de g(x) (h(x) a partir de f(x) e g(x)). Para obter a solução explícita de todas as funções, o parâmetro explicit deve ser repassado como terceiro argumendo do comando dsolve . 

 

A solução de uma EDO de ordem n (ordem da derivada mais alta) é dita geral se ela possui n constantes arbitrárias. Se a EDO for linear, a solução geral fornece todas as soluções possíveis. Se a EDO for não-linear, podem existir soluções especiais (ditas singulares) que não são obtidas da solução geral para quaisquer valores das constantes arbitrárias. 

Método de Classificação 

Uma das primeiras tentativas do comando dsolve é determinar se a EDO tem uma forma já classificada de acordo com os livros da área, em especial os livros Kamke[Ref], Murphy[Ref] e  Zwillinger[Ref].  As EDO's de primeira ordem estão classificadas no Maple ( ?odeadvisor,types ) como 

 

Abel ,           Abel2A ,         Abel2C ,         Bernoulli ,     Chini ,        
Clairaut ,       dAlembert ,      exact ,          homogeneous ,   homogeneousB ,
homogeneousC ,   homogeneousD ,   homogeneousG ,   linear ,        patterns ,     
quadrature ,     rational ,       Riccati ,        separable                     

 

As EDO's de segunda ordem (ou de outra ordem qualquer) estão classificaficadas como 

 

Bessel ,       Duffing ,        ellipsoidal ,       elliptic ,     Emden ,      
erf ,          exact_linear ,   exact_nonlinear ,   Gegenbauer ,   Halm ,       
Hermite ,      Jacobi ,         Lagerstrom ,        Laguerre ,     Lienard ,    
Liouville ,    linear_ODEs ,    missing ,           Painleve ,     quadrature ,
reducible ,    Titchmarsh ,     Van_der_Pol                                   

 

A classificação de uma EDO é feita com o comando odeadvisor do pacote DEtools . 

> with(DEtools, odeadvisor)
[odeadvisor] (1.2.1)
 

EDO's de ordem 1 

 

Uma EDO de primeira ordem é dita separable se ela tem a forma 

diff(y(x), x) = `*`(f(x), `*`(g(y(x)))) 

A solução geral é 

`+`(Int(f(x), x), `-`(Intat(`/`(1, `*`(g(_a))), _a = y(x))), _C1) = 0 

A  EDO 

> separable_EDO := `*`(exp(`+`(y(x), sin(x))), `*`(diff(y(x), x))) = 1
`*`(exp(`+`(y(x), sin(x))), `*`(diff(y(x), x))) = 1 (1.2.1.1)
 

é separável. Podemos confirmar com o comando odeadvisor .  

> odeadvisor(separable_EDO)
[_separable] (1.2.1.2)
 

A solução é  

> dsolve(separable_EDO)
y(x) = ln(`+`(Int(exp(`+`(`-`(sin(x)))), x), _C1)) (1.2.1.3)
 

A EDO de Bernoulli é da forma 

diff(y(x), x) = `+`(`*`(A, `*`(y(x))), `*`(B, `*`(`^`(y(x), c)))) 

onde A e B são funções de x e c é uma constante. Por exemplo, a EDO 

> Bernoulli_EDO := diff(y(x), x) = `+`(`*`(x, `*`(y(x))), `*`(`^`(y(x), `/`(1, 2))))
diff(y(x), x) = `+`(`*`(x, `*`(y(x))), `*`(`^`(y(x), `/`(1, 2)))) (1.2.1.4)
 

é do tipo Bernoulli  

> odeadvisor(Bernoulli_EDO)
[_Bernoulli] (1.2.1.5)
 

e tem a seguinte solução geral 

> dsolve(Bernoulli_EDO)
`+`(`*`(`^`(y(x), `/`(1, 2))), `-`(`/`(`*`(`+`(`*`(`/`(1, 2), `*`(`^`(Pi, `/`(1, 2)), `*`(erf(`+`(`*`(`/`(1, 2), `*`(x))))))), _C1)), `*`(exp(`+`(`-`(`*`(`/`(1, 4), `*`(`^`(x, 2)))))))))) = 0 (1.2.1.6)
 

 

EDO's de ordem 2 ou maior 

Uma EDO é linear se ela é da forma, 

 

F(x) = `+`(`*`(A, `*`(y(x))), `*`(B, `*`(diff(y(x), x))), `*`(C, `*`(diff(y(x), x, x))), `*`(` D`, `*`(diff(y(x), x, x, x))), `...`) 

onde A, B, C, D, ... são funções de x. Se F(x) = 0, a EDO é dita linear e homogênea. Se os coeficientes forem constantes, dsolve é capaz de achar a solução geral da equação homogênea. Por exemplo a EDO 

> linear_EDO := `+`(diff(y(x), `$`(x, 4)), `*`(a, `*`(diff(y(x), `$`(x, 3)))), `*`(b, `*`(diff(y(x), `$`(x, 2)))), `*`(c, `*`(diff(y(x), x))), `*`(d, `*`(y(x)))) = 0
`+`(diff(diff(diff(diff(y(x), x), x), x), x), `*`(a, `*`(diff(diff(diff(y(x), x), x), x))), `*`(b, `*`(diff(diff(y(x), x), x))), `*`(c, `*`(diff(y(x), x))), `*`(d, `*`(y(x)))) = 0 (1.2.2.1)
 

tem a seguinte solução geral 

> dsolve(linear_EDO)
y(x) = Sum(`*`(exp(`*`(RootOf(`+`(`*`(`^`(_Z, 4)), `*`(`^`(_Z, 3), `*`(a)), `*`(`^`(_Z, 2), `*`(b)), `*`(_Z, `*`(c)), d), index = _a), `*`(x))), `*`(_C[_a])), _a = 1 .. 4) (1.2.2.2)
 

O índice _R do somatório acima é assume os valores das raízes de um polinômio de quarta ordem. Para se obter o resultado explícito, é necessário dar o comando _EnvExplicit:=true (veja solve ). Para EDO's de ordem acima de 4, não é mais possível expandir o somatório que aparece na solução. Se a equação não for homogênea, a solução geral é a solução da parte homogênea mais uma solução particular. Se os coeficientes dependem de x, a EDO não pode ser integrada de forma genérica (veja linear_ODEs para mais detalhes). 

 

Uma ODE é dita missing se ela tem uma das formas 

F(x, diff(y(x), x), diff(y(x), x, x), diff(y(x), x, x, x), `...`) = 0 

ou 

F(y(x), diff(y(x), x), diff(y(x), x, x), diff(y(x), x, x, x), `...`) = 0 

No primeiro caso falta a variável y(x) e na segunda x. EDO's de ordem n do tipo missing podem sempre ser reduzidas para uma EDO de ordem `+`(n, `-`(1)). Isso não garante a solução completa a menos que a EDO reduzida possa ser resolvida. A ordem de uma EDO faltando a variável y(x) (primeiro tipo) pode ser reduzida pela substituição `+`(diff(y(x), x), `-`(`*`(`>`, `*`(z(x))))). Se a EDO puder ser resolvida para z(x), a solução final é obtida por uma integração simples. Uma EDO sem apresentar a variável x explicitamente requer uma técnica um pouco mais rebuscada. Para reduzir a ordem a substituição deve ser `+`(diff(y(x), x), `-`(`*`(`>`, `*`(z(y))))). Note que a nova variável z(y) deve ser vista como função de y. Usando a regra da cadeia podemos ver que a substituição para diff(y(x), x, x) deve ser `*`(z(y), `*`(diff(z(y), y))). Note a redução de uma ordem na derivada. O mesmo vale para as outras ordens. A EDO transformada é resolvida considerando y como variável independente. 

 

Por exemplo, considere a EDO de segunda ordem do tipo missing (sem y(x) e sem x) completamente geral. 

> missing_x_and_y_EDO := F(diff(y(x), x), diff(y(x), x, x)) = 0
F(diff(y(x), x), diff(diff(y(x), x), x)) = 0 (1.2.2.3)
 

Observe que a classificação indica que a EDO não tem explicitamente as variáveis x e y(x). 

> odeadvisor(missing_x_and_y_EDO)
[[_2nd_order, _missing_x]] (1.2.2.4)
 

Essa EDO pode ser completamente integrada. 

> dsolve(missing_x_and_y_EDO)
y(x) = `+`(Int(RootOf(`+`(x, `-`(Intat(`/`(1, `*`(RootOf(F(_f, _Z)))), _f = _Z)), _C1)), x), _C2) (1.2.2.5)
 

Vejamos um exemplo mais concreto. 

> EDO := diff(y(x), x, x) = `*`(`^`(y(x), 5)); 1
diff(diff(y(x), x), x) = `*`(`^`(y(x), 5)) (1.2.2.6)
 

Essa EDO não tem a variável x aparecendo explicitamente. 

> odeadvisor(EDO)
[[_2nd_order, _missing_x], [_2nd_order, _reducible, _mu_x_y1]] (1.2.2.7)
 

Para obter informações sobre o método de solução 

> infolevel[dsolve] := 2
2 (1.2.2.8)
 

> res := dsolve(EDO)
 

Methods for second order ODEs:
 

 

 

--- Trying classification methods ---
trying 2nd order Liouville
trying 2nd order WeierstrassP
trying 2nd order JacobiSN
differential order: 2; trying a linearization to 3rd order
trying 2nd order ODE linearizable_by_differentiation
trying 2nd order, 2 integrating factors of the form mu(x,y)
trying differential order: 2; missing variables
-> Computing symmetries using: way = 3
-> Calling odsolve with the ODE (diff(_b(_a) _a))*_b(_a)-_a^5 = 0 _b(_a) HINT = [[_a 3*_b]]
  *** Sublevel 2 ***
  symmetry methods on request
1st order, trying reduction of order with given symmetries:
[_a, `+`(`*`(3, `*`(_b)))]
  1st order, trying the canonical coordinates of the invariance group
     -> Calling odsolve with the ODE diff(y(x) x) = 3*y(x)/x y(x)
        *** Sublevel 3 ***
        Methods for first order ODEs:
        --- Trying classification methods ---
        trying a quadrature
        trying 1st order linear
        <- 1st order linear successful
  <- 1st order, canonical coordinates successful
<- differential order: 2; canonical coordinates successful
<- differential order 2; missing variables successful
`+`(Intat(`+`(`-`(`/`(`*`(3), `*`(`^`(`+`(`*`(3, `*`(`^`(_a, 6))), `*`(3, `*`(_C1))), `/`(1, 2)))))), _a = y(x)), `-`(x), `-`(_C2)) = 0, `+`(Intat(`+`(`/`(`*`(3), `*`(`^`(`+`(`*`(3, `*`(`^`(_a, 6))), ... (1.2.2.9)
 

> infolevel[dsolve] := 1
1 (1.2.2.10)
 

Podemos tecer várias observações: 

1. O comando infolevel[dsolve] := 2;  permite que o usuário acompanhe o método usado no processo de integração da EDO. No caso acima, o método missing variables reduz a EDO de segunda ordem para uma EDO de primeira ordem. Esta última é resolvida pelo método de Bernoulli. 

2. O comando dsolve retorna uma sequência de soluções. 

3. As soluções estão na forma implícita. 

4. As integrais estão na forma inert do comando intat (observe que a integral só tem o limite superior). 

 

Podemos obter uma solução explícita se _C1 = 0. O comando value é necessário para avaliar a integral inerte. 

> sol := solve(value(subs(_C1 = 0, res[1])), y(x))
`+`(`/`(`*`(`/`(1, 2), `*`(`^`(6, `/`(1, 2)))), `*`(`^`(`*`(`+`(x, _C2), `*`(`^`(3, `/`(1, 2)))), `/`(1, 2))))), `+`(`-`(`/`(`*`(`/`(1, 2), `*`(`^`(6, `/`(1, 2)))), `*`(`^`(`*`(`+`(x, _C2), `*`(`^`(3,... (1.2.2.11)
 

Podemos confirmar a primeira solução. 

> odetest(y(x) = sol[1], EDO)
0 (1.2.2.12)
 

Muitas EDO's, cuja soluções são dadas por funções não elementares, também estão classificadas. Por exemplo, as funções de Bessel J e Y obedecem a seguinte EDO 

> Bessel_EDO := `+`(`*`(`^`(x, 2), `*`(diff(y(x), x, x))), `*`(x, `*`(diff(y(x), x))), `*`(`+`(`-`(`*`(`^`(n, 2))), `*`(`^`(x, 2))), `*`(y(x)))) = 0
`+`(`*`(`^`(x, 2), `*`(diff(diff(y(x), x), x))), `*`(x, `*`(diff(y(x), x))), `*`(`+`(`-`(`*`(`^`(n, 2))), `*`(`^`(x, 2))), `*`(y(x)))) = 0 (1.2.2.13)
 

> dsolve(Bessel_EDO)
 

<- No Liouvillian solutions exists
y(x) = `+`(`*`(_C1, `*`(BesselJ(n, x))), `*`(_C2, `*`(BesselY(n, x)))) (1.2.2.14)
 

A classificação é  

> odeadvisor(Bessel_EDO)
[_Bessel] (1.2.2.15)
 

 

A solução de uma ODE não é necessarimente a função correspondente a classificação. A ODE  

> erf_EDO := `+`(diff(y(x), x, x), `*`(2, `*`(x, `*`(diff(y(x), x)))), `-`(`*`(2, `*`(n, `*`(y(x)))))) = 0; 1
`+`(diff(diff(y(x), x), x), `*`(2, `*`(x, `*`(diff(y(x), x)))), `-`(`*`(2, `*`(n, `*`(y(x)))))) = 0 (1.2.2.16)
 

é classificada como 

> odeadvisor(erf_EDO)
[_erf] (1.2.2.17)
 

A classificação nos diz que a ODE é da forma obedecida pela função erro e correlatas porém a solução é dada em termos das funções de Whittaker  

> dsolve(erf_EDO)
 

<- No Liouvillian solutions exists
y(x) = `+`(`*`(_C1, `*`(exp(`+`(`-`(`*`(`^`(x, 2))))), `*`(KummerM(`+`(1, `*`(`/`(1, 2), `*`(n))), `/`(3, 2), `*`(`^`(x, 2))), `*`(x)))), `*`(_C2, `*`(exp(`+`(`-`(`*`(`^`(x, 2))))), `*`(KummerU(`+`(1,... (1.2.2.18)
 

Podemos verificar que as integrais iteradas da função erro complementar é solução dessa ODE através do comando odetest. 

> odetest(y(x) = erfc(n, x), erf_EDO)
0 (1.2.2.19)
 

A função erro erf é definida pela integral 

erf(x) = `+`(`/`(`*`(2, `*`(int(exp(`+`(`-`(`*`(`^`(t, 2))))), t = 0 .. x))), `*`(sqrt(Pi)))) 

e a função erro complementar é definida por erfc(x) = `+`(1, `-`(erf(x))). As integrais iteradas da função erro é definida recursivamente por 

erfc(n, x) = Int(erfc(`+`(n, `-`(1)), t), t = x .. infinity) 

onde erfc(0, x) = erfc(x). 

 

Uma EDO é dita exata ( exact_linear , exact_nonlinear , exact order 1 ) se 

 

Diff(F(x, y(x), Diff(y(x), x), diff(y(x), x, x), diff(y(x), x, x, x), `   ...   `), x) = 0. 

 

Se F(x, y, z, `...`) for uma função linear em todos os argumentos então a EDO também é linear. É fácil de ver que EDO's desse tipo podem sempre ser reduzidas de uma ordem. Por exemplo, a EDO 

> exact_EDO := `*`(diff(y(x), x), `*`(`+`(x, `*`(`^`(diff(y(x), x), 2), `*`(exp(y(x)))), `*`(2, `*`(exp(y(x)), `*`(diff(y(x), x, x))))))) = `+`(`-`(y(x))); 1
`*`(diff(y(x), x), `*`(`+`(x, `*`(`^`(diff(y(x), x), 2), `*`(exp(y(x)))), `*`(2, `*`(exp(y(x)), `*`(diff(diff(y(x), x), x))))))) = `+`(`-`(y(x))) (1.2.2.20)
 

é exata, como podemos confirmar com o comando odeadvisor. 

> odeadvisor(exact_EDO)
[[_2nd_order, _exact, _nonlinear], [_2nd_order, _reducible, _mu_y_y1], [_2nd_order, _reducible, _mu_poly_yn]] (1.2.2.21)
 

Ela pode ser reduzida para uma EDO de primeira ordem 

> sol := dsolve(exact_EDO)
y(x) = ODESolStruc(_b(_a), [{`+`(`*`(_b(_a), `*`(_a)), `*`(`^`(diff(_b(_a), _a), 2), `*`(exp(_b(_a)))), _C1) = 0}, {_a = x, _b(_a) = y(x)}, {x = _a, y(x) = _b(_a)}])
y(x) = ODESolStruc(_b(_a), [{`+`(`*`(_b(_a), `*`(_a)), `*`(`^`(diff(_b(_a), _a), 2), `*`(exp(_b(_a)))), _C1) = 0}, {_a = x, _b(_a) = y(x)}, {x = _a, y(x) = _b(_a)}])
(1.2.2.22)
 

que é dada por explicitamente por 

> EDO_reduzida := op([2, 2, 1, 1], sol)
`+`(`*`(_b(_a), `*`(_a)), `*`(`^`(diff(_b(_a), _a), 2), `*`(exp(_b(_a)))), _C1) = 0 (1.2.2.23)
 

A EDO reduzida é do tipo patterns  

> odeadvisor(EDO_reduzida)
[`y=_G(x,y')`] (1.2.2.24)
 

porém não pode ser resolvida pelo comando dsolve para _C1 arbitrário. 

 

Pacote DEtools 

Comandos para manipulação de EDOs 

Os principais comando de manipulação são: 

 

DEnormal ,     autonomous ,    convertAlg ,   convertsys ,
indicialeq ,   reduceOrder ,   regularsp ,   translate ,  
 
untranslate , varparam .                                

 

O comando reduceOrder reduz a ordem da EDO uma vez conhecida uma ou mais soluções particulares para ela. A sintaxe é 

 

reduceOrder(EDO, y(x), solu\E7\E3o_particular, op\E7\E3o)            

 

Por exemplo, a EDO de terceira ordem 

> with(DEtools); -1

> EDO := `+`(`*`(cos(x), `*`(diff(y(x), `$`(x, 3)))), `-`(diff(y(x), `$`(x, 2))), `*`(Pi, `*`(diff(y(x), x)))) = `+`(y(x), `-`(x)); 1
`+`(`*`(cos(x), `*`(diff(diff(diff(y(x), x), x), x))), `-`(diff(diff(y(x), x), x)), `*`(Pi, `*`(diff(y(x), x)))) = `+`(y(x), `-`(x)) (1.3.1.1)
 

tem como solução particular a função 

> f := proc (x) options operator, arrow; `+`(x, Pi) end proc
proc (x) options operator, arrow; `+`(x, Pi) end proc (1.3.1.2)
 

como podemos verificar com o comando odetest  

> odetest(y(x) = f(x), EDO)
0 (1.3.1.3)
 

Podemos reduzir essa EDO para uma outra de segunda ordem 

> EDO_reduzida := reduceOrder(EDO, y(x), `+`(x, Pi))
`+`(`*`(`+`(`*`(cos(x), `*`(x)), `*`(cos(x), `*`(Pi))), `*`(diff(diff(y(x), x), x))), `*`(`+`(`-`(x), `-`(Pi), `*`(3, `*`(cos(x)))), `*`(diff(y(x), x))), `*`(`+`(`*`(`^`(Pi, 2)), `*`(Pi, `*`(x)), `-`(... (1.3.1.4)
 

cuja solução geral não inclui mais a função f(x) = `+`(x, Pi). 

 

 

O comando convertAlg converte um EDO linear em uma lista com 2 elementos. Se a EDO tem a forma 

`+`(`*`(A[1], `*`(y(x))), `*`(A[2], `*`(diff(y(x), x))), `*`(A[3], `*`(diff(y(x), x, x))), `...`) = f(x) 

 

então o resultado da aplicação do comando é 

 

[[A[1], A[2], A[3], `...`], f(x)]. 

O comando convertsys converte uma EDO ou um sistema de EDO's de qualquer ordem para um sistema de EDO's de primeira ordem. 

 

 

Comandos para visualização 

Os principais comandos de visualização são: 

 

DEplot , DEplot3d , dfieldplot , phaseportrait .   

 

O comando DEplot faz o gráfico da solução de uma EDO de qualquer ordem ou faz o gráfico direcional de um sistema de duas EDO's de primeira ordem. A sintaxe para uma EDO é 

 

    DEplot(EDO, y(x), x = a .. b, CI's, y = c .. d, opções) 

 

e para um sistema de duas EDO's é  

 

     DEplot({EDO1, EDO2}, {x(t), y(t)},  t = a .. b, CI's, x = c .. d, y = e .. f, opções) 

 

onde CI's são as condições iniciais nas forma de lista de listas (veja exemplos abaixo). Considere a seguinte EDO de segunda ordem que não pode ser resolvida com o comando dsolve . 

> EDO := `+`(`*`(cos(x), `*`(`+`(x, Pi), `*`(diff(y(x), x, x)))), `-`(`*`(`+`(x, Pi, `-`(`*`(3, `*`(cos(x))))), `*`(diff(y(x), x)))), `*`(`+`(`*`(`^`(Pi, 2)), `*`(Pi, `*`(x)), `-`(2)), `*`(y(x)))) = 0; ...
`+`(`*`(cos(x), `*`(`+`(x, Pi), `*`(diff(diff(y(x), x), x)))), `-`(`*`(`+`(x, Pi, `-`(`*`(3, `*`(cos(x))))), `*`(diff(y(x), x)))), `*`(`+`(`*`(`^`(Pi, 2)), `*`(Pi, `*`(x)), `-`(2)), `*`(y(x)))) = 0 (1.3.2.1)
 

Considere as condições iniciais 

> CI := [[y(0) = 1, (D(y))(0) = 2]]
[[y(0) = 1, (D(y))(0) = 2]] (1.3.2.2)
 

O gráfico da solução para x no intervalo [-2, 2] é 

> DEplot(EDO, y(x), x = -2 .. 2, CI, linecolor = red)
 

Warning, plot may be incomplete, the following errors(s) were issued:
 

  cannot evaluate the solution further right of 1.5707963, probably a singularity
Plot_2d
 

O sistema de EDO's  

> sistema_EDO := {diff(y(x), x) = `+`(y(x), `-`(z(x))), diff(z(x), x) = `+`(z(x), `-`(`*`(2, `*`(y(x)))))}
{diff(y(x), x) = `+`(y(x), `-`(z(x))), diff(z(x), x) = `+`(z(x), `-`(`*`(2, `*`(y(x)))))} (1.3.2.3)
 

com as condições iniciais 

> CI := [[y(0) = 1.638, z(0) = 2.31]]
[[y(0) = 1.638, z(0) = 2.31]] (1.3.2.4)
 

tem o sequinte gráfico de direções com a curva que obedece as condições iniciais em destaque. 

> DEplot(sistema_EDO, {y(x), z(x)}, x = 0 .. 3, CI, y = 0 .. 2, z = -4 .. 4, color = black, linecolor = red)
 

Plot_2d
 

O mesmo gráfico pode ser obtido com o comando phaseportrait ou com o comando dfieldplot , porém este último sem usar condições iniciais. Os comandos equivalentes que geram o gráfico acima é 

phaseportrait(sistema_EDO, {y(x), z(x)}, x = 0 .. 3, CI, y = 0 .. 2, z = -4 .. 4) 

 

dfieldplot(sistema_EDO, {y(x), z(x)}, x = 0 .. 3, y = 0 .. 2, z = -4 .. 4) 

 

O gráfico tri-dimensional da curva em destaque do comando acima pode ser feito com o comando DEplot3d . A opção scene = [x, z(x), y(x)] especifica a ordem dos eixos no gráfico. 

> DEplot3d(sistema_EDO, {y(x), z(x)}, x = 0 .. 3, CI, y = 0 .. 2, z = -4 .. 4, scene = [x, z(x), y(x)], linecolor = black);
 

Plot_2d
 

 

Outros comandos que retornam soluções de EDOs 

Exite uma série de comandos que resolvem EDO's de tipos particulares.  A maioria desses métodos está implementada no comando dsolve porém as soluções retornadas pelo dsolve não são totalmente equivalentes às soluções retornadas por esses comandos particulares, principalmente com relação a forma das soluções e com relação a soluções especiais de EDO's não lineares. A lista desses comando é 

 

RiemannPsols ,    abelsol ,    bernoullisol , chinisol ,      clairautsol ,   
constcoeffsols , eulersols , exactsol ,      expsols ,       genhomosol ,    
kovacicsols ,     liesol ,     linearsol ,     matrixDE ,      parametricsol ,
polysols ,        ratsols ,    riccatisol ,    separablesol .                 

 

 

As EDO's de Riccati tem a forma 

diff(y(x), x) = `+`(a, `*`(b, `*`(y(x))), `*`(c, `*`(`^`(y(x), 2)))) 

onde a, b, c são funções de x. A EDO  

> Riccati_EDO := `+`(`*`(x, `*`(diff(y(x), x))), y(x)) = `+`(`*`(3, `*`(`^`(x, 2), `*`(`^`(y(x), 2))))); 1
`+`(`*`(x, `*`(diff(y(x), x))), y(x)) = `+`(`*`(3, `*`(`^`(x, 2), `*`(`^`(y(x), 2))))) (1.3.3.1)
 

é do tipo Riccati, portanto pode ser resolvida pelo comando   riccatisol . 

> riccatisol(Riccati_EDO, y(x))
{y(x) = `/`(1, `*`(`+`(`-`(`*`(3, `*`(x))), _C1), `*`(x)))} (1.3.3.2)
 

Compare agora com a solução obtida com o comando dsolve . 

> dsolve(Riccati_EDO)
y(x) = `/`(1, `*`(`+`(`-`(`*`(3, `*`(x))), _C1), `*`(x))) (1.3.3.3)
 

A solução especial y(x) = 0 não foi dada explicitamente pelo comando dsolve , porém ela pode ser obtida tomando o limite quando _C1 vai a infinity. 

 

O comando   matrixDE acha a solução de um sistema de EDO's lineares da forma  

diff(X(t), t) = `+`(`*`(A(t), `*`(X(t))), B(t)) 

onde A(t) e B(t) são matrizes. Por exemplo, o sistema de EDO's pode ser resolvido da seguinte forma. 

> A := matrix(2, 2, [1, t, t, 1])
array( 1 .. 2, 1 .. 2, [( 2, 1 ) = (t), ( 1, 1 ) = (1), ( 2, 2 ) = (1), ( 1, 2 ) = (t)  ] ) (1.3.3.4)
 

> sol := matrixDE(A, t)
 

     A Liouvillian solution exists
[array( 1 .. 2, 1 .. 2, [( 2, 1 ) = (exp(`+`(`*`(`/`(1, 2), `*`(t, `*`(`+`(t, 2))))))), ( 1, 1 ) = (exp(`+`(`*`(`/`(1, 2), `*`(t, `*`(`+`(t, 2))))))), ( 2, 2 ) = (`+`(`-`(exp(`+`(`-`(`*`(`/`(1, 2), `*... (1.3.3.5)
 

 

Método Numérico 

Podemos resolver uma equação diferencial sem parâmetros livres usando métodos numéricos. A solução é dada na forma de um procedimento que pode ser usado para gerar o valor da solução em determinados pontos ou para gerar o gráfico da solução. Vamos ver um exemplo. 

> restart

> EDO := `+`(diff(F(x), x, x), `*`(2, `*`(F(x), `*`(`+`(`*`(2, `*`(ln(F(x)), `*`(`^`(x, 2)))), `-`(`*`(cos(`*`(`^`(x, 2))), `*`(`+`(1, `*`(2, `*`(cos(`*`(`^`(x, 2))), `*`(`^`(x, 2))))))))))))) = 0
`+`(diff(diff(F(x), x), x), `*`(2, `*`(F(x), `*`(`+`(`*`(2, `*`(ln(F(x)), `*`(`^`(x, 2)))), `-`(`*`(cos(`*`(`^`(x, 2))), `*`(`+`(1, `*`(2, `*`(cos(`*`(`^`(x, 2))), `*`(`^`(x, 2))))))))))))) = 0 (1.4.1)
 

> ci := F(0) = 1, (D(F))(0) = 0
F(0) = 1, (D(F))(0) = 0 (1.4.2)
 

> f := dsolve({EDO, ci}, F(x), numeric)
proc (x_rkf45) local _res, _dat, _vars, _solnproc, _xout, _ndsol, _pars, _n, _i; option `Copyright (c) 2000 by Waterloo Maple Inc. All rights reserved.`; if `<`(1, nargs) then error (1.4.3)
 

O procedimento ( procedure ) f  fornece o valor da função e da derivada primeira uma vez dado o ponto x: 

> f(0)
[x = HFloat(0.0), F(x) = HFloat(1.0), diff(F(x), x) = HFloat(0.0)] (1.4.4)
 

> f(1)
[x = 1., F(x) = HFloat(2.319776885169381), diff(F(x), x) = HFloat(2.506761466792519)] (1.4.5)
 

Para fazer o gráfico, podemos usar o comando odeplot do pacote plots: 

> plots[odeplot](f, [x, F(x)], 0 .. 4)
Plot_2d
 

Se o usuário não especificar o método de resolução numerica, o Maple usa o método de Euler. Existem vários outros métodos como o de Runge-Kutta de segunda, terceira ou quarta order, Adams-Bashford, séries de Taylor entre vários outros. Para mais informações veja o help on line de ? dsolve, numeric . 

Exercício 

Tente encontrar a solução exata da equação diferencial acima. Verique que a solução procurada é  

 

 

Método de Séries 

É possível encontrar uma expansão em séries para a solução de uma EDO ou de um sistema de EDO's sem a resolução direta da equação. Os métodos usados são o método de iteração de Newton, método de Frobenius ou método de substituição por uma séria com coeficientes arbitrários a serem determinados. A sintaxe é 

 

    dsolve(EDO, y(x), series) 

    dsolve({EDO, IC's}, y(x), series) 

    dsolve({seq_de_EDOs, CI's}, {funcs}, series) 

 

onde  

 

     EDO é uma equação diferencial ordinária 

     y(x) é uma função indeterminada de um única variável 

     CI's são as condicões iniciais. 

     seq_de_EDOs é um conjunto de EDO's 

    {funcs} é um conjunto de funções indeterminadas de um única variável 

 

Novamente vamos usar a equação de Mathieu como exemplo. 

> Order := 12; -1

> Mathieu_EDO := `+`(diff(y(x), x, x), `-`(`*`(cos(`+`(`*`(2, `*`(x)))), `*`(y(x)))))
`+`(diff(diff(y(x), x), x), `-`(`*`(cos(`+`(`*`(2, `*`(x)))), `*`(y(x))))) (1.5.1)
 

> dsolve({Mathieu_EDO, y(0) = 0, (D(y))(0) = 1}, y(x), series)
y(x) = series(`+`(x, `*`(`/`(1, 6), `*`(`^`(x, 3))), `-`(`*`(`/`(11, 120), `*`(`^`(x, 5)))), `*`(`/`(29, 5040), `*`(`^`(x, 7))), `*`(`/`(71, 24192), `*`(`^`(x, 9))), `-`(`*`(`/`(3151, 4435200), `*`(`^... (1.5.2)
 

A variável Order controla a ordem da solução. Vejamos um exemplo de um sistema de EDO's. 

> Order := 3; -1

> sistema := {diff(x(t), t) = y(t), diff(y(t), t) = `+`(`-`(x(t)))}; 1
{diff(x(t), t) = y(t), diff(y(t), t) = `+`(`-`(x(t)))} (1.5.3)
 

> dsolve(`union`(sistema, {x(0) = A, y(0) = B}), {x(t), y(t)}, type = series)
{x(t) = series(`+`(A, `*`(B, `*`(t)), `-`(`*`(`*`(`/`(1, 2), `*`(A)), `*`(`^`(t, 2)))))O(`^`(t, 3)),t,3), y(t) = series(`+`(B, `-`(`*`(A, `*`(t))), `-`(`*`(`*`(`/`(1, 2), `*`(B)), `*`(`^`(t, 2)))))O(`... (1.5.4)
 

Compare o resultado com a expansão em série da solução exata. 

> res := dsolve(`union`(sistema, {x(0) = A, y(0) = B}), {x(t), y(t)})
{x(t) = `+`(`*`(B, `*`(sin(t))), `*`(A, `*`(cos(t)))), y(t) = `+`(`*`(B, `*`(cos(t))), `-`(`*`(A, `*`(sin(t)))))} (1.5.5)
 

> map(proc (x) options operator, arrow; lhs(x) = series(rhs(x), t) end proc, res)
{x(t) = series(`+`(A, `*`(B, `*`(t)), `-`(`*`(`*`(`/`(1, 2), `*`(A)), `*`(`^`(t, 2)))))O(`^`(t, 3)),t,3), y(t) = series(`+`(B, `-`(`*`(A, `*`(t))), `-`(`*`(`*`(`/`(1, 2), `*`(B)), `*`(`^`(t, 2)))))O(`... (1.5.6)
 

Para mais informações veja o help on line de ? dsolve, series . 

Exemplo 1 - Crescimento populacional 

Ref. D. G. Zill, Equações Diferenciais com Aplicações em Modelagem 

 

Lei de Malthus 

 

A lei de Malthus prevê um crescimento exponencial da população como consequência da seguinte hipótese: a taxa de crescimento é proporcional ao tamanho da população. Se P(t) denota o tamanho da população no instante t, a modelagem matemática do hipótese de Malthus é: 

> restart

> EDO := diff(P(t), t) = `*`(k, `*`(P(t)))
(1.6.1.1)
 

onde k é uma constante positiva. Vamos analisar um caso particular de população, cujos indivíduos são bactérias. No início t = 0, vamos supor que há apenas uma bactéria. Portanto, a condição inicial do problema é 

> CI := P(0) = 1
P(0) = 1 (1.6.1.2)
 

A solução da EDO é 

> SOL := dsolve({CI, EDO})
P(t) = exp(`*`(k, `*`(t))) (1.6.1.3)
 

> P := unapply(rhs(SOL), t)
proc (t) options operator, arrow; exp(`*`(k, `*`(t))) end proc (1.6.1.4)
 

A constante k é a taxa de crescimento relativa (tx de crescimento dividida pelo tamanho da população). Vamos supor que a população aumentou 1 indivíduo após a primeira unidade de tempo (de t = 0 para t = 1): 

> k := solve(P(1) = `+`(P(0), 1), k)
ln(2) (1.6.1.5)
 

O gráfico da solução é 

> plot(P(t), t = 0 .. 10, tamanho_da_popula\E7\E3o = 0 .. 1000)
Plot_2d
 

 

Equação Logística 

 

Se a quantidade de recursos disponíveis do meio ambiente diminuir, não é esperado um crescimento exponencial permanente. Vamos supor que o meio ambiente suporta no máximo K indivíduos. A hipótese sobre a taxa de crescimento deve mudar. Vamos supor que a taxa de crescimento tem um fator multiplicativo que inicialmente é 1 e diminui quando a população aumenta, tendendo a zero quando a população aproxima do valor máximo K: 

>

> restart

> EDO := diff(P(t), t) = `*`(k, `*`(P(t), `*`(`+`(1, `-`(`/`(`*`(P(t)), `*`(K)))))))
(1.6.2.1)
 

A condição inicial é 

> CI := P(0) = 1
P(0) = 1 (1.6.2.2)
 

A solução da EDO é 

> SOL := dsolve({CI, EDO})
P(t) = `/`(`*`(K), `*`(`+`(1, `*`(exp(`+`(`-`(`*`(k, `*`(t))))), `*`(K)), `-`(exp(`+`(`-`(`*`(k, `*`(t))))))))) (1.6.2.3)
 

> P := unapply(rhs(SOL), t)
proc (t) options operator, arrow; `/`(`*`(K), `*`(`+`(1, `*`(exp(`+`(`-`(`*`(k, `*`(t))))), `*`(K)), `-`(exp(`+`(`-`(`*`(k, `*`(t))))))))) end proc (1.6.2.4)
 

Vamos supor que o número máximo de bactérias é 

> K := 1500
1500 (1.6.2.5)
 

Vamos supor que a população aumentou 1 indivíduo após a primeira unidade de tempo (de t = 0 para t = 1): 

> k := solve(P(1) = `+`(P(0), 1), k)
`+`(`-`(ln(`/`(749, 1499)))) (1.6.2.6)
 

O gráfico da solução, com uma apresentação melhorada, é 

> plot([K, P(t), exp(`*`(ln(2), `*`(t)))], t = 0 .. 25, `tamanho da popula\E7\E3o` = 0 .. `+`(K, 100), labeldirections = [horizontal, vertical], title =
plot([K, P(t), exp(`*`(ln(2), `*`(t)))], t = 0 .. 25, `tamanho da popula\E7\E3o` = 0 .. `+`(K, 100), labeldirections = [horizontal, vertical], title =
plot([K, P(t), exp(`*`(ln(2), `*`(t)))], t = 0 .. 25, `tamanho da popula\E7\E3o` = 0 .. `+`(K, 100), labeldirections = [horizontal, vertical], title =
Plot_2d
 

 

Exercício 1. A equação logística tem que ordem? É linear ou não-linear?  

 

Exercício 2. Refaça a análise desta seção usando a equação de Gompertz:  diff(P(t), t) = `*`(P(t), `*`(`+`(a, `-`(`*`(b, `*`(ln(P(t)))))))) onde a e b são números positivos. 

 

Exemplo 2 - Mistura de soluções salinas 

Ref. D. G. Zill, Equações Diferenciais com Aplicações em Modelagem 

 

Um tanque - EDO de primeira ordem 

 

Suponha que um tanque de 300 litros tem água salgada inicialmente na concentração de 250 gramas por litro. O limite máximo de concentração de sal na água à temperatura ambiente é cerca de 357 gramas por litro. Suponha que esteja sendo bombeada água salgada com a concentração de 120 gramas por litro a uma taxa de 2 litros por minuto para dentro do tanque sendo imediatamente misturada com a água que já está no tanque e, ao mesmo tempo, o tanque também tem um outro tubo que escoa água para fora na taxa de 2 litros por minuto. O volume de água no tanque permanece constante. Qual é a quantidade de sal em kilos no tanque? 

 

Vamos denotar a quantidade de sal na água do tanque em kilos por A(t) e vamos usar minuto como unidade de tempo.  A equação diferencial que descreve o comportamento de A(t) é 

>

> restart

> EDO := diff(A(t), t) = `+`(Tx1, `-`(Tx2(t)))
diff(A(t), t) = `+`(Tx1, `-`(Tx2(t))) (1.7.1.1)
 

onde Tx1 é a taxa de entrada de sal e Tx2 é a taxa de saída de sal. A taxa Tx1 é constante e é dada pelo produto da vazão (2 litros/min) pela concentração de sal (0.12 kg/litro), isto é 

> Tx1 := `*`(2, .12)
.24 (1.7.1.2)
 

A taxa Tx2 de saída do sal não é constante, pois a concentração de sal na água do tanque varia com o tempo. A taxa Tx2 é o produto da taxa de saída da água (2 litros/min) pela concentração de sal no instante t, que é dado por A(t) dividido pelo volume de água no tanque. 

> Tx2 := proc (t) options operator, arrow; `*`(2., `*`(`/`(`*`(A(t)), `*`(300.)))) end proc
proc (t) options operator, arrow; `*`(2., `*`(`/`(`*`(A(t)), `*`(300.)))) end proc (1.7.1.3)
 

> EDO
diff(A(t), t) = `+`(.24, `-`(`*`(0.6666666666e-2, `*`(A(t))))) (1.7.1.4)
 

No início, a concentração de sal é 0.25 kilo/litro, portanto a condição inicial do problema é 

> CI := A(0) = `*`(.25, 300)
A(0) = 75.00 (1.7.1.5)
 

A solução da EDO é 

> SOL := evalf(dsolve({CI, EDO}))
A(t) = `+`(36.00000000, `*`(39.00000000, `*`(exp(`+`(`-`(`*`(0.6666666666e-2, `*`(t)))))))) (1.7.1.6)
 

O gráfico da solução é 

> dia := `*`(60, 24); -1

> quantidade_max_de_sal := `*`(.35, 300); -1

> plot(subs(SOL, A(t)), t = 0 .. dia, quantidade_de_sal = 0 .. quantidade_max_de_sal)
Plot_2d
 

A quantidade de sal final (t = infinity) no tanque é 

> valor_final := limit(subs(SOL, A(t)), t = infinity)
36. (1.7.1.7)
 

Vamos fazer o gráfico conjunto com o valor final da quantidade de sal e melhorar a apresentação. 

> plot([valor_final, subs(SOL, A(t))], t = 0 .. dia, `quantidade de sal` = 0 .. quantidade_max_de_sal, labeldirections = [horizontal, vertical], title =
plot([valor_final, subs(SOL, A(t))], t = 0 .. dia, `quantidade de sal` = 0 .. quantidade_max_de_sal, labeldirections = [horizontal, vertical], title =
plot([valor_final, subs(SOL, A(t))], t = 0 .. dia, `quantidade de sal` = 0 .. quantidade_max_de_sal, labeldirections = [horizontal, vertical], title =
Plot_2d
 

 

Exercício 1. No exemplo acima, a taxa de saída de água é igual a taxa de entrada. Refaça o problema supondo que a taxa de saída é de 2.5 litros por minuto. Encontre também o instante que o tanque fica totalmente vazio. 

 

 

Dois tanques - sistema da EDOs de primeira ordem 

 

Considere dois tanques com a capacidade de 300 litros. O primeiro (tanque A) tem água salgada inicialmente na concentração de 250 gramas por litro e o segundo (tanque B) água pura.  

 

Image 

 

Os tanques estão interconectados e a vazão em cada tubo é 

 

V1 = 9 litros/min (de água pura entrando em A) 

V2 = 3 litros/min (de B para A) 

V3 = 12 litros/min (de A para B) 

V4 = 9 litros/min (saindo de B) 

 

Qual é a quantidade de sal em kilos em cada tanque? 

 

Vamos denotar a quantidade de sal na água do tanque A em kilos por A(t) e no tanque B por B(t). Vamos usar minuto como unidade de tempo.  A equação diferencial que descreve o comportamento de A(t) é 

>

> restart

> V1, V2, V3, V4 := 9, 3, 12, 9; 1
9, 3, 12, 9 (1.7.2.1)
 

> EDO_A := diff(A(t), t) = `+`(Tx_entrada_A(t), `-`(Tx_saida_A(t)))
diff(A(t), t) = `+`(Tx_entrada_A(t), `-`(Tx_saida_A(t))) (1.7.2.2)
 

onde Tx_entrada_A é a taxa de entrada de sal no tanque A e Tx_saida_A é a taxa de saída de sal do tanque A. A taxa de entrada em A é 

> Tx_entrada_A := proc (t) options operator, arrow; `+`(`*`(`/`(1, 300), `*`(V2, `*`(B(t))))) end proc
proc (t) options operator, arrow; `+`(`*`(`/`(1, 300), `*`(V2, `*`(B(t))))) end proc (1.7.2.3)
 

A taxa de saída de A é 

> Tx_saida_A := proc (t) options operator, arrow; `+`(`*`(`/`(1, 300), `*`(V3, `*`(A(t))))) end proc
proc (t) options operator, arrow; `+`(`*`(`/`(1, 300), `*`(V3, `*`(A(t))))) end proc (1.7.2.4)
 

> EDO_A
diff(A(t), t) = `+`(`*`(`/`(1, 100), `*`(B(t))), `-`(`*`(`/`(1, 25), `*`(A(t))))) (1.7.2.5)
 

Analogamente 

> EDO_B := diff(B(t), t) = `+`(`*`(`/`(1, 300), `*`(V3, `*`(A(t)))), `-`(`*`(`/`(1, 300), `*`(V4, `*`(B(t))))), `-`(`*`(`/`(1, 300), `*`(V2, `*`(B(t))))))
diff(B(t), t) = `+`(`*`(`/`(1, 25), `*`(A(t))), `-`(`*`(`/`(1, 25), `*`(B(t))))) (1.7.2.6)
 

 

No início, a concentração de sal é 0.25 kilo/litro no tanque A e nenhum sal no tanque B, portanto as condições iniciais do problema são 

> CI_A, CI_B := A(0) = `*`(.25, 300), B(0) = 0
A(0) = 75.00, B(0) = 0 (1.7.2.7)
 

A solução da EDO é 

> SOL := dsolve({CI_A, CI_B, EDO_A, EDO_B})
{A(t) = `+`(`*`(`/`(75, 2), `*`(exp(`+`(`-`(`*`(`/`(1, 50), `*`(t))))))), `*`(`/`(75, 2), `*`(exp(`+`(`-`(`*`(`/`(3, 50), `*`(t)))))))), B(t) = `+`(`*`(75, `*`(exp(`+`(`-`(`*`(`/`(1, 50), `*`(t)))))))... (1.7.2.8)
 

> A := unapply(subs(SOL, A(t)), t)

> B := unapply(subs(SOL, B(t)), t)
 

(1.7.2.9)
 

O gráfico da solução é 

> plot([A(`t (min)`), B(`t (min)`)], `t (min)` = 0 .. 300, `quantidade de sal (kg)` = 0 .. 75, labeldirections = [horizontal, vertical], title =
plot([A(`t (min)`), B(`t (min)`)], `t (min)` = 0 .. 300, `quantidade de sal (kg)` = 0 .. 75, labeldirections = [horizontal, vertical], title =
plot([A(`t (min)`), B(`t (min)`)], `t (min)` = 0 .. 300, `quantidade de sal (kg)` = 0 .. 75, labeldirections = [horizontal, vertical], title =
Plot_2d
 

 

Exercício 1. Encontre a quantidade de sal máxima no tanque B e em que instante isto ocorre. Confira os resultados com os valores obtidos no gráfico. 

Solução 

Método 1 

>

> eq1 := A(t) = B(t)
`+`(`*`(`/`(75, 2), `*`(exp(`+`(`-`(`*`(`/`(1, 50), `*`(t))))))), `*`(`/`(75, 2), `*`(exp(`+`(`-`(`*`(`/`(3, 50), `*`(t)))))))) = `+`(`*`(75, `*`(exp(`+`(`-`(`*`(`/`(1, 50), `*`(t))))))), `-`(`*`(75, ... (1.7.2.1.1)
 

> t0 := solve(eq1)
`+`(`*`(25, `*`(ln(3)))) (1.7.2.1.2)
 

> maxB := B(t0)
`+`(`*`(`/`(50, 3), `*`(`^`(3, `/`(1, 2))))) (1.7.2.1.3)
 

> evalf(t0)
27.46530722 (1.7.2.1.4)
 

> evalf(maxB)
28.86751347 (1.7.2.1.5)
 

Método 2 

> maxB := maximize(B(t), t = 0 .. 50)
`+`(`*`(`/`(50, 3), `*`(`^`(3, `/`(1, 2))))) (1.7.2.1.6)
 

> t0 := fsolve(B(t) = maxB)
27.46530722 (1.7.2.1.7)
 

 

 

Exercício 2. No exemplo acima, a taxa de saída de água é igual a taxa de entrada. Refaça o problema supondo que a vazão V4 seja 10 litros/min. Encontre também o instante no qual o tanque fica totalmente vazio. 

 

Exercício 3. Resolva o sistema de equações diferenciais do problema dos tanques A e B sem usar o comando do Maple para sistemas de equações diferenciais. Não é permitido usar o comando dsolve ou similares. 

Solução do exercício 3 

>

> restart

> EDO_A, EDO_B := diff(A(t), t) = `+`(`*`(`/`(1, 100), `*`(B(t))), `-`(`*`(`/`(1, 25), `*`(A(t))))), diff(B(t), t) = `+`(`*`(`/`(1, 25), `*`(A(t))), `-`(`*`(`/`(1, 25), `*`(B(t)))))
EDO_A, EDO_B := diff(A(t), t) = `+`(`*`(`/`(1, 100), `*`(B(t))), `-`(`*`(`/`(1, 25), `*`(A(t))))), diff(B(t), t) = `+`(`*`(`/`(1, 25), `*`(A(t))), `-`(`*`(`/`(1, 25), `*`(B(t)))))
diff(A(t), t) = `+`(`*`(`/`(1, 100), `*`(B(t))), `-`(`*`(`/`(1, 25), `*`(A(t))))), diff(B(t), t) = `+`(`*`(`/`(1, 25), `*`(A(t))), `-`(`*`(`/`(1, 25), `*`(B(t))))) (1.7.2.2.1)
 

Equações auxiliares do processo de separação das variáveis A(t) e B(t). 

> EQ1 := isolate(EDO_B, A(t)); 1

> EQ2 := isolate(EDO_A, B(t))
 

(1.7.2.2.2)
 

Geração das novas EDOs sem acoplamento. Note que obtemos EDOs de segunda ordem. 

> EDO_A_new := expand(subs(EDO_B, EQ2, diff(EDO_A, t))); 1

> EDO_B_new := expand(subs(EDO_A, EQ1, diff(EDO_B, t))); 1
 

(1.7.2.2.3)
 

`*`(Se, `*`(pud\E9ssemos, `*`(usar, `*`(o, `*`(comando, `*`(dsolse)))))), `*`(Typesetting:-delayDotProduct(`*`(o, `*`(exerc\EDcio, `*`(terminaria, `*`(com, `*`(mais, `*`(um, `*`(comando))))))), De), `*`(f...
`*`(Se, `*`(pud\E9ssemos, `*`(usar, `*`(o, `*`(comando, `*`(dsolse)))))), `*`(Typesetting:-delayDotProduct(`*`(o, `*`(exerc\EDcio, `*`(terminaria, `*`(com, `*`(mais, `*`(um, `*`(comando))))))), De), `*`(f...
 

> dsolve({EDO_A_new, A(0) = 75, (D(A))(0) = `+`(`-`(`*`(`/`(1, 25), `*`(A(0)))))}); 1

> dsolve({EDO_B_new, B(0) = 0, (D(B))(0) = `*`(75, `/`(1, 25))})
 

(1.7.2.2.4)
 

Sem usar o comando dsolve, temos que proceder de outra maneira e usar o método de soluções de EDOs lineares de segunda ordem. Vamos resolver a EDO para A(t) e deixar como exercício a resolução de EDO para B(t). 

> EDO_A_new := (`+`(lhs, `-`(rhs)))(EDO_A_new)
`+`(diff(diff(A(t), t), t), `*`(`/`(3, 2500), `*`(A(t))), `*`(`/`(2, 25), `*`(diff(A(t), t)))) (1.7.2.2.5)
 

Vamos converter a EDO em um polinômio onde x representa o operador diferencial. Para reobter a equação EDO_A_new temos que multiplicar por A(t) e interpretar cada atuação de x em A(t) como a derivada de A(t) em relação a t. 

> polinomio := subs({diff(A(t), t) = x, diff(A(t), t, t) = `*`(`^`(x, 2))}, A(t) = 1, EDO_A_new)
`+`(`*`(`^`(x, 2)), `/`(3, 2500), `*`(`/`(2, 25), `*`(x))) (1.7.2.2.6)
 

Note que o termo constante `/`(3, 2500) deveria estar multiplicado pelo operador identidade. Vamos agora fatorar o polinômio, multiplicar cada fator por A(t) e igualar cada resultado a zero. 

> EQ1, EQ2 := op(factor(numer(polinomio))); 1
`+`(`*`(50, `*`(x)), 3), `+`(`*`(50, `*`(x)), 1) (1.7.2.2.7)
 

> EDO1 := subs(`*`(x, `*`(A(t))) = diff(A(t), t), expand(`*`(EQ1, `*`(A(t)))))

> EDO2 := subs(`*`(x, `*`(A(t))) = diff(A(t), t), expand(`*`(EQ2, `*`(A(t)))))
 

(1.7.2.2.8)
 

Podemos agora achar duas soluções particulares: 

> SOL1 := isolate(map(int, expand(`/`(`*`(EDO1), `*`(A(t)))), t), A(t))

> SOL2 := isolate(map(int, expand(`/`(`*`(EDO2), `*`(A(t)))), t), A(t))
 

(1.7.2.2.9)
 

A solução geral é uma combinação linear destas soluções particulares. 

> sol_geral := `+`(`*`(c1, `*`(rhs(SOL1))), `*`(c2, `*`(rhs(SOL2))))
`+`(`*`(c1, `*`(exp(`+`(`-`(`*`(`/`(3, 50), `*`(t))))))), `*`(c2, `*`(exp(`+`(`-`(`*`(`/`(1, 50), `*`(t)))))))) (1.7.2.2.10)
 

Podemos encontrar os valores de c1 e c2 usando as condições iniciais para A(t). 

> sistema := {eval(subs(t = 0, sol_geral)) = 75, eval(subs(t = 0, diff(sol_geral, t))) = `+`(`-`(`*`(75, `/`(1, 25))))}
{`+`(c1, c2) = 75, `+`(`-`(`*`(`/`(3, 50), `*`(c1))), `-`(`*`(`/`(1, 50), `*`(c2)))) = -3} (1.7.2.2.11)
 

A solução final para A(t) é 

> A(t) = subs(solve(sistema), sol_geral)
A(t) = `+`(`*`(`/`(75, 2), `*`(exp(`+`(`-`(`*`(`/`(1, 50), `*`(t))))))), `*`(`/`(75, 2), `*`(exp(`+`(`-`(`*`(`/`(3, 50), `*`(t)))))))) (1.7.2.2.12)
 

 

 

Exemplo 3 - Circuitos elétricos 

Ref. D. G. Zill, Equações Diferenciais com Aplicações em Modelagem 

 

Circuito com resistência e indutor 

De acordo com a teoria de circuitos elétricos, se uma bateria com voltagem V é ligada em um circuito com um único resistor de resistência R, a corrente elétrica no circuito pode ser encontrada usando a fórmula V = `*`(R, `*`(i)), onde i é a corrente. Temos uma equação algébrica que pode ser resolvida facilmente. Se adicionarmos um indutor de indutância L a este circuito, formando um circuito em série, a equação passa a ser V = `+`(`*`(R, `*`(i)), `*`(L, `*`(diff(i, t)))), onde i é uma função do tempo a ser determinada através da resolução da equação differencial linear de primeira ordem. 

 

Suponha que uma bateria de 12 volts (que nunca decresce de capacidade) é conectada a  uma circuito em série no qual a resistência é 10 ohms e a indutância é 1/2 henry. Determine a corrente elétrica i se a corrente inical for nula. A unidade de t é segundos. 

>

> restart

> V, R, L := 12, 10, `/`(1, 2)

> EDO := V = `+`(`*`(R, `*`(i(t))), `*`(L, `*`(diff(i(t), t))))
12 = `+`(`*`(10, `*`(i(t))), `*`(`/`(1, 2), `*`(diff(i(t), t)))) (1.8.1.1)
 

> CI := i(0) = 0
i(0) = 0 (1.8.1.2)
 

> sol := dsolve({CI, EDO})
i(t) = `+`(`/`(6, 5), `-`(`*`(`/`(6, 5), `*`(exp(`+`(`-`(`*`(20, `*`(t))))))))) (1.8.1.3)
 

Um indutor normalmente é um solenoide em torno de um íma que resiste a mudança de corrente elétrica, porém não tem nenhuma ação caso a corrente seja constante. Na solução acima, podemos ver que a corrente começa no valor zero e tende ao valor constante `/`(6, 5) quando t vai para o infinito, pois o termo dependente do tempo decai exponencialmente rápido para zero. Note que em menos de 1 segundo a corrente quase se estabiliza, como podemos ver pelo gráfico da corrente (em amperes) versus tempo (em segundos). Isto é consequência do fato da indutância ser uma constante positiva. O termo dependente do tempo é chamado transiente e o termo constante (nesta solução) de estacionário. 

> plot(rhs(sol), t = 0 .. 1, i = 0 .. `/`(6, 5))
Plot_2d
 

 

 

Circuito com resistência, indutor e capacitor (circuito RLC) 

De acordo com a teoria de circuitos elétricos, se uma bateria com voltagem V é ligada em um circuito com um resistor de resistência R, um indutor de indutância L e um capacitor de capacitância C, formando um circuito em série, a equação diferencial associada a este problema é  V = `+`(`/`(`*`(q), `*`(C)), `*`(R, `*`(i)), `*`(L, `*`(diff(i, t)))), onde i é a corrente elétrica e q é a carga elétrica do capacitor. Como i = diff(q, t), podemos derivar os dois lados da equação em função de t para obter  diff(V, t) = `+`(`/`(`*`(i), `*`(C)), `*`(R, `*`(diff(i, t))), `*`(L, `*`(diff(i, t, t)))), para obter uma equação differencial de segunda ordem. 

 

Suponha que uma bateria de 12 volts (que nunca decresce de capacidade) é conectada a  uma circuito LRC em série no qual a resistência é 50 ohms, a indutância é 1/2 henry e a capacitância é 1/1250 farads. Determine a corrente elétrica i se a corrente inical for nula e a carga inicial no capacitor for 1/1000 coulumb. A unidade de t é segundos. 

>

> restart

> V, R, L, C, q0 := 12, 50, `/`(1, 2), `/`(1, 1250), `/`(1, 1000); 1
12, 50, `/`(1, 2), `/`(1, 1250), `/`(1, 1000) (1.8.2.1)
 

> EDO := 0 = `+`(`/`(`*`(i(t)), `*`(C)), `*`(R, `*`(diff(i(t), t))), `*`(L, `*`(diff(i(t), t, t))))
0 = `+`(`*`(1250, `*`(i(t))), `*`(50, `*`(diff(i(t), t))), `*`(`/`(1, 2), `*`(diff(diff(i(t), t), t)))) (1.8.2.2)
 

Uma vez que a EDO deste problema é de segunda ordem, devemos usar duas condições iniciais independentes. As condições iniciais são: corrente nula i(0) = 0 e e carga q0 = `/`(1, 1000). A partir destes valores, podemos encontrar a derivada da corrente no instante t = 0 usando a equação V = `+`(`/`(`*`(q), `*`(C)), `*`(R, `*`(i)), `*`(L, `*`(diff(i, t)))) no instante t=0.  

> CI := i(0) = 0, (D(i))(0) = solve(V = `+`(`/`(`*`(q0), `*`(C)), `*`(R, 0), `*`(L, `*`(x))), x)
CI := i(0) = 0, (D(i))(0) = solve(V = `+`(`/`(`*`(q0), `*`(C)), `*`(R, 0), `*`(L, `*`(x))), x)
i(0) = 0, (D(i))(0) = `/`(43, 2) (1.8.2.3)
 

A solução do problema é 

> sol := dsolve({CI, EDO})
i(t) = `+`(`*`(`/`(43, 2), `*`(exp(`+`(`-`(`*`(50, `*`(t))))), `*`(t)))) (1.8.2.4)
 

cujo gráfico é 

> plot(rhs(sol), t = 0 .. .2, i)
Plot_2d
 

 

Exercício 1 Encontre a corrente máxima no circuito e em que instante isto ocorre. Confira os resultados com os valores obtidos no gráfico. 

 

Exercício 2 Encontre a carga no capacitor e faça o gráfico da carga em função do tempo. Qual é a carga máxima e quando o máximo é atingido? 

Respostas 

`+`(`-`(`*`(`*`(`/`(43, 5000), `+`(`*`(50, `*`(t)), 1)), `*`(exp(`+`(`-`(`*`(50, `*`(t)))))))), `/`(6, 625)),  `/`(6, 625), t = infinity 

 

Exercício 3 No exemplo acima a capacitancia obedece o vínculo C = `+`(`/`(`*`(4, `*`(L)), `*`(`^`(R, 2)))). Faça um exemplo tal que `<`(C, `+`(`/`(`*`(4, `*`(L)), `*`(`^`(R, 2))))), descreva quais são as principais diferenças e explique fisicamente os novos resultados. 

 

 

Exemplo 4 - Curva Tractrix 

A curva tractrix é gerada da seguinte forma. Suponha que uma bola está no ponto (4,0) sobre o eixo x. Uma corda de comprimento 4 é amarrada na bola e a outra extremidade fica no ponto (0,0). Esta extremidade é puxada ao longo do eixo y provocando o deslocamento da bola (com atrito no chão) como mostra a figura abaixo (clique na figura e aperte no play). A curva azul é a tractrix com parâmetro a = 4. 

 

 

Plot_2d 

A equação diferencial da Tractrix é 

>

> restart

> EDO := diff(f(x), x) = `+`(`-`(`/`(`*`(sqrt(`+`(`*`(`^`(a, 2)), `-`(`*`(`^`(x, 2)))))), `*`(x))))
diff(f(x), x) = `+`(`-`(`/`(`*`(`^`(`+`(`*`(`^`(a, 2)), `-`(`*`(`^`(x, 2)))), `/`(1, 2))), `*`(x)))) (1.9.1)
 

cuja solução é 

> sol := simplify(dsolve({EDO, f(a) = 0}, explicit), symbolic)
f(x) = `+`(`*`(a, `*`(ln(`+`(`*`(`^`(`+`(`*`(`^`(a, 2)), `-`(`*`(`^`(x, 2)))), `/`(1, 2))), a)))), `-`(`*`(a, `*`(ln(x)))), `-`(`*`(`^`(`+`(`*`(`^`(a, 2)), `-`(`*`(`^`(x, 2)))), `/`(1, 2))))) (1.9.2)
 

Vamos definir uma função tanto da variável x quanto do parâmetro a: 

> f := unapply(rhs(sol), x, a)
proc (x, a) options operator, arrow; `+`(`*`(a, `*`(ln(`+`(`*`(`^`(`+`(`*`(`^`(a, 2)), `-`(`*`(`^`(x, 2)))), `/`(1, 2))), a)))), `-`(`*`(a, `*`(ln(x)))), `-`(`*`(`^`(`+`(`*`(`^`(a, 2)), `-`(`*`(`^`(x,... (1.9.3)
 

O gráfico mostra a curva (compare com a curva do modelo) 

> plot(f(x, 4), x = 0 .. 4, scaling = constrained)
Plot_2d
 

 

Exercícios 

1. Considere as seguinte EDOs: EDO1 := `+`(`*`(sin(x), `*`(diff(y(x), x))), `-`(`*`(cos(x), `*`(y(x))))) = 0, EDO2 := diff(y(x), x, x) = `+`(`*`(2, `*`(y(x))), 1) e  EDO3 := `+`(diff(y(x), x), `/`(`*`(8, `*`(y(x))), `*`(`+`(x, 9)))) = `*`(`^`(sin(x), 2)). 

a) y(x) = `*`(c, `*`(sin(x))), onde c é uma constante, é solução de EDO1? 

b) y(x) = `+`(`*`(a1, `*`(sin(x))), a2), onde a1 e a2 são constantes, é solução de EDO2? 

c) y(x) = `/`(`*`(`^`(cos(x), 2)), `*`(`+`(x, 9))) é solução de EDO3? 

 

2. O objetivo deste exercício é encontrar uma ODE e as condições iniciais obedecendo às seguintes restrições: 

(a) Encontre uma ODE sem funções trigonométricas de primeira ordem com uma condição inicial cuja solução é tan(x). 

(b) Encontre uma ODE linear de primeira ordem com uma condição inicial cuja solução é tan(x). 

(c) Encontre uma ODE sem funções trigonométricas de segunda ordem com duas condições iniciais cuja solução é tan(x). 

(d) Encontre uma ODE linear de segunda ordem com duas condições iniciais cuja solução é tan(x). 

 

3. A equação diferencial de uma corrente suspensa presa nas extremidades é `*`(`^`(diff(y(x), x, x), 2)) = `*`(`^`(k, 2), `*`(`+`(1, `*`(`^`(diff(y(x), x), 2))))). 

(a) Encontre a solução da equação diferencial correspondente a corrente sob ação da gravidade presa nas extremidades (as extremidades têm a mesma altura y = 0). 

(b) Faça o gráfico da solução para k = 1 para uma corda de comprimento 1. 

(c) Encontre o valor de k tal que a posição mínima da corda no eixo vertical é -1 para uma corda de comprimento 1. 

 

Sugestões 

 

1. Substitua a função na EDO e tente simplificar até verificar uma igualdade. Note que não há necessidade de resolver a EDO. 

 

2. Escreva y(x) = tan(x) e depois derive ambos os lados em função de x. 

 

3. Considere uma corda presa nos pontos x = 0 e x = 1, onde y(x) é o deslocamento da corda. Note que `<`(y(x), 0) para `and`(`<`(0, x), `<`(x, 1)). Lembre que diff(y(x), x) = diff(y(x), x).