Maple Avançado

Prévia do material em texto

UNIVERSIDADE FEDERAL DE SANTA MARIA 
CENTRO DE CIÊNCIAS NATURAIS E EXATAS 
DEPARTAMENTO DE MATEMÁTICA 
 
 
 
 
TÓPICOS DE ÁLGEBRA LINEAR, EDO'S E PROGRAMAÇÃO NO MAPLE 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ALISSON DARÓS SANTOS 
DANIELA DE ROSSO TOLFO 
LEONEL GIACOMINI DELATORRE 
 
SUMÁRIO 
 
 
INTRODUÇÃO ..................................................................................................................... 4 
CAPÍTULO 1. UTILITÁRIOS .................................................................................................... 5 
1.1 AJUDA NO MAPLE: HELP............................................................................................ 5 
1.2 PACOTES .................................................................................................................. 6 
1.3 INSTRUÇÕES BÁSICAS ................................................................................................. 6 
1.4 FUNÇÕES .................................................................................................................. 7 
1.5 SOMATÓRIOS ............................................................................................................ 9 
1.6 PRODUTÓRIO ........................................................................................................... 9 
1.7 LIMITES ..................................................................................................................... 9 
1.8 DERIVADAS ............................................................................................................... 9 
1.9 INTEGRAIS INDEFINIDAS .............................................................................................. 9 
1.10 INTEGRAIS DEFINIDAS ............................................................................................... 9 
CAPÍTULO 2. ÁLGEBRA LINEAR ............................................................................................ 10 
2.1 COMANDOS E OPERAÇÕES BÁSICAS COM MATRIZES ..................................................... 10 
2.2 MATRIZES CUJAS ENTRADAS SÃO FUNÇÕES ................................................................... 14 
2.3 POSTO DE UMA MATRIZ, PRODUTO ESCALAR, PRODUTO VETORIAL E NORMA DE VETORES ... 15 
2.4 AUTOVALORES E AUTOVETORES ................................................................................. 16 
2.5 NULLSPACE DE UMA MATRIZ A ................................................................................... 18 
2.6 PROCESSO DE ORTOGONALIZAÇÃO DE GRAM-SCHIMIDT ............................................... 19 
2.7 FORMA CANÔNICA DE JORDAN .................................................................................. 20 
2.8 ELIMINAÇÃO GAUSSIANA .......................................................................................... 23 
2.9 RESOLUÇÃO DE SISTEMAS .......................................................................................... 23 
CAPÍTULO 3. EQUAÇÕES DIFERENCIAIS ORDINÁRIAS .............................................................. 28 
3.1 COMANDOS BÁSICOS ............................................................................................... 28 
3.2 COMANDOS ESPECÍFICOS DE EDO’S DE PRIMEIRA ORDEM ............................................ 29 
3.3 CAMPO DE DIREÇÕES PARA EQUAÇÕES DIFERENCIAIS DE PRIMEIRA ORDEM ...................... 31 
3.3 PLANOS DE FASE ...................................................................................................... 34 
3.4 EQUAÇÃO DO PÊNDULO .......................................................................................... 36 
CAPÍTULO 4. PROGRAMAÇÃO ............................................................................................. 42 
4.1 COMANDOS BÁSICOS ............................................................................................... 42 
4.2 PROCEDIMENTOS NO MAPLE ................................................................................... 45 
BIBLIOGRAFIA ................................................................................................................... 49 
 
 
 
Introdução 
 
 
 
Esta apostila foi desenvolvida como material de apoio ao Minicurso MAPLE 
Avançado, organizado pelo Grupo PET Matemática – Programa de Educação Tutorial. Os 
minicursos, bem como o material didático desenvolvido, surgem como uma proposta de 
qualificar a formação de bolsistas e acadêmicos na utilização de novas tecnologias 
aplicadas ao ensino e à pesquisa. 
Neste material serão revistos alguns comandos básicos do MAPLE que podem ser 
utilizados no cálculo de limites, derivadas e integrais, porém o enfoque principal está no 
uso do MAPLE como ferramenta auxiliar em disciplinas como Álgebra Linear, Equações 
Diferenciais Ordinárias, além de disciplinas que envolvam programação. 
Pretendemos fazer uma abordagem sobre os comandos que, em nossa experiência 
de utilização do software, foram mais relevantes. Isso não quer dizer que outros 
comandos ou tópicos sejam menos importantes, mas sim que o material desenvolvido 
baseia-se, principalmente, nas necessidades de utilização do MAPLE até o presente 
momento. Além disso, nossos conhecimentos são restritos quando comparados à 
amplitude e às abrangentes possibilidades de utilização do mesmo. 
CAPÍTULO 1. UTILITÁRIOS 
 
1.1 AJUDA NO MAPLE: HELP 
 
O help é uma maneira de conseguir ajuda caso você saiba exatamente o tópico a 
respeito do qual você necessita de informações. Existem pelo menos duas formas de 
acessá-lo: 
1ª Na aba Help 
 
 
 
 
 
 
2ª Solicitando a abertura do help a partir do 
comando “?” seguido do tópico a ser 
pesquisado. 
 
Exemplo: 
>?matrix; 
 
Que conduzirá a seguinte janela: 
 
 
 
 
1.2 PACOTES 
 
Alguns comandos do MAPLE são de uso específico, por isso são agrupados em 
pacotes (packages). Para ativar um pacote do MAPLE, utiliza-se o comando: with(nome 
do pacote), veja 
>with(LinearAlgebra): 
 
Alguns pacotes disponíveis ao usuário são: plots, linalg, DEtools, LinearAlgebra, Students. 
 
1.3 INSTRUÇÕES BÁSICAS 
 
O comando restart permite limpar a memória armazenada no MAPLE em 
qualquer parte do documento. É aconselhável seu uso sempre no início de um novo 
arquivo. 
>restart: 
O MAPLE aceita a troca de linhas dentro de um mesmo comando, para isso 
utiliza-se as teclas SHIFT e ENTER simultaneamente na hora em que deseja-se a troca de 
linha. 
Ao final de cada comando pode-se utilizar ponto e vírgula (;) ou dois pontos (:). A 
utilização do ponto e vírgula tornará visível ao usuário o resultado do comando utilizado, 
no caso de utilizar dois pontos a visualização será ocultada. Ex.: 
>A:=Matrix([[1,2],[4,5]]); 
 
>A:=Matrix([[1,2],[4,5]]): 
 
Para declarar uma variável inteira utilizamos o seguinte comando. 
>restart: 
>assume(n,integer); 
>cos(n*Pi); 
 
>cos((2*n-1)*Pi); 
 
>cos(2*n*Pi); 
 
Dado um número complexo, podemos encontrar sua parte real e imaginária da 
seguinte forma: 
 := A 





1 2
4 5
( )-1 n~
-1
1
>Re(4+I);; 
 
>Im(1+3*I); 
 
Um comando bastante utilizado é o solve, com o qual podemos encontrar tanto 
soluções de equações quanto sistemas de equações: 
>solve(2*x+y=0,x); 
 
>solve( {2*a + b = 1, a+2*b=0}, [a,b]); 
 
 
Exercício: 
1. Aplique o comando solve ao sistema de equações e comente a solução encontrada. 
 
2𝑎 + 𝑏 + 𝑐 = 1
𝑎 + 2𝑏 + 𝑐 = 0
5𝑎 + 4𝑏 + 3𝑐 = 2
 
 
1.4 FUNÇÕES 
 
Uma maneira para definirmos uma função no MAPLE é usarmos o operador seta (-
>, isto é, sinal de menos seguido do sinal demaior). Por exemplo: 
>g:= x ->x^2 + 1; 
 
>g(4); 
 
Devemos definir a função desta maneira porque da forma como atribuímos 
anteriormente o MAPLE apenas nos daria o valor de f(x), vejamos: 
>f(x):=x^2+1*x+1=0; 
 
>solve (f(x)); 
 
Nesta forma o MAPLE apenas sabe encontrar valores para a função x é 
𝒙𝟐 + 𝒙 + 𝒙 = 𝟎. Mas se pedirmos algum outro ele não sabe. Por exemplo, o valor de f no 
ponto f(2). 
4
3

y
2











,a
2
3
b
-1
3
 := g x x2 1
