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]]);
1 2
A :=

 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);
( -1 )n~
>cos((2*n-1)*Pi);
-1
>cos(2*n*Pi);
1
Dado um número complexo, podemos encontrar sua parte real e imaginária da
seguinte forma:
>Re(4+I);;
4
>Im(1+3*I);
3
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);
y

2
>solve( {2*a + b = 1, a+2*b=0}, [a,b]);
2
-1 


a , b 





3
3



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 de maior). Por exemplo:
>g:= x ->x^2 + 1;
g := xx21
>g(4);
17
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;
f( x ) := x2x10
>solve (f(x));
1 1
1 1
  I 3 ,   I 3
2 2
2 2
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).
>f(2);
f( 2 )
>g:= piecewise(x<-1,x+2,x>=-1 and x<1,x^2,x^3);
 x2
 2
g := 
x



 x3

x-1
-1x and x1
otherwise
>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:
>?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
2

 2 6
n 1 n
1.6 PRODUTÓRIO
>Product(1/n, n=1..30)=product(1/n, n=1..30);
30
1
1
 n 265252859812191058636308480000000
n 1
1.7 LIMITES
>Limit(x^2*sin(1/x), x=0)=limit(x^2*sin(1/x), x=0);
1
lim x2 sin 0
x 0
x
1.8 DERIVADAS
>Diff(x^2*sin(1/x),x$1)=diff(x^2*sin(1/x),x$1);
d  2  1 
1
1
 x sin  2 x sin cos 
dx 
 x 
x
x
1.9 INTEGRAIS INDEFINIDAS
>Int(x^2, x)=int(x^2, x);
3
x2 dx x

3

1.10 INTEGRAIS DEFINIDAS
>Int(x^2, x=1..3)=int(x^2, x=1..3);
3
 x2 dx26

3
1
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]);
a
A := 
d
c

f 
b
e
>B:=Matrix(3,2,[[1,7],[5,6]]);
 1

B := 5

 0
7

6

0
1
C :=
4
2

5
>C:=Matrix([[1,2],[4,5]]);
>v:=Vector(3,[a,b,c]);
 a 
v :=  b 
 
 c
Utilizando o pacote linalg
>restart:
>with(linalg):
>A:=matrix(2,3,[a,b,c,d,e,f]);
a
A := 
d
b
e
c

f 
>v:=vector(3,[a,b,c]);
 a 
v :=  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);
 1 0 0


Iden := 0 1 0


 0 0 1
>N:=Matrix(2,3);
0 0 0
N :=

 0 0 0
>ZeroMatrix(2);
0

0
0

0
>ZeroVector(2);
 0
 
 0
ou
>restart:
>with(linalg):
>N:=matrix(2,2,0);
0
N :=
0
0

0
>M:=Matrix(3,3,shape=identity);
1

M := 0

0
0
1
0
0

0

1
2.1.3 Operações básicas
Sejam as matrizes
>with(LinearAlgebra):
>A:=Matrix(2,2,[[4,6],[0,5]]);
4
A :=
0
6

5
>B:=Matrix(2,2,[[1,4],[9,-1]]);
1 4
B :=

 9 -1
e os vetores
>v:=Vector(2,[[1],[-1]]);
1
v := 
 -1
>u:=Vector(2,[[2],[-3]]);
2
u := 
 -3
ADIÇÃO DE MATRIZES E VETORES
>A+B;
 5 10


 9 4
>A+(-B);
 3 2


 -9 6
>v+u;
 3
 
 -4
>v+(-u);
 -1
 
 2
MULTIPLICAÇÃO DE MATRIZES E VETORES
>Multiply(A,B);
58 10


45 -5
>Multiply(A,u);
 -10
 
 -15
DETERMINANTE
>Determinant(A);
20
TRAÇO DA MATRIZ
Soma dos elementos da diagonal
>Trace(A);
9
TRANSPOSTA DE UMA MATRIZ
>Transpose(A);
4

6
0

5
MATRIZ INVERSA
>MatrixInverse(A);
 1

 4



 0

-3
10
1
5








Vamos verificar se esta realmente é a matriz inversa
>Multiply(A,MatrixInverse(A));
1

0
0

1
>Multiply(MatrixInverse(A),A);
1

0
0

1
Consideremos a matriz
>C:=Matrix(2,2,[[3,1],[3,1]]);
3
C :=
3
1

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);
0
ELIMINAÇÃO DE LINHAS E COLUNAS DA MATRIZ
>restart:
>with(LinearAlgebra):
>G:=Matrix(3,3,[[2,-1,3],[4,7,8],[9,0,4]]);
 2 -1 3


G := 4 7 8
 9 0 4


>DeleteColumn(G,3);
2

4


9
-1

7

0
>DeleteRow(G,[1,3]);
[4 7 8]
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]]);
1
 x

F := 2
x 1 0


Caso se queira calcular o valor de cada coordenada quando 𝑥 = 0podemos usar o
comando
>subs(x=0,F);
 0 1


 -1 0
Comando este que também é válido para funções
>f:=x^2+1;
f :=x21
>subs(x=1,f);
2
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);
 x2 3
2

x 1 2


Pode-se dessa forma obter também a derivada das entradas da matriz
>Map(diff,F,x);
 1 0


2x 0
e também sua integral
>Map(int,F,x);
2
 x

 2


1 3
 x x
3


x 



0 

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]);
 1 3 2


A := 4 7 1


 6 13 5
>Rank(A);
2
>B:=Matrix(2,2,[1,4,9,5]);
1
B :=
9
4

5
>Rank(B);
2
>C:=Matrix(2,3,[1,3,5,4,3,7]);
1 3 5
C :=

 4 3 7
>Rank(C);
2
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]);
 1
 
v :=  2
 
 2
>w:=Vector(3,[1,2,-1]);
 1
 
w :=  2
 
 -1
2.3.1 PRODUTO ESCALAR
>DotProduct(v,w);
3
2.3.2 PRODUTO VETORIAL
>CrossProduct(v,w);
 -6
 
 3
 
 
 0
2.3.3 NORMA DE UM VETOR
>VectorNorm(v,2);
3
>VectorNorm(w,2);
6
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);
 6

 :=arccos
 6 
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]]);
4 2
A :=

 3 -1
>Determinant(A-lambda*IdentityMatrix(2));
1032
Ou simplesmente
>p(lambda):=CharacteristicPolynomial(A,lambda);
p() :=1032
Para encontrarmos os autovalores através do polinômio característico resolvemos
>solve(p(lambda)=0);
5, -2
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);
 5
 
 -2
Caso queira o primeiro ou o segundo autovalor separadamente, podemos usar o
comando a seguir
>Eigenvalues(A)[1];
5
>Eigenvalues(A)[2];
-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 P
>(v,e):=Eigenvectors(A);
5  2
v, e := , 
 -2  1

-1 

3 
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,
1
2
−3
para este exemplo, 𝑣1 =
é autovetor associado ao autovalor -2, e 𝑣2 =
é
1
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);
2
v1 :=  
 1
>Multiply(A,v1);
 10 
 
 5
>v2:=DeleteColumn(e,1);
 -1 
v2 :=  3 
 1 


>Multiply(A,v2);
 2 
 3 
 -2 


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]]);
1
A :=
3
2

6
>NullSpace(A);
-2
{  }
 1
Nullspace de 𝐴 é o núcleo de 𝐴, e o comando Nullspace(A) nos dá uma base para
o núcleo de 𝐴.
Outro exemplo:
>B:=Matrix(3,3,[[1,1,2],[2,2,4],[3,3,6]]);
 1 1 2


B := 2 2 4


 3 3 6
>NullSpace(B);
 -2  -1 

 


 




 0,  1 



 1
 
 0


 

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);
a( 1)
 
a( 2)
vv := 
a( 3)
 
a( 4)
 
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]]);








ord := 









1 

1 
, 
1 
1 




-2 

-1 
, 
1 
2 





8
5
-17
10
-13
10
7
5

















 

Caso seja necessário obter um conjunto de vetores ortonormais, procede-se:
>GramSchmidt({v[1],v[2],v[3]},normalized);
 30   61 12570   303 38129 




 30   12570   76258  














  30   11 12570  207 38129 
 10  


4190   76258  



, 
, 
 




 2 30  2 12570 

38129

 
 

 15  


6285  
5866  










  30   44 12570   19 38129 

 
 

10894  
 15   6285  
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]);
1
>DotProduct(s[2],s[2]);
1
>DotProduct(s[3],s[3]);
1
Daí concluímos que os vetores obtidos são unitários.
>DotProduct(s[1],s[2]);
0
>DotProduct(s[1],s[3]);
0
>DotProduct(s[2],s[3]);
0
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:
Teorema:Seja 𝑇: 𝑉 → 𝑉 um operador linear cujos polinômio mínimo e o
polinômio característico são, respectivamente,
𝑚 𝑥 = 𝑥 − 𝜆1
𝑟1
∙ 𝑥 − 𝜆2
𝑟2
∙ ⋯ ∙ 𝑥 − 𝜆𝑟
𝑟𝑘
𝑝 𝑥 = 𝑥 − 𝜆1
𝑠1
∙ 𝑥 − 𝜆2
𝑠2
∙ ⋯ ∙ 𝑥 − 𝜆𝑟
𝑠𝑘
e
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]);
3
T :=
2
1