17
 := ( )f x  x2 x 1 0
, 
1
2
1
2
I 3  
1
2
1
2
I 3
>f(2); 
 
>g:= piecewise(x<-1,x+2,x>=-1 and x<1,x^2,x^3); 
 
 
>plot(g,x=-1.5..1.5,thickness=2,scaling=constrained); 
 
 
 
Abaixo apresentamos uma pequena lista da sintaxe de algumas funções 
matemáticas no MAPLE (lembre-se que o MAPLE é escrito em inglês): 
 funções trigonométricas: sin(x), cos(x), tan(x), cot(x), sec(x), csc(x); 
 funções trigonométricas inversas: arcsin(x), arccos(x), arctan(x), arccot(x), 
arcsec(x), arccsc(x); 
 função exponencial de base e: exp(x); 
 função logarítmica de base e: ln(x); 
 função logarítmica de base a, sendo a>0 qualquer: log[a](x); 
 funções hiperbólicas: sinh(x), cosh(x), tanh(x), sech(x), csch(x), coth(x); 
 funções hiperbólicas inversas: arcsinh(x), arccosh(x), arctanh(x), arcsech(x), 
arccsch(x), arccotgh(x). 
 
Para acessar informações sobre essas e outras funções no MAPLE, utiliza-se o comando: 
 
( )f 2
 := g








x 2 x -1
x2 and -1 x x 1
x3 otherwise
>?inifcn 
 
que irá redirecionar ao help do MAPLE. 
 
1.5 SOMATÓRIOS 
>Sum(1/n^2, n=1..infinity)=sum(1/n^2, n=1..infinity); 
 
1.6 PRODUTÓRIO 
>Product(1/n, n=1..30)=product(1/n, n=1..30); 
 
1.7 LIMITES 
>Limit(x^2*sin(1/x), x=0)=limit(x^2*sin(1/x), x=0); 
 
 
1.8 DERIVADAS 
>Diff(x^2*sin(1/x),x$1)=diff(x^2*sin(1/x),x$1); 
 
 
1.9 INTEGRAIS INDEFINIDAS 
>Int(x^2, x)=int(x^2, x); 
 
 
1.10 INTEGRAIS DEFINIDAS 
>Int(x^2, x=1..3)=int(x^2, x=1..3); 
 
 
 

n 1

1
n2
2
6

n 1
30
1
n
1
265252859812191058636308480000000
lim
x 0
x2 




sin
1
x
0

d
d
x





x
2 




sin
1
x
2 x 




sin
1
x





cos
1
x
d

x
2 x
x3
3
d


1
3
x2 x
26
3
CAPÍTULO 2. ÁLGEBRA LINEAR 
 
2.1 COMANDOS E OPERAÇÕES BÁSICAS COM MATRIZES 
 
Os pacotes utilizados neste capítulo serão essencialmente: LinearAlgebra e linalg. 
Estes, embora relativos à Álgebra Linear, diferem em alguns comandos. Pensando nisso, 
na medida do possível, será trabalhado paralelamente com os dois pacotes. 
Para dar início ao trabalho com matrizes, serão apresentados alguns comandos 
básicos relativos a este tópico. 
 
2.1.1 Declarando matrizes e vetores 
 
Existem várias formas de declarar matrizes e vetores no MAPLE, destacamos as seguintes: 
Utilizando o pacote LinearAlgebra 
>restart: 
>with(LinearAlgebra): 
>A:=Matrix(2,3,[a,b,c,d,e,f]); 
 
 
>B:=Matrix(3,2,[[1,7],[5,6]]); 
 
>C:=Matrix([[1,2],[4,5]]); 
 
 
>v:=Vector(3,[a,b,c]); 
 
 
 
Utilizando o pacote linalg 
>restart: 
>with(linalg): 
>A:=matrix(2,3,[a,b,c,d,e,f]); 
 
 := A 





a b c
d e f
 := B












1 7
5 6
0 0
 := C 





1 2
4 5
 := v












a
b
c
 := A 





a b c
d e f
>v:=vector(3,[a,b,c]); 
 
2.1.2 Matriz Nula e Matrizes Identidade 
 
A matriz identidade e a matriz nula podem ser obtidas da seguinte forma: 
>restart: 
>with(LinearAlgebra): 
>Iden:=IdentityMatrix(3); 
 
>N:=Matrix(2,3); 
 
>ZeroMatrix(2); 
 
>ZeroVector(2); 
 
ou 
>restart: 
>with(linalg): 
>N:=matrix(2,2,0); 
 
>M:=Matrix(3,3,shape=identity); 
 
 
2.1.3 Operações básicas 
 
Sejam as matrizes 
>with(LinearAlgebra): 
>A:=Matrix(2,2,[[4,6],[0,5]]); 
 
 := v












a
b
c
 := Iden












1 0 0
0 1 0
0 0 1
 := N 





0 0 0
0 0 0






0 0
0 0






0
0
 := N 





0 0
0 0
 := M












1 0 0
0 1 0
0 0 1
 := A 





4 6
0 5
>B:=Matrix(2,2,[[1,4],[9,-1]]); 
 
e os vetores 
 
>v:=Vector(2,[[1],[-1]]); 
 
>u:=Vector(2,[[2],[-3]]); 
 
 
ADIÇÃO DE MATRIZES E VETORES 
>A+B; 
 
>A+(-B); 
 
>v+u; 
 
>v+(-u); 
 
MULTIPLICAÇÃO DE MATRIZES E VETORES 
>Multiply(A,B); 
 
>Multiply(A,u); 
 
 
DETERMINANTE 
>Determinant(A); 
 
TRAÇO DA MATRIZ 
Soma dos elementos da diagonal 
>Trace(A); 
 := B 





1 4
9 -1
 := v 





1
-1
 := u 





2
-3






5 10
9 4






3 2
-9 6






3
-4






-1
2






58 10
45 -5






-10
-15
20
 
TRANSPOSTA DE UMA MATRIZ 
>Transpose(A); 
 
MATRIZ INVERSA 
>MatrixInverse(A); 
 
Vamos verificar se esta realmente é a matriz inversa 
 
>Multiply(A,MatrixInverse(A)); 
 
>Multiply(MatrixInverse(A),A); 
 
Consideremos a matriz 
>C:=Matrix(2,2,[[3,1],[3,1]]); 
 
utilizando o comando para obter a matriz inversa resulta 
>MatrixInverse(C); 
Error, (in LinearAlgebra:-LA_Main:-MatrixInverse) singular matrix 
 
O MAPLE neste caso acusa que a matriz Cé singular ou seja seu determinante é 
zero, o que leva a matriz a não ser inversível. 
>Determinant(C); 
 
ELIMINAÇÃO DE LINHAS E COLUNAS DA MATRIZ 
>restart: 
>with(LinearAlgebra): 
>G:=Matrix(3,3,[[2,-1,3],[4,7,8],[9,0,4]]); 
 
>DeleteColumn(G,3); 
 
9






4 0
6 5
















1
4
-3
10
0
1
5






1 0
0 1






1 0
0 1
 := C 





3 1
3 1
0
 := G












2 -1 3
4 7 8
9 0 4












2 -1
4 7
9 0
>DeleteRow(G,[1,3]); 
 
 
2.2 MATRIZES CUJAS ENTRADAS SÃO FUNÇÕES 
 
Vamos agora trabalhar com matrizes cujas entradas são funções de uma variável 
>F:=Matrix(2,2,[[x,1],[x^2-1,0]]); 
 
 
Caso se queira calcular o valor de cada coordenada quando 𝑥 = 0podemos usar o 
comando 
>subs(x=0,F); 
 
Comando este que também é válido para funções 
>f:=x^2+1; 
 
>subs(x=1,f); 
 
O comando Mappercorre cada coordenada da matriz realizando nessa a operação 
desejada. Vejamos algumas aplicações deste comando: 
Neste exemplo estamos somando 2 a cada coordenada da matriz em questão. 
>Map(x->x+2,F); 
 
Pode-se dessa forma obter também a derivada das entradas da matriz 
>Map(diff,F,x); 
 
e também sua integral 
>Map(int,F,x); 
 
 := F








x 1
x2 1 0






0 1
-1 0
 := f x2 1
2







x 2 3
x2 1 2






1 0
2x 0


















x2
2
x