2
> p(x):=factor(CharacteristicPolynomial(T,x));
p(x) :=(x1) (x4)
>m(x):=factor(MinimalPolynomial(T,x));
m(x) :=(x1) (x4)
>J:=JordanForm(T);
1
J :=
0
0

4
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.
>Eigenvectors(T);
-1 

 4,  1 2 
  

 1  1 1 


 3 1 -1


Exercício: Verifique se a matriz T := 2 2 -1 é diagonalizável, calculando os


 2 2 0
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]);
 3 1 -1


T := 2 2 -1


 2 2 0
>p(x):=factor(CharacteristicPolynomial(T,x));
p(x) :=(x1) (x2)2
>m(x):=factor(MinimalPolynomial(T,x));
m(x) :=(x1) (x2)2
>J:=JordanForm(T);
1

J := 0

0
0
2
0
0

1

2
 1 1 0


Exercício: Dada a matriz T := -1 3 0 calcule o polinômio característico e minimal,


 -1 1 2
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]);
 1 1 0


T := -1 3 0


 -1 1 2
>p(x):=factor(CharacteristicPolynomial(T,x));
p(x) :=(x2)3
>m(x):=factor(MinimalPolynomial(T,x));
m(x) :=(x2)2
>J:=JordanForm(T);
2

J := 0

0
0

0

2
1
2
0
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]);
1 2 3
B :=

 1 3 2
> GaussianElimination(B);
 1 2 3


 0 1 -1
> C:=Matrix(2,2,[1,2,5,2]);
1
C :=
5
2

2
> GaussianElimination(C);
 1 2


 0 -8
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 𝑥3 o preço da cocada temos o seguinte sistema de equações.
3𝑥1 + 𝑥2 + 2𝑥3 = 21,50
8𝑥1 + 3𝑥2 + 5𝑥3 = 57
𝑥1 + 𝑥2 + 𝑥3 = 10
Matricialmente pode-se escrever
𝑥1
3 1 2
21,5
𝐴𝑥 = 𝑏 ⇒ 8 3 5 × 𝑥2 = 57
𝑥3
1 1 1
10
sendo
3
𝐴= 8
1
𝑥1
1 2
21,5
𝑥
3 5 , 𝑏 = 57 e𝑥 = 2
𝑥3
1 1
10
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]]);
3

A := 8

1
1
3
1
2

5

1
>b:=Vector([[21.5],[57],[10]]);
21.5
 
b := 57 
 
 10 
>Determinant(A);
1
Como det 𝐴 ≠ 0 sabe-se que a matriz 𝐴 é inversível, desta forma podemos calcular:
>x:=Multiply(MatrixInverse(A),b);
4.






x :=2.50000000000000000



3.50000000000000000



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);
4.




2.50000000000000000





3.50000000000000000



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
𝐿 𝑦 = 𝑏.
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');
1

p, L, U := 0

0
0
1
0


0 

0, 

1 


1
8
3
1
3
0
1
2
0
 3

0 
,  0


1  0

1
1
3
0
2

-1 
3 

1 
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);
21.5


Pb := 57.


 10.
>y:=LinearSolve(L,Pb);
 21.5000000000000000




y :=-0.333333333333330151



3.49999999999999422


>x:=LinearSolve(U,y);
4.00000000000000266




2.50000000000000356
x :=




3.49999999999999422



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.
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]);
16 -4 12 -4


 -4 2 -1 1


A :=

12 -1 14 -2


 -4 1 -2 83


>G:=LUDecomposition(A,method='Cholesky');
 4 0 0 0


 -1 1 0 0


G :=

 3 2 1 0


 -1 0 1 9


>Gt:=Transpose(G);
 4 -1 3 -1


 0 1 2 0


Gt :=

 0 0 1 1


 0 0 0 9


Onde verificamos que
>Multiply(G,Gt);
16

 -4


12

 -4

-4
2
-1
1
12 -4

-1 1

14 -2
-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);
dn
y( t )
dtn
Dessa forma, para declararmos uma equação diferencial no MAPLE escrevemos:
> edo:=diff(y(t),t$2)-5*y(t)=2*cos(t);
2
d