1
3
x3 x 0
[ ]4 7 8
2.3 POSTO DE UMA MATRIZ, PRODUTO ESCALAR, PRODUTO VETORIAL E NORMA DE 
VETORES 
 
Dada uma matriz A o posto da matriz pode ser calculado utilizando o comando 
Rank(A), no pacote LinearAlgebra. Vejamos alguns exemplos: 
>restart: 
>with(LinearAlgebra): 
>A:=Matrix(3,3,[1,3,2,4,7,1,6,13,5]); 
 
>Rank(A); 
 
>B:=Matrix(2,2,[1,4,9,5]); 
 
>Rank(B); 
 
>C:=Matrix(2,3,[1,3,5,4,3,7]); 
 
>Rank(C); 
 
Vamos agora apresentar comandos que forneçam produto escalar, produto vetorial 
norma e ângulo entre dois vetores. Dados dois vetores, 𝑢, 𝑣 vejamos os comandos 
relativos a estas operações. 
>with(LinearAlgebra): 
>v:=Vector(3,[1,2,2]); 
 
>w:=Vector(3,[1,2,-1]); 
 
2.3.1 PRODUTO ESCALAR 
>DotProduct(v,w); 
 
2.3.2 PRODUTO VETORIAL 
>CrossProduct(v,w); 
 := A












1 3 2
4 7 1
6 13 5
2
 := B 





1 4
9 5
2
 := C 





1 3 5
4 3 7
2
 := v












1
2
2
 := w












1
2
-1
3
 
2.3.3 NORMA DE UM VETOR 
>VectorNorm(v,2); 
 
>VectorNorm(w,2); 
 
2.3.4 ÂNGULO ENTRE DOIS VETORES 
O ângulo entre dois vetores pode ser encontrado a partir do produto interno como: 
𝜃 = 𝑎𝑟𝑐𝑐𝑜𝑠
𝑣 ∙ 𝑤
 𝑣 |𝑤|
 
O MAPLE possui um comando específico para calcular o ângulo dado por: 
>theta:=VectorAngle(v,w); 
 
Resultado que confere com a fórmula para 𝜃 dada acima. 
 
2.4 AUTOVALORES E AUTOVETORES 
 
Definição: (autovalor e autovetor) 
 Seja 𝐴 uma matriz quadrada. Um escalar 𝜆 é chamado de autovalor de 𝐴 se existe 
um vetor 𝑣 não nulo tal que 
𝐴𝑣 = 𝜆𝑣 
qualquer vetor satisfazendo esta relação é chamado de autovetor de 𝐴 associado ao 
autovalor 𝜆. 
Os autovalores e autovetores da matriz 𝐴 podem ser calculados através do sistema 
 𝐴 − 𝜆𝐼 𝑣 = 0 
O qual tem solução se 
𝑑𝑒𝑡 𝐴 − 𝜆𝐼 = 0 
já que 𝑣 ≠ 0por definição. O polinômio 𝑝 𝜆 = det⁡(𝐴 − 𝜆𝐼) é chamado característico 
que será um polinômio de grau 𝑛 em 𝜆. 
 
Cálculo do polinômio característico 
>restart: 
with(LinearAlgebra): 
>A:=Matrix(2,2,[[4,2],[3,-1]]); 
 
 












-6
3
0
3
6
 := 





arccos
6
6
 := A 





4 2
3 -1
>Determinant(A-lambda*IdentityMatrix(2)); 
 
 
Ou simplesmente 
>p(lambda):=CharacteristicPolynomial(A,lambda); 
 
 
 
Para encontrarmos os autovalores através do polinômio característico resolvemos 
>solve(p(lambda)=0); 
 
No MAPLE existem comandos específicos para calcular os autovalores e 
autovetores de uma matriz 𝐴 sem utilizarmos explicitamente o polinômio característico. 
 
2.4.1 AUTOVALORES 
 
Abaixo temos um comando para encontrar os autovalores de 𝐴 
 
>Eigenvalues(A); 
 
Caso queira o primeiro ou o segundo autovalor separadamente, podemos usar o 
comando a seguir 
 
>Eigenvalues(A)[1]; 
 
>Eigenvalues(A)[2]; 
 
 Utilizar o comando Eigenvalues é equivalente a encontrarmos as raízes do 
polinômio característico de 𝐴. 
 
2.4.2 AUTOVETORES 
 
Agora vamos encontrar os autovetores de 
>(v,e):=Eigenvectors(A); 
 
 
  10 3 2
 := ( )p    10 3 2
,5 -2






5
-2
5
-2
P
 := ,v e ,






5
-2












2
-1
3
1 1
Aqui o vetor 𝑣 nos fornece os autovalores de 𝐴 e a matriz 𝑒 os autovetores de 𝐴 de 
forma que a i-ésima coluna de 𝑒 é autovetor associado i-ésimo elemento de 𝑣. Ou seja, 
para este exemplo, 𝑣1= 
−
1
3
1
 é autovetor associado ao autovalor -2, e 𝑣2 = 
2
1
 é 
autovetor associado ao autovalor 5. 
O uso do comando Eigenvectors é equivalente a resolvermos o sistema 
 𝐴 − 𝜆𝐼 𝑣 = 0, 
no qual é autovalor e 𝑣 autovetor. 
 
Exercício: 
1. Verifique se as soluções encontradas satisfazem 𝐴𝑣 = 𝜆𝑣. 
Solução: 
>v1:=DeleteColumn(e,2); 
 
>Multiply(A,v1); 
 
>v2:=DeleteColumn(e,1); 
 
>Multiply(A,v2); 
 
2.5 NULLSPACE DE UMA MATRIZ A 
 
Por definição é o subepaço gerado pelos vetores que são solução de𝐴𝑥 = 0, 𝑥um 
vetor. 
 
>restart: 
>with(LinearAlgebra): 
>A:=Matrix(2,2,[[1,2],[3,6]]); 
 
>NullSpace(A); 
 
Nullspace de 𝐴 é o núcleo de 𝐴, e o comando Nullspace(A) nos dá uma base para 
o núcleo de 𝐴. 
Outro exemplo: 

 := v1 





2
1






10
5
 := v2












-1
3
1












2
3
-2
 := A 





1 2
3 6
{ }






-2
1
>B:=Matrix(3,3,[[1,1,2],[2,2,4],[3,3,6]]); 
 
>NullSpace(B); 
 
 
2.6 PROCESSO DE ORTOGONALIZAÇÃO DE GRAM-SCHIMIDT 
 
Dado um conjunto LI de vetores a aplicação do processo de ortogonalização de 
Gram-Schimidt fornece um conjunto LI de vetores ortogonais. No MAPLE o comando 
GramSchmidtrealiza este processo. 
 
>restart: 
>with(LinearAlgebra): 
 
>vv:=Vector(4,a); 
 
Declaramos os vetores 
 
>v[1]:=Vector(4,[[1],[1],[1],[1]]): 
>v[2]:=Vector(4,[[1],[2],[4],[5]]): 
>v[3]:=Vector(4,[[1],[-3],[-4],[-2]]): 
>ord:=GramSchmidt([v[1],v[2],v[3]]); 
 
 
 
 Caso seja necessário obter um conjunto de vetores ortonormais, procede-se: 
 := B












1 1 2
2 2 4
3 3 6
 := vv


















( )a 1
( )a 2
( )a 3
( )a 4
 := ord






































, ,


















1
1
1
1


















-2
-1
1
2






































8
5
-17
10
-13
10
7
5













,












-2
0
1












-1
1
0
>GramSchmidt({v[1],v[2],v[3]},normalized); 
 
 
Exercício: 
1. Aplique os comandos para calcular norma de um vetor e produto escalar para verificar 
se no exemplo anterior os vetores encontrados são unitários e ortogonais entre si. 
Solução: 
>DotProduct(s[1],s[1]); 
 
>DotProduct(s[2],s[2]); 
 
>DotProduct(s[3],s[3]); 
 
Daí concluímos que os vetores obtidos são unitários. 
>DotProduct(s[1],s[2]); 
 
>DotProduct(s[1],s[3]); 
 
>DotProduct(s[2],s[3]); 
 
E então que são dois a dois ortogonais. 
 
2.7 FORMA CANÔNICA DE JORDAN 
 