edo :=  2 y( t ) 5 y( t )2 cos ( t )
 dt


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);
ics := y( 0 )1, D( 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));
1 e
y( t )
15
( 5 t)
5 ( 4 5 sin( 1 ) e
(e
1
 cos( t )
3
( 5)
2
) 1
( 5)
)
1 e

15
( 5 t )
e
( 5)
( 20 e
(e
( 5)
( 5)
 5 sin( 1 ) )
2
) 1
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
(5 t )
5
1
y( t ) cos ( t ) sin( t )e
_C1
13
13
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
y( x )1 1x32 x22 x_C1 , y( x )1 1x32 x22 x_C1
3.2 COMANDOS ESPECÍFICOS DE EDO’S DE PRIMEIRA ORDEM
3.2.1 Fator Integrante
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;
>
d
edo := t  y( t ) ( t1 ) y( t )t
 dt

> dsolve(edo,y(t));
1 e
y( t )1 
t
( t )
_C1
t
> intfactor(edo);
et
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);
edo :=
d
12 t
y( t )
dt
y( t )
> separablesol(edo,y(t));
{ y( t ) 2 t2 t 22 _C1 , y( t ) 2 t2 t 22 _C1 }
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 :=
d
x 2x y( x )y( x ) 2
y( x )
dx
x2
> genhomosol(edo,y(x));
{ y( x )tan( ln( x )_C1 ) 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;
(2 x )
d
edo :=
y( x )e
y( x )1
dx
> exactsol(edo,y(x));
2
{ y( x )( e x ) 1_C1 e x }
3.2.5 Método de Bernoulli
> with(DEtools):
> edo:=x^2* diff(y(x),x$1)+y(x)^2=x*y(x);
d
edo :=  y( x )  x 2y( x ) 2x y( x )
 dx

> bernoullisol(edo,y(x));
{ y( x )
x
}
ln( x )_C1
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
𝑑𝑝
= 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 plotar no 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))));
d
4 x3 y( x)
edo := y( x)
dx
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:
>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)];
d
d
sistema1:= x( t )y( t ), y( t )x( t ) 
dt
 dt

>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)];
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);
d
d

sistema1:=

 dt x( t )y( t ), dt y( t )x( t ) 



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
);
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))];
d
d
sistema1:= x( t )y( t ), y( t )sin( x( t ) ) 
dt
 dt

>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
);
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))];
d
d
sistema1:= x( t )y( t ), y( t )y( t )4 sin( x( t ) ) 
dt
 dt

>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);
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;
11
12
13
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;
s1 :=11
s2 :=12
s3 :=13
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;
n1 :=2
n2 :=4
n3 :=6
n4 :=8
n5 :=10
n6 :=12
n7 :=14
n8 :=16
n9 :=18
n10 :=20
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;
n1 :=3
n2 :=5
n3 :=7
n4 :=9
n5 :=11
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;
2
 x dx2

0
2
 x2 dx8

3
0
2
 x3 dx4

0
Exemplo: Dada uma matriz 𝐴, queremos somar 1 em cada uma de suas
coordenadas utilizando o comando for.
Observação: Essa operação já foi realizada utilizando o comando Map.
> restart:
> A:=Matrix(2,2,[a,b,c,d]);
a b
A :=

 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);
a1 b1


c1 d1
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;
x1 :=1
> if x[1]<=3 then n:=1 fi;
n :=1
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;
f :=3
Vamos agora utilizar os comandos for e if combinados.
2 4
Exemplo: Dada a matriz A, A :=
 , crie uma matriz auxiliar B, tal que
 -1 9
𝐵𝑖,𝑗 =
𝐴𝑖,𝑗 , 𝑠𝑒𝐴𝑖,𝑗 > 0
0, 𝑠𝑒 𝐴𝑖,𝑗 ≤ 0
> restart:with(LinearAlgebra):
> A:=Matrix(2,2,[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);
2

0
4

9
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;
s :=2
s :=4
s :=6
s :=8
s :=10
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
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);
2
> modulo(-2);
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);
8
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);
6.402171746
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:
Neste caso o comando local declara as variáveis que serão utilizadas no interior do
programa.
> soma(100);
5050
𝑥, 𝑠𝑒 𝑥 < −2
𝑥
+
1,
𝑠𝑒 − 2 ≤ 𝑥 < 0
Exemplo 5: Declarar a função 𝑓 𝑥 =
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);
4
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);
89
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;
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]]);
I 2 -2I
A :=

4 0 2 
> transpostaconjugada(A,m,n);
 I

2


2 I
4

0

2
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);
 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.