Dado um operador linear 𝑇 podemos escrever a Forma de Canônica de Jordan 
deste operador. A Forma Canônica de Jordan é descrita pelo seguinte teorema: 
 









































, ,








































30
30

30
10

2 30
15

30
15







































61 12570
12570

11 12570
4190

2 12570
6285
44 12570
6285








































303 38129
76258
207 38129
76258

38129
5866

19 38129
10894
1
1
1
0
0
0
Teorema:Seja 𝑇: 𝑉 → 𝑉 um operador linear cujos polinômio mínimo e o 
polinômio característico são, respectivamente, 
𝑚 𝑥 = 𝑥 − 𝜆1 
𝑟1 ∙ 𝑥 − 𝜆2 
𝑟2 ∙ ⋯ ∙ 𝑥 − 𝜆𝑟 
𝑟𝑘 
e 
𝑝 𝑥 = 𝑥 − 𝜆1 
𝑠1 ∙ 𝑥 − 𝜆2 
𝑠2 ∙ ⋯ ∙ 𝑥 − 𝜆𝑟 
𝑠𝑘 
Onde os 𝜆𝑖 são escalares distintos. Então 𝑇 possui uma representação matricial 
diagonal por blocos, onde cada elemento diagonal é um bloco de Jordan 𝐽𝑖𝑗 = 𝐽(𝜆𝑖). Para 
cada 𝜆𝑖𝑗 , o bloco 𝐽𝑖𝑗 correspondente possui as seguintes propriedades: 
(i) Existe ao menos um 𝐽𝑖𝑗 de ordem 𝑟𝑖; todos os outros 𝐽𝑖𝑗 são de ordem 
≤ 𝑟𝑖 . 
(ii) A soma das ordens dos 𝐽𝑖𝑗 é 𝑠𝑖 . 
(iii) A quantidade dos 𝐽𝑖𝑗 é a multiplicidade geométrica de 𝜆𝑖 . 
(iv) A quantidade dos blocos 𝐽𝑖𝑗 de uma ordem qualquer possível é unicamente 
determinada por 𝑇. 
Exemplo 1: 
> restart: 
> with(LinearAlgebra): 
> T:=Matrix(2,2,[3,1,2,2]); 
 
> p(x):=factor(CharacteristicPolynomial(T,x)); 
 
 
>m(x):=factor(MinimalPolynomial(T,x)); 
 
 
>J:=JordanForm(T); 
 
Exercício: Verifique que no exemplo anterior os autovalores da matriz T, utilizando o 
comando Eigenvalues. 
 
Observação: 
Cabe aqui lembrar que uma matriz é diagonalizável se o polinômio minimal é mônico. 
 
 := T 





3 1
2 2
 := ( )p x ( )x 1 ( )x 4
 := ( )m x ( )x 1 ( )x 4
 := J 





1 0
0 4
>Eigenvectors(T); 
 
Exercício: Verifique se a matriz é diagonalizável, calculando os 
polinômios minimal e característico da matriz do operador. Em seguida calcule a forma 
canônica de Jordan. 
>restart: 
>with(LinearAlgebra): 
>T:=Matrix(3,3,[3,1,-1,2,2,-1,2,2,0]); 
 
>p(x):=factor(CharacteristicPolynomial(T,x)); 
 
 
>m(x):=factor(MinimalPolynomial(T,x)); 
 
 
>J:=JordanForm(T); 
 
Exercício: Dada a matriz calcule o polinômio característico e minimal, 
conclua se a matriz é diagonalizável. E então calcule a Forma Canônica de Jordan. 
>restart: 
>with(LinearAlgebra): 
>T:=Matrix(3,3,[1,1,0,-1,3,0,-1,1,2]); 
 
>p(x):=factor(CharacteristicPolynomial(T,x)); 
 
 
>m(x):=factor(MinimalPolynomial(T,x)); 
 
 
,






4
1












1
-1
2
1 1
 := T












3 1 -1
2 2 -1
2 2 0
 := T












3 1 -1
2 2 -1
2 2 0
 := ( )p x ( )x 1 ( )x 2 2
 := ( )m x ( )x 1 ( )x 2 2
 := J












1 0 0
0 2 1
0 0 2
 := T












1 1 0
-1 3 0
-1 1 2
 := T












1 1 0
-1 3 0
-1 1 2
 := ( )p x ( )x 2 3
 := ( )m x ( )x 2 2
>J:=JordanForm(T); 
 
 
2.8 ELIMINAÇÃO GAUSSIANA 
 
Dada uma matriz de ordem qualquer o comando GaussianElimination: 
 
> restart:with(LinearAlgebra): 
> B:=Matrix(2,3,[1,2,3,1,3,2]); 
 
> GaussianElimination(B); 
 
> C:=Matrix(2,2,[1,2,5,2]); 
 
> GaussianElimination(C); 
 
 
2.9 RESOLUÇÃO DE SISTEMAS 
 
Modelando situações reais podemos nos deparar com diferentes tipos de sistemas. 
Aqui serão abordados alguns métodos para resolução de sistemas lineares. 
Exemplo: 
(Fuvest 2008) João entrou na lanchonete BOG e pediu 3 
hambúrgueres, 1 suco de laranja e 2 cocadas, gastando R$ 
21,50. Na mesa ao lado, algumas pessoas pediram 8 
hambúrgueres, 3 sucos de laranja e 5 cocadas, gastando R$ 
57,00. Sabendo-se que o preço de um hambúrguer, mais o de 
um suco de laranja, mais o de uma cocada totaliza R$ 10,00, 
calcule o preço de cada um desses itens. 
 
Para resolver esse problema escrevemos cada afirmação como uma equação 
matemática. Assim se chamarmos de 𝑥1 o preço do hambúrguer, 𝑥2 o preço do suco de 
laranja e 𝑥3o preço da cocada temos o seguinte sistema de equações. 
 
 := J












2 1 0
0 2 0
0 0 2
 := B 





1 2 3
1 3 2






1 2 3
0 1 -1
 := C 





1 2
5 2






1 2
0 -8
 
3𝑥1 + 𝑥2 + 2𝑥3 = 21,50
8𝑥1 + 3𝑥2 + 5𝑥3 = 57
𝑥1 + 𝑥2 + 𝑥3 = 10
 
 
Matricialmente pode-se escrever 
 
𝐴𝑥 = 𝑏 ⇒ 
3 1 2
8 3 5
1 1 1
 × 
𝑥1
𝑥2
𝑥3
 = 
21,5
57
10
 
sendo 
𝐴 = 
3 1 2
8 3 5
1 1 1
 , 𝑏 = 
21,5
57
10
 e𝑥 = 
𝑥1
𝑥2
𝑥3
 
 
Sabemos que o sistema tem uma única solução se o determinante da matriz 𝐴 for 
diferente de zero. Vejamos: 
 
>restart: 
>with(LinearAlgebra): 
>A:=Matrix([[3,1,2],[8,3,5],[1,1,1]]); 
 
 
>b:=Vector([[21.5],[57],[10]]); 
 
 
 
>Determinant(A); 
 
Como det 𝐴 ≠ 0 sabe-se que a matriz 𝐴 é inversível, desta forma podemos calcular: 
>x:=Multiply(MatrixInverse(A),b); 
 
 := A












3 1 2
8 3 5
1 1 1
 := b












21.5
57
10
1
 
 
Assim obtemos os seguintes valores das mercadorias: 
 
𝑥1 = 4, 𝑥2 = 2,5 e 𝑥3 = 3,5 
 
Pode-se resolver esse sistema utilizando o comando: 
>LinearSolve(A,b); 
 
 
 
Existem vários tipos de decomposição de matrizes que permitem resolver sistemas 
lineares, como Fatoração LU, Fatoração de Cholesky, Fatoração LDU, Decomposição 
QR, Decomposição em valores singulares (SVD). Abordaremos aqui apenas a Fatoração 
LU e Fatoração de Cholesky. 
 
 
2.9.1 Fatoração LU 
 
Dado o sistema 𝐴𝑥 = 𝑏, 𝐴 matriz quadrada e não singular, a fatoração LU permite 
escrever a matriz 𝐴 como o produto de duas matrizes 𝐿 e 𝑈, sendo 𝐿 uma matriz 
triangular inferior (Low) e 𝑈 uma matriz triangular superior (Upper). 
Se pudermos realizar a fatoração 𝐴 = 𝐿𝑈, o sistema linear pode ser escrito como: 
 
 𝐿𝑈 𝑥 = 𝑏 
𝐿 𝑈𝑥 = 𝑏 
 
Para calcularmos o vetor 𝑥 resolveremos dois sistemas lineares: 
𝑈𝑥 = 𝑦 
e posteriormente 
 := x












4.
2.50000000000000000
3.50000000000000000












4.
2.50000000000000000
3.50000000000000000
𝐿 𝑦 = 𝑏. 
O camandoLUDecomposition(A) do MAPLE nos fornece, dada uma matriz 𝐴, os 
fatores 𝐿, 𝑈 e a matriz de permutação. 
 
>(p,L,U):=LUDecomposition(A,method='GaussianElimination'); 
 
 
A matriz p, chamada matriz de permutação, determina o pivoteamento realizado. 
Agora vamos resolver os sistemas determinados pela fatoração: 
>Pb:=Multiply(p,b); 
 
>y:=LinearSolve(L,Pb); 
 
 
>x:=LinearSolve(U,y); 
 
 
 
Como a matriz permutação altera as linhas do sistema, a mesma deve ser 
multiplicada pelo vetor 𝑏 a fim de realizar a mesma permutação neste vetor. Como no 
exemplo anterior a matriz de permutação é a identidade as linhas do vetor 𝑏 não serão 
alteradas, mas é importante prestar atenção a este detalhe, pois 𝑝 = 𝐼 não é um caso 
geral. 
 
 := , ,p L U , ,












1 0 0
0 1 0
0 0 1






















1 0 0
83
1 0
1
3
2 1


















3 1 2
0
1
3
-1
3
0 0 1
 := Pb












21.5
57.
10.
 := y












21.5000000000000000
-0.333333333333330151
3.49999999999999422
 := x












4.00000000000000266
2.50000000000000356
3.49999999999999422
2.9.2 Fatoração de Cholesky 
 
Esta fatoração propõe decompor a matriz 𝐴 simétrica e definida positiva do 
sistema 𝐴𝑥 = 𝑏, como produto de uma matriz por sua transposta, ou seja, 
𝐴 = 𝐺𝐺𝑇 
Sendo 𝐺 uma matriz triangular inferior com os elementos da diagonal estritamente 
positivos. 
>A:=Matrix(4,4,[16,-4,12,-4,-4,2,-1,1,12,-1,14,-2,-4,1,-2,83]); 
 
>G:=LUDecomposition(A,method='Cholesky'); 
 
>Gt:=Transpose(G); 
 
Onde verificamos que 
>Multiply(G,Gt); 
 
 
 
 := A


















16 -4 12 -4
-4 2 -1 1
12 -1 14 -2
-4 1 -2 83
 := G


















4 0 0 0
-1 1 0 0
3 2 1 0
-1 0 1 9
 := Gt


















4 -1 3 -1
0 1 2 0
0 0 1 1
0 0 0 9


















16 -4 12 -4
-4 2 -1 1
12 -1 14 -2
-4 1 -2 83
CAPÍTULO 3. EQUAÇÕES DIFERENCIAIS ORDINÁRIAS 
 
Para obter resultados relacionados a equações diferenciais ordinárias no MAPLE 
utilizamos o pacote DEtools. Esse pacote permite encontrar a solução de algumas 
equações, resolver problemas de valor inicial, plotar o gráfico de suas soluções e plotar o 
campo de direções. 
3.1 COMANDOS BÁSICOS 
 
Para declarar uma EDO precisamos identificar a ordem de cada derivada presente 
na equação. Por exemplo, se quisermos declarar a derivada de ordem 𝑛 de uma 
função𝑦no MAPLE, escrevemos: 
>diff(y(t),t$n); 
 
Dessa forma, para declararmos uma equação diferencial no MAPLE escrevemos: 
 
> edo:=diff(y(t),t$2)-5*y(t)=2*cos(t); 
 
 
 
Para resolvermos um PVI devemos declarar, além da equação diferencial, as 
condições iniciais do problema, procedemos da seguinte maneira: 
 
> ics := y(0)=1,(D@@(1))(y)(1)=(0); 
 
 
Em geral, o comando para resolver uma EDO é o dsolve. Agora resolvendo o 
Problema de Valor Inicial acima citado: 
> with(DEtools): 
> edo:=diff(y(t),t$2)-5*y(t)=2*cos(t): 
> ics:=y(0)=1,(D@@(1))(y)(1)=(0): 
> dsolve({edo,ics},y(t)); 
 
d
dn
tn
( )y t
 := edo 







d
d2
t2
( )y t 5 ( )y t 2 ( )cos t
 := ics ,( )y 0 1 ( )( )D y 1 0
( )y t
1
15
e
( )5 t
5 ( ) 4 5 ( )sin 1 e
( )5
( )e
( )5
2
1
1
15
e
( ) 5 t
e
( )5
( )20 e
( )5
5 ( )sin 1
( )e
( )5
2
1
 
1
3
( )cos t
Utilizando o comando dsolve obtemos uma solução para a equação diferencial, 
porém este comando não identifica o método utilizado. Para isso utiliza-se o comando 
infolevel. O valor identificado no comando infolevel varia nos níveis: 
- Nível 2,3: informações gerais, incluindo a técnica ou algoritmo usado. 
- Nível 4,5: informações mais detalhadas sobre como o problema está sendo resolvido. 
 
Vejamos alguns exemplos: 
 
Exemplo 1: Utilizando a Equação Diferencial 
𝑑
𝑑𝑡
𝑦 𝑡 + 5𝑦 𝑡 = 2 cos 𝑡 . 
> with(DEtools): 
> edo:=diff(y(t),t$1)-5*y(t)=2*cos(t):
 
 
> infolevel[dsolve]:=4: 
> dsolve(edo,y(t)); 
 
Methods for first order ODEs: 
--- Trying classification methods --- 
trying a quadrature 
trying 1st order linear 
<- 1st order linear successful 
 
 
 
Exemplo 2: Utilizando a Equação Diferencial 
𝑑
𝑑𝑥
𝑦 𝑥 =
3𝑥²+4𝑥+2
2(1−𝑦 𝑥 )
. 
> with(DEtools): 
> edo:=diff(y(x),x$1)=(3*x^2+4*x+2)/(2*(1-y(x))): 
> infolevel[dsolve]:=4: 
> dsolve(edo,y(x)); 
 
Methods for first order ODEs: 
--- Trying classification methods --- 
trying a quadrature 
trying 1st order linear 
trying Bernoulli 
trying separable 
<- separable successful 
 
 
 
3.2 COMANDOS ESPECÍFICOS DE EDO’S DE PRIMEIRA ORDEM 
 
3.2.1 Fator Integrante 
 
( )y t   
5
13
( )cos t
1
13
( )sin t e
( )5 t
_C1
,( )y x 1    1 x3 2 x2 2 x _C1 ( )y x 1    1 x3 2 x2 2 x _C1
Para resolvermos as equações por fator integrante usamos o comando dsolve, mas se 
desejarmos saber qual é o fator integrante na Equação Diferencial, usamos o comando 
intfactor. 
Exemplo: 𝑡 
𝑑
𝑑𝑡
𝑦 𝑡 + 𝑡 + 1 𝑦 𝑡 = 𝑡. 
> with(DEtools): 
> edo:=t*diff(y(t),t)+(t+1)*y(t)=t; 
> 
 
> dsolve(edo,y(t)); 
 
> intfactor(edo); 
 
 
3.2.2 Equações Separáveis 
 
Para resolvermos Equações Diferenciais Separáveis utilizamos o comando 
separablesol. 
Exemplo: 
𝑑
𝑑𝑡
𝑦 𝑡 =
1−2𝑡
𝑦(𝑡)
. 
> with(DEtools): 
> edo:=diff(y(t),t)=(1-2*t)/y(t); 
 
 
> separablesol(edo,y(t)); 
 
 
 
3.2.3 EQUAÇÕES HOMOGÊNEAS 
 
Para resolvermos Equações Diferenciais Homogêneas utilizamos o comando 
genhomosol. 
Exemplo: 
𝑑
𝑑𝑥
𝑦 𝑥 =
𝑥²+𝑥𝑦 𝑥 ²
𝑥²
. 
> with(DEtools): 
> edo:= diff(y(x),x$1)=(x^2+x*y(x)+y(x)^2)/x^2; 
 
 := edo t 




d
d
t
( )y t ( )t 1 ( )y t t
( )y t  1
1
t
e
( )t
_C1
t
e t
 := edo 
d
d
t
( )y t
1 2 t
( )y t
{ },( )y t  2 t 2 t2 2 _C1 ( )y t   2 t 2 t2 2 _C1
 
> genhomosol(edo,y(x)); 
 
 
 
3.2.4 Equações Exatas 
 
Para resolvermos Equações Diferenciais por Bernoulli utilizamos o comando 
bernoulliosol. 
Exemplo: 𝑥²
𝑑
𝑑𝑥
𝑦 𝑥 + 𝑦 𝑥 2 = 𝑥𝑦 𝑥 . 
resolvermos Equações Diferenciais Exatas utilizamos o comando exactsol. 
Exemplo: 
𝑑
𝑑𝑥
𝑦 𝑥 = 𝑒(2x) + 𝑦 𝑥 − 1. 
> with(DEtools): 
> edo:=diff(y(x),x$1)= exp(2*x)+y(x)-1; 
 
> exactsol(edo,y(x)); 
 
 
3.2.5 Método de Bernoulli 
 
> with(DEtools): 
> edo:=x^2* diff(y(x),x$1)+y(x)^2=x*y(x); 
 
> bernoullisol(edo,y(x)); 
 
 
3.3 CAMPO DE DIREÇÕES PARA EQUAÇÕES DIFERENCIAIS DE PRIMEIRA ORDEM 
 
Para plotar o campo de direções de Edo utilizamos o comando dfieldplot. Vamos 
através de um exemplo construir o campo de direções. 
Exemplo (Boice 2006): Seja uma população de presas dada pela equação 
diferencial 
 := edo 
d
d
x
( )y x
 x2 x ( )y x ( )y x 2
x2
{ }( )y x ( )tan ( )ln x _C1 x
 := edo 
d
d
x
( )y x  e
( )2 x
( )y x 1
{ }( )y x  ( )ex
2
1 _C1 ex
 := edo 




d
d
x
( )y x x2 ( )y x 2 x ( )y x
{ }( )y x
x
( )ln x _C1
𝑑𝑝
𝑑𝑡
= 0.5𝑝 − 450 
sendo 0.5 a taxa de crescimento da população de presas por mês na ausência de 
predadores e 450 o número de presas mortas pelos predadores por mês. 
Podemos observar que para valores de 𝑝 temos: 
𝑝 > 900 temos 
𝑑𝑝
𝑑𝑡
> 0, para 𝑝 < 900 temos 
𝑑𝑝
𝑑𝑡
< 0 e para 𝑝 = 900 temos 
𝑑𝑝
𝑑𝑡
= 0, o que 
pode ser observado também no campo de direções. 
 
> restart: 
with(DEtools): 
edo:=diff(p(t),t)=0.5*p(t)-450: 
dfieldplot(edo,{p(t)},t=-
3..3,p=800..1000,color=green,title=`Campo de direções da 
equação diferencial`); 
 
 
 
Vejamos outros exemplos: 
> restart: 
with(DEtools): 
edo:=diff(y(t),t)-(2*y(t))=3*(exp(t)): 
dfieldplot(edo,{y(t)},t=-3..3,y=-3..3,color=green,title=`Campo 
de direções da equação diferencial dy/dt-2*y(t)=3*(exp(t))`); 
 
 
 
Caso deseja-se plotarno campo de direções uma solução da equação, dadas as 
condições iniciais podemos utilizar o comando DEplot. Exemplo: 
 
> DEplot(edo,y(t),t=-3..3,[[y(0)=1]],y=-3..3); 
 
 
 
Exercício: Plote o campo de direções da 
𝑑𝑦
𝑑𝑥
= −
4𝑥 + 3𝑦
2𝑥 + 𝑦
 
 utilizando o comando dfieldplot, e também utilizando o comando DEplot com a 
condição inicial 𝑦 0 = 1. 
 
> restart: 
> with(DEtools): 
> edo:=diff(y(x),x)=(-((4*x)+(3*y(x)))/((2*x)+(y(x)))); 
 
> dfieldplot(edo,{y(x)},x=-3..3,y=-
3..3,color=green,dirgrid=[50,50],title=`Campo de direções da 
equação diferencial`); 
 
> DEplot(edo,y(x),x=-7..7,[[y(0)=1]],linecolor=[blue], 
y=-5..5); 
 
 
3.3 PLANOS DE FASE 
 
O plano de fase será construído com a utilização do comando phaseportrait, no 
qual são explicitadas as condições iniciais que desejamos plotar as soluções, como segue: 
 
 := edo 
d
d
x
( )y x 
4x 3 ( )y x
2x ( )y x
>phaseportrait(diff(y(x),x)=-y(x)+x,y(x),x=-1..2.5, 
[[y(0)=0],[y(0)=1],[y(0)=-1]],colour=magenta, 
linecolor=[gold,yellow,wheat]); 
 
 
 
 
> restart: 
> with(DEtools): 
> phaseportrait(Pi*diff(y(x),x)=y(x)-x,y(x),x=-2.5..1.4, 
[[y(0)=1]],y=-4..5,stepsize=.05); 
 
 
 
Exercício: Plote o plano de fase do EDO: 
𝑦 𝑥 = −𝑦 𝑥 − 𝑥2 
com as condições iniciais: 𝑦 0 = 0, 𝑦 0 = 1, 𝑦 0 = −1. Utilize o Título “Plano de 
FAse”, como cor das soluções defina, azul, preto e vermelho, e como cor do campo de 
direções defina verde: 
> restart: 
with(DEtools): 
edo:=diff(y(x),x)=-y(x)-x^2: 
> phaseportrait(D(y)(x)=-y(x)-x^2,y(x),x=-1..2.5, 
[[y(0)=0],[y(0)=1],[y(0)=-1]],title=`Plano de 
fase`,colour=green,linecolor=[blue,black,red]); 
 
 
 
3.4 EQUAÇÃO DO PÊNDULO 
 
Nesta seção vamos obter os planos de fase da equação do pêndulo. Para isso 
consideraremos as seguintes situações: pêndulo não amortecido, com pequenas 
oscilações e com oscilações maiores e o pêndulo amortecidos. Para cada caso será 
construído o plano de fase com uma animação em relação ao tempo. 
 
3.4.1 Pêndulo não amortecido 
 
A equação que modela o movimento do pêndulo simples não amortecido é 
𝜃 +
𝑔
𝐿
𝑠𝑒𝑛(𝜃) = 0 (1) 
 
Para o caso com pequenas oscilações, podemos considerar 𝑠𝑒𝑛(𝜃) ≈ 𝜃, assim a 
equação (1) pode ser escrita como 
𝜃 +
𝑔
𝐿
𝜃 = 0 (2) 
E tomando 𝑥 = 𝜃 e 𝑦 = 𝑥 = 𝜃 temos o seguinte sistema associado a (2) 
 
𝑥 = 𝑦
𝑦 = −
𝑔
𝐿
𝑥
 
Vejamos agora como obter o plano de fase, 
>restart: 
>with(DEtools): 
>with(plots): 
>sistema1:=[diff(x(t),t)=y(t),diff(y(t),t)=-x(t)]; 
 
>g1:=DEplot(sistema1,{x(t),y(t)},t=-2..2,x=-
6..6,[[x(0)=k,y(0)=2] $ k=-5..5],y=-
6..6,color=brown,dirgrid=[20,20],linecolour=blue): 
>g2:=DEplot(sistema1,{x(t),y(t)},t=-2..2,x=-
6..6,[[x(0)=k,y(0)=-2] $ k=-5..5],y=-
6..6,color=brown,dirgrid=[20,20],linecolour=blue): 
>display([g1,g2]); 
 
 
 
O plano de fase dado acima pode ser dado também por: 
 
>restart: 
>with(DEtools): 
>with(plots): 
>sistema1:=[diff(x(t),t)=y(t),diff(y(t),t)=-x(t)]; 
 := sistema1 




,d
d
t
( )x t ( )y t 
d
d
t
( )y t  ( )x t
DEplot(sistema1,{x(t),y(t)},t=-2..2,x=-6..6,[[x(0)=k,y(0)=k] $ 
k=-10..10],y=-
6..6,color=brown,dirgrid=[20,20],linecolour=blue); 
 
 
 
O plano de fase animado para a equação (2) é obtido como segue 
 
>DEplot([diff(x(t),t)=y(t),diff(y(t),t)=-
x(t)],[x(t),y(t)],t=0..10,[[x(0)=0,y(0)=.5],[x(0)=0,y(0)=1],[x
(0)=0,y(0)=1.8], 
[x(0)=5,y(0)=1],[x(0)=-4,y(0)=1],[x(0)=-Pi,y(0)=1], 
[x(0)=Pi,y(0)=1], [x(0)=-2*Pi,y(0)=1],[x(0)=2*Pi,y(0)=.5], 
[x(0)=-2*Pi,y(0)=2.1],[x(0)=2*Pi,y(0)=-2.1]],title=`Plano de 
fase`,dirfield=300,color=magnitude,linecolor=blue,animate=true
); 
 
 := sistema1 




,d
d
t
( )x t ( )y t 
d
d
t
( )y t  ( )x t
Para o caso com oscilações maiores temos a equação (1) que pode ser 
representada como o sistema de equações de primeira ordem, 
 
𝑥 = 𝑦
𝑦 = −sin⁡(𝑥)
 
>restart: 
>with(DEtools): 
>with(plots): 
>sistema1:=[diff(x(t),t)=y(t),diff(y(t),t)=-sin(x(t))]; 
 
>g1:=DEplot(sistema1,{x(t),y(t)},t=-10..10,x=-
12..12,[[x(0)=k/1,y(0)=0] $ k=-20..20],y=-
5..5,color=gray,dirgrid=[20,20],linecolour=blue): 
>g2:=DEplot(sistema1,{x(t),y(t)},t=-10..10,x=-
12..12,[[x(0)=2*k,y(0)=-2] $ k=-10..10],y=-
5..5,color=gray,dirgrid=[20,20],linecolour=blue): 
>g3:=DEplot(sistema1,{x(t),y(t)},t=-10..10,x=-
12..12,[[x(0)=2*k,y(0)=2] $ k=-10..10],y=-
5..5,color=gray,dirgrid=[20,20],linecolour=blue): 
>display([g1,g2,g3],thickness=4,title=`Plano de fase`); 
 
 
O plano de fase animado para este sistema é dado 
 
>DEplot([diff(x(t),t)=y(t),diff(y(t),t)=-
sin(x(t))],[x(t),y(t)],t=0..10,[[x(0)=0,y(0)=.5],[x(0)=0,y(0)=
1],[x(0)=0,y(0)=1.8],[x(0)=-
2*Pi,y(0)=1],[x(0)=2*Pi,y(0)=.5],[x(0)=-
2*Pi,y(0)=2.1],[x(0)=2*Pi,y(0)=-2.1]],title=`plano de 
fase`,dirfield=300,color=magnitude,linecolor=blue,animate=true
); 
 
 
 := sistema1 




,d
d
t
( )x t ( )y t 
d
d
t
( )y t  ( )sin ( )x t
 
3.4.2 Pêndulo com amortecimento 
 
A equação que modela o movimento do pêndulo simples não amortecido é 
𝜃 + 𝜇𝜃 +
𝑔
𝐿
𝑠𝑒𝑛(𝜃) = 0 (3) 
 
E tomando 𝑥 = 𝜃 e 𝑦 = 𝑥 = 𝜃 temos o seguinte sistema associado a (2) 
 
𝑥 = 𝑦
𝑦 = −𝜇𝑦 −
𝑔
𝐿
𝑠𝑒𝑛(𝑥)
 
Vejamos agora como obter o plano de fase, 
>restart: 
>with(DEtools): 
>with(plots): 
>mu:=1:gl:=4: 
>sistema1:=[diff(x(t),t)=y(t),diff(y(t),t)=-mu*y(t)-
gl*sin(x(t))]; 
 
>g1:=DEplot(sistema1,{x(t),y(t)},t=-5..5,x=-
10..10,[[x(0)=k,y(0)=0] $ k=-10..10],y=-
10..10,color=gray,dirgrid=[20,20],linecolour=blue): 
>g2:=DEplot(sistema1,{x(t),y(t)},t=-5..5,x=-
10..10,[[x(0)=k,y(0)=-2] $ k=-10..10],y=-
10..10,color=gray,dirgrid=[20,20],linecolour=blue): 
>g3:=DEplot(sistema1,{x(t),y(t)},t=-5..5,x=-
10..10,[[x(0)=k,y(0)=2] $ k=-10..10],y=-
10..10,color=gray,dirgrid=[20,20],linecolour=blue): 
>display([g1,g2,g3],thickness=4); 
 := sistema1 




,d
d
t
( )x t ( )y t 
d
d
t
( )y t  ( )y t 4 ( )sin ( )x t
 
 
O plano de fase animado é dado por 
>DEplot([diff(x(t),t)=y(t),diff(y(t),t)=-mu*y(t)-
4*sin(x(t))],[x(t),y(t)],t=0..10,[[x(0)=0,y(0)=.5],[x(0)=0,y(0
)=1],[x(0)=0,y(0)=1.8],[x(0)=-
2*Pi,y(0)=1],[x(0)=2*Pi,y(0)=.5], 
[x(0)=-2*Pi,y(0)=2.1],[x(0)=2*Pi,y(0)=-2.1]], title=`Vibração 
do Pêndulo`,dirfield=300,color=magnitude,linecolor=blue, 
animate=true); 
 
CAPÍTULO 4. PROGRAMAÇÃO 
 
Neste capítulo procura-se apresentar alguns dos comandos básicos para 
programação, e alguns exemplos de programas simples. 
 
4.1 COMANDOS BÁSICOS 
 
4.1.1 Comando: for 
 
O comando for é uma estrutura de programação que permite realizar iterações, 
“loop”. Este comando é dado da seguinte forma: 
for i from a to b do 
comando a ser realizado 
od; 
Sendo: 
i: variável do loop; 
a: valor inicial; 
b: valor final. 
Observação: O comando for sempre deve ser encerrado com od. 
Exemplo: Somar à 10 uma variável que assuma valores de 1 até 3. 
> for i from 1 to 3 do 
10+i 
od; 
 
 
 
Se no exemplo anterior fosse necessário armazenarmos os valores obtidos 
poderíamos proceder da seguinte forma: 
> for i from 1 to 3 do 
s[i]:=10+i 
od; 
 
 
 
Exemplo: Utilize o comando for para escrever os números pares (𝑛 = 2𝑘) para 
𝑘 = 1, … ,10: 
> for k from 1 to 10 do 
 n[k]:=2*k 
od; 
11
12
13
 := s
1
11
 := s
2
12
 := s
313
 
 
 
 
 
 
 
 
 
 
Exercício: Utilizando o comando para obter os alguns números pares, obtenha 
agora os números ímpares com 𝑘 = 1 … 5: 
> for k from 1 to 5 do 
 n[k]:=2*k+1 
od; 
 
 
 
 
 
 
Exercício: Calcule as integrais das funções 𝑓 𝑥 = 𝑥𝑖 para 𝑖 variando de 1 até 3. 
> for i from 1 to 3 do 
Int(x^i,x=0..2)=int(x^i,x=0..2) 
od; 
 
 
 
Exemplo: Dada uma matriz 𝐴, queremos somar 1 em cada uma de suas 
coordenadas utilizando o comando for. 
 := n
1
2
 := n
2
4
 := n
3
6
 := n
4
8
 := n
5
10
 := n
6
12
 := n
7
14
 := n
8
16
 := n
9
18
 := n
10
20
 := n
1
3
 := n
2
5
 := n
3
7
 := n
4
9
 := n
5
11
d


0
2
x x 2
d


0
2
x2 x
8
3
d


0
2
x3 x 4
Observação: Essa operação já foi realizada utilizando o comando Map. 
> restart: 
> A:=Matrix(2,2,[a,b,c,d]); 
 
> for i from 1 to 2 do 
 for j from 1 to 2 do 
 A[i,j]:=A[i,j]+1 
 od; 
od; 
print(A); 
 
4.1.2 Comando: if 
 
A estrutura if permite que executemos um determinado comando sob certas 
condições. De maneira geral é executado da seguinte forma: 
if condição then comando1 else comando2 fi; 
Observação: Quando utilizamos a estrutura if sempre encerramos com fi. 
Exemplo: 
> x[1]:=1; 
 
> if x[1]<=3 then n:=1 fi; 
 
 
 
O próximo exemplo é simples, mas posteriormente nos dará a idéia de como 
definir uma função. 
> x:=3; 
 := x 3
 
> if x<=2 then f:=x+2; 
 else f:=x; 
 fi; 
 
Vamos agora utilizar os comandos for e if combinados. 
Exemplo: Dada a matriz A, , crie uma matriz auxiliar B, tal que 
𝐵𝑖 ,𝑗 = 
𝐴𝑖 ,𝑗 , 𝑠𝑒𝐴𝑖 ,𝑗 > 0
0, 𝑠𝑒 𝐴𝑖 ,𝑗 ≤ 0
 
 
> restart:with(LinearAlgebra): 
> A:=Matrix(2,2,[2,4,-1,9]): 
 := A 





a b
c d






a 1 b 1
c 1 d 1
 := x
1
1
 := n 1
 := f 3
 := A 





2 4
-1 9
> B:=Matrix(2,2,a): 
> for i from 1 to 2 do 
 for j from 1 to 2 do 
 if A[i,j]<=0 then 
 B[i,j]:=0; 
 else 
 B[i,j]:=A[i,j]; 
 fi; 
 od; 
od; 
print(B); 
 
4.1.3 Comando: while 
 
Com o comando while permite também criarmos uma espécie de “loop”. Para 
este comando utilizamos a seguinte estrutura. 
while 𝑎 do b od; 
onde: 
𝑎: condição; 
b: comando a ser executado. 
Vejamos um pequeno exemplo: 
> s:=0: 
> while s<10 do 
 s:=s+2 
od; 
 
 
 
 
 
Até este momento vimos algumas estruturas simples amplamente utilizadas em 
programação. Vamos agora criar alguns programas que exemplifiquem procedimentos 
implementados no MAPLE. 
 
4.2 PROCEDIMENTOS NO MAPLE 
 
 Um procedimento no MAPLE é iniciado com o comando proc( ) e encerrado com 
o comando end: 
 No comando proc( ), declaramos as variáveis que representam os dados de 
entrada do programa. Geralmente coloca-se um nome neste programa, para que 






2 4
0 9
 := s 2
 := s 4
 := s 6
 := s 8
 := s 10
posteriormente possamos acioná-lo. Vamos através de um exemplo ilustrar as 
observações realizadas acima. 
Exemplo 1: Calcular o módulo de um número 𝑥𝜖ℝ. 
Neste exemplo temos como dado de entrada 𝑥, podemos chamar o procedimento 
de modulo, vejamos: 
> restart: 
> modulo:=proc(x) 
 if x<=0 then 
 Mod(x):=-x 
 else 
 Mod(x):=x 
 fi; 
 end: 
 
Aplicando o procedimento acima: 
 
> modulo(2); 
 
> modulo(-2); 
 
Exemplo 2: Calcular a média aritmética para três valores dados: 
> restart: 
 aritmetica:=proc(v1,v2,v3) 
 (v1+v2+v3)/3 
 end: 
 
> aritmetica(7,8,9); 
 
Exemplo 3: Calcular a média geométrica para 4 valores dados. 
> restart: 
 geometrica:=proc(v1,v2,v3,v4) 
 evalf(v1*v2*v3*v4)^(1/4) 
 end: 
> geometrica(6,5,7,8); 
 
Exemplo 4: Somar os 𝑛 primeiros números naturais. 
> restart: 
> soma:=proc(n) 
 local s,i; 
 s:=0; 
 for i from 1 to n do 
 s:=s+i 
 od; 
end: 
 
2
2
8
6.402171746
Neste caso o comando local declara as variáveis que serão utilizadas no interior do 
programa. 
> soma(100); 
 
Exemplo 5: Declarar a função 𝑓 𝑥 = 
𝑥, 𝑠𝑒 𝑥 < −2
𝑥 + 1, 𝑠𝑒 − 2 ≤ 𝑥 < 0
𝑥2 , 𝑠𝑒 𝑥 ≥ 0
 
> restart: 
> f:=proc(x) 
 if x<-2 then x 
 else 
 if -2<=x and x<0 then x+1 
 else x^2 
 fi; 
 fi; 
 end: 
 
> f(2); 
 
Exemplo 6: Criar um programa que permita calcular o n-ésimo termo da sequência de 
Fibonacci dado pela recursivamente por: 
𝐹 𝑛 = 
0, 𝑝𝑎𝑟𝑎 𝑛 = 0
1, 𝑝𝑎𝑟𝑎 𝑛 = 1
𝐹 𝑛 − 1 + 𝐹 𝑛 − 2 , 𝑝𝑎𝑟𝑎 𝑛 ≥ 2
 
> restart: 
> SeqFibonacci:=proc(n,integer) 
 if n=0 then 0 
 else 
 if n=1 then 1 
 else SeqFibonacci(n-1)+SeqFibonacci(n-2) 
 fi; 
 fi; 
 end: 
 
> SeqFibonacci(11); 
 
Exemplo 7: Calcular as matriz transposta conjugada de uma matriz 𝐴 de ordem 𝑚 × 𝑛. 
> restart: 
> transpostaconjugada:=proc(A,m,n) 
 local At, i,j; 
 with(LinearAlgebra): 
 At:=matrix(n,m,a); 
 for i from 1 to n do 
 for j from 1 to m do 
 At[i,j]:=conjugate(A[j,i]) 
 od; 
 od; 
5050
4
89
 print(At); 
 end: 
 
Vamos agora aplicar o procedimento acima a uma matriz em particular. 
 
> m:=2: 
 n:=3: 
> A:=Matrix(m,n,[[I,2,-2*I],[4,0,2]]); 
 
> transpostaconjugada(A,m,n); 
 
 
Exemplo 8: Dadas duas matrizes 𝐴 e 𝐵 de ordem 𝑚 × 𝑛, criar um procedimento que 
realize a soma destas matrizes. 
> restart: 
 Soma:=proc(A,B,m,n) 
 local M, i,j; 
 with(LinearAlgebra): 
 M:=Matrix(m,n,a); 
 for i from 1 to m do 
 for j from 1 to n do 
 M[i,j]:=A[i,j]+B[i,j] 
 od; 
 od; 
 print(M); 
 end: 
 
Aplicando o procedimento para matrizes em particular: 
> m:=2: 
 n:=3: 
> A:=Matrix(m,n,[[1,2,0],[0,2,1]]): 
> B:=Matrix(m,n,[[1,1,1],[5,2,0]]): 
> Soma(A,B,m,n); 
 
 
 
 
 
 
 
 
 := A 





I 2 -2I
4 0 2












I 4
2 0
2 I 2






2 3 1
5 4 1
 
 
BIBLIOGRAFIA 
 
 
- NEVES, J. C. Programação em MAPLE. Disponível em 
<http://www.slideshare.net/jeandson/introduo-programao-em-MAPLE>. Acesso em 28 
set. 2010. 
 
- ANDRADE, L. N.; Introdução à computação algébrica com o MAPLE. Rio de Janeiro: 
Sociedade Brasileira de Matemática, 2004. 
 
- PORTUGAL, R.; Introdução ao MAPLE. Petrópolis - RJ, 2002. 
 
- RUGGIERO, M. A. G. & LOPES, V. L. R. Cálculo numérico: aspectos teóricos e 
computacionais. 2.ed. São Paulo, Makron, 1997. 
 
- LIPSCHUTZ, S. Álgebra Linear. 3.ed. COLEÇAO SCHAUM. Porto Alegre, bookman, 
2008. 
 
- BOYCE, W. E.; Di PRIMA, R. C. Equações Diferenciais Elementares e Problemas de 
Valores de Contorno. Tradução de Valéria Magalhães. 8.ª Ed. Rio de Janeiro: LTC, 2006.