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

FERNANDA RONSSANI DE FIGUEIREDO

GUILHERME GALINA LOCH
 SUMÁRIO
Introdução ........................................................................................................................ 3
Capítulo 1. Utilitários ....................................................................................................... 4
1.1 Ajuda no Maple: help ............................................................................................. 4
1.2 Pacotes ................................................................................................................... 5
1.3 Instruções Básicas ................................................................................................... 5
1.4 Funções .................................................................................................................. 6
1.5 Somatórios.............................................................................................................. 8
1.6 Produtório .............................................................................................................. 8
1.7 Limites .................................................................................................................... 9
1.8 Derivadas ............................................................................................................... 9
1.9 Integrais Indefinidas ................................................................................................ 9
1.10 Integrais Definidas ................................................................................................ 9
Capítulo 2. Álgebra Linear .............................................................................................. 11
2.1 Comandos e Operações Básicas com Matrizes ..................................................... 11
2.2 Matrizes cujas entradas são funções...................................................................... 16
2.3 Posto de uma matriz, produto escalar, produto vetorial e norma de vetores ......... 17
2.4 Autovalores e autovetores ..................................................................................... 19
2.5 Nullspace de uma matriz A ................................................................................... 22
2.6 Processo de ortogonalização de Gram-Schimidt ................................................... 22
2.7 Forma Canônica de Jordan ................................................................................... 24
2.8 Eliminação Gaussiana ........................................................................................... 26
2.9 Resolução de sistemas .......................................................................................... 27
Capítulo 3. Equações Diferenciais Ordinárias ................................................................. 31
3.1 Comandos Básicos ................................................................................................ 31
3.2 Comandos Específicos de EDO’s de Primeira Ordem ........................................... 33
3.3 Campo de Direções para Equações Diferenciais de primeira ordem..................... 35
3.3 Planos de Fase ...................................................................................................... 38
Capítulo 4. Programação ................................................................................................ 40
4.1 Comandos Básicos ................................................................................................ 40
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 dos 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.
 CAPÍTULO 1. UTILITÁRIOS

1.1 AJUDA NO MAPLE: HELP

O help (ajuda) é uma maneira de conseguir ajuda caso você saiba exatamente o
tópico a respeito do qual necessita de informações. Existem pelo menos duas formas de
acessá-lo:
1ª Na aba Help (ou Ajuda), conforme ilustração abaixo;

2ª Solicitando a abertura do help a partir do comando “?” seguido do tópico a ser

pesquisado. Exemplo:

>?plot;

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), conforme o exemplo:

>with(linalg);

Alguns pacotes disponíveis ao usuário são: plots, LinearAlgebra, 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 tal utiliza-se as
teclas SHIFT e ENTER simultaneamente na hora em que se deseja trocar 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. Exemplo:

>A=Matrix([[1,2,3],[4,5,6],[7,8,9]):
>A=Matrix([[1,2,3],[4,5,6],[7,8,9]);

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 digitando os
seguintes comandos:

>Re(2+7*I);

>Im(2+7*I);

Outro comando, que é bastante utilizado, é o solve, através do qual se pode encontrar
soluções de equações ou de sistemas de equações. Veja o exemplo:

>solve(x^2–5*x+6, x);

>solve( {3*m+n=7, 7*m+2*n=16}, [m, n]);

Exercício:
1. Utilize o comando solve para encontrar a solução do sistema de equações abaixo e
depois comente a solução encontrada.

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:

>f:=x->x^3+3;

>f(2);

Esta maneira de definir as funções oferece a possibilidade de calcularmos a imagem da

função definida para todos os valores do domínio. Observe a diferença entre as duas
maneiras utilizadas a seguir:

>g(x):=x^2+2*x+3;

>g(3);
>solve (g(x), x);

>g:=x->x^2+2*x+3;

>g(3);

Observe que da primeira forma como a função g(x) foi definida acima, somente é
possível encontrar valores de x para os quais , através do uso do
comando solve. Porém, se pedirmos para o MAPLE calcular o valor da função g(x) em
algum dos pontos do domínio, em 3 por exemplo, obteremos como resposta
simplesmente g(3).
Abaixo, apresentamos uma breve 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”.
É possível definirmos também funções “por partes” através do comando “piecewise”. Veja
um exemplo de uma função assim definida:

>alpha:=piecewise(t<0,-t^2+1,t>=0 and t<=1,1,t^2);

>plot(alpha,x=-2..2,thickness=4);
1.5 SOMATÓRIOS

Para simplesmente definirmos o somatório usamos o comando “Sum” e para que o

MAPLE nos forneça o resultado do somatório utilizamos “sum”. Veja:

>Sum((-1)^(1+n)/n, n=1..infinity)=sum((-1)^(1+n)/n,
n=1..infinity);

1.6 PRODUTÓRIO

Para o produtório o comando utilizado é “product”, sendo as funções do comando

diferenciadas pela inicial maiúscula ou minúscula, assim como no caso do somatório.
Observe:

>Product(k^2+k+1, k=0..5)=product(k^2+k+1, k=0..5);

1.7 LIMITES

Nesse caso o comando utilizado é “limit” e as regras também são as mesmas do

somatório e do produtório, conforme o exemplo:

>Limit(sin(x)/x, x=0)=limit(sin(x)/x, x=0);

1.8 DERIVADAS

Aqui, o comando usado é “diff” e as regras anteriores continuam valendo. Para

determinarmos a ordem da derivada usamos “$n”, onde n é a ordem desejada. Veja:

>Diff(y^3,y$1)=diff(y^3,y$1) and Diff(y^3,y$2)=diff(y^3,y$2);

1.9 INTEGRAIS INDEFINIDAS

Para integrais utilizamos o comando “int”, conforme o exemplo:

>Int(x^3+x^2+1, x)=int(x^3+x^2+1, x);

1.10 INTEGRAIS DEFINIDAS

O comando para integrais indefinidas e definidas é o mesmo. Aqui, simplesmente

definimos os limites de integração. Observe:

>Int(x^3+x^2+1, x=1..5)=int(x^3+x^2+1, x=1..5);

Exercícios:
1. Calcule os resultados de cada uma das expressões abaixo:
a) ∑

b)
c)
 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 sejam ambos 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,[1,2,3,4,5,6]);

>B:=Matrix(3,2,[[a,3],[5,f]]);

>C:=Matrix([[x,y],[z,w]]);

>v:=Vector(3,[a,b,c]);

*Utilizando o pacote linalg:

>restart:
>with(linalg):
>A:=matrix(2,3,[1,2,3,4,5,6]);
>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:

*Utilizando o pacote LinearAlgebra:

>restart:
>with(LinearAlgebra):
>N:=Matrix(2,4);

>ZeroMatrix(3);

>ZeroVector(2);

>Iden:=IdentityMatrix(4);

*Utilizando o pacote linalg:

>restart:
>with(linalg):
>N:=matrix(2,4,0);
>G:=Matrix(4,4,shape=identity);

2.1.3 OPERAÇÕES BÁSICAS

Considere as seguintes matrizes e vetores:

>restart:
>with(LinearAlgebra):
>A:=Matrix(2,2,[[1,2],[3,4]]);

>B:=Matrix(2,2,[[-5,6],[7,-8]]);

>a:=Vector(2,[[1],[-1]]);

>b:=Vector(2,[[2],[-3]]);

ADIÇÃO DE MATRIZES E VETORES

>C:=A+B;

>F:=A+(-B);

>a+b;
>a+(-b);

MULTIPLICAÇÃO DE MATRIZES E VETORES

>G:=Multiply(A,B);

>H:=Multiply(A,a);

DETERMINANTE

>Determinant(B);

TRAÇO DA MATRIZ

O traço é a soma dos elementos da diagonal principal:

>Trace(B);

TRANSPOSTA DE UMA MATRIZ

>Transpose(B);

MATRIZ INVERSA

>K:=MatrixInverse(B);
Vamos verificar se esta é realmente a matriz inversa de B:

>Multiply(B,K);

>Multiply(K,B);

Agora, considere a seguinte matriz:

>L:=Matrix(2,2,[[2,3],[4,6]]);

Observe que utilizando o comando para obter a matriz inversa temos:

>MatrixInverse(L);
Error, (in LinearAlgebra:-LA_Main:-MatrixInverse) singular
matrix

Neste caso, o MAPLE acusa que a matriz C é singular, ou seja, seu determinante é zero, o
que leva a matriz a não ser invertível. De fato:

>Determinant(L);

ELIMINAÇÃO DE LINHAS E COLUNAS DA MATRIZ

>R:=Matrix(3,3,[[5,2,7],[-3,10,2],[0,-1,-7]]);
>DeleteColumn(R,2);

>DeleteRow(R,[1,2]);

2.2 MATRIZES CUJAS ENTRADAS SÃO FUNÇÕES

Vamos agora trabalhar com matrizes cujas entradas são funções de uma variável:

>restart:
>with(LinearAlgebra):
>A:=Matrix(2,2,[[x^2,3],[5,cos(x)]]);

Caso se queira calcular o valor de cada coordenada quando , por exemplo,

podemos usar o seguinte comando:

>subs(x=0,A);

Este comando também é válido para funções, observe:

>f:=x^3+1;

>subs(x=3,f);

O comando Map percorre cada coordenada da matriz realizando nela a operação

desejada. Vejamos algumas aplicações deste comando:
Neste exemplo, queremos somar 3 a cada coordenada da matriz A.
>Map(x->x+3,A);

Pode-se também obter a derivada e a integral dos elementos da matriz A através do

comando Map:

>Map(diff,A,x);

>Map(int,A,x);

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):
>B:=Matrix(3,3,[3,-2,5,13,-3,-4,10,7,9]);

>Rank(B);

>C:=Matrix(2,2,[1,2,4,8]);

>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):
>a:=Vector(3,[1,2,3]);

>b:=Vector(3,[-1,2,-1]);

PRODUTO ESCALAR

>DotProduct(a,b);

PRODUTO VETORIAL

>CrossProduct(a,b);

NORMA EUCLIDIANA DE UM VETOR

>VectorNorm(a,2);

>VectorNorm(b,2);

ÂNGULO ENTRE DOIS VETORES

O ângulo entre dois vetores a e b pode ser encontrado a partir do produto interno da
seguinte maneira:

| || |
O MAPLE possui um comando específico para calcular o ângulo entre dois vetores a,b:

>theta:=VectorAngle(a,b);

2.4 AUTOVALORES E AUTOVETORES

Definição: Seja uma matriz quadrada de ordem n. 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

Este sistema tem solução se

,
já que , por definição. O polinômio é chamado polinômio
característico de A e será um polinômio de grau n em .

Duas maneiras de encontrarmos o polinômio característico:

>restart:
>with(LinearAlgebra):
>A:=Matrix(3,3,[[2,0,0],[-4,3,0],[-1,1,1]]);

>Determinant(A-lambda*IdentityMatrix(3));

>p(lambda):=CharacteristicPolynomial(A,lambda);

Para encontrarmos os autovalores através do polinômio característico utilizamos:

>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, conforme
mostramos a seguir.
 2.4.1 AUTOVALORES

Abaixo, temos um comando para encontrar os autovalores de :

>Eigenvalues(A);

Caso quiséssemos o primeiro, o segundo ou o terceiro autovalor separadamente,

poderíamos usar o seguinte comando:

>Eigenvalues(A)[1];

>Eigenvalues(A)[2];

>Eigenvalues(A)[3];

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 A:

>(v,e):=Eigenvectors(A);

Aqui, o vetor nos fornece os autovalores de e a matriz os autovetores de , de

forma que a i-ésima coluna de é autovetor associado ao i-ésimo elemento de . Ou
seja, para este exemplo, =[ ] é autovetor associado ao autovalor 2,
=[ ] é autovetor associado ao autovalor 3, e =[ ] é autovetor
associado ao autovalor 1.
O uso do comando Eigenvectors é equivalente a resolvermos o sistema
,
no qual  é autovalor e autovetor.

Exercício:
1. Verifique que as soluções encontradas anteriormente satisfazem, de fato, .

>v1:=DeleteColumn(e,[2,3]);

>Multiply(A,v1);

>v2:=DeleteColumn(e,[1,3]);

>Multiply(A,v2);

>v3:=DeleteColumn(e,[1,2]);

>Multiply(A,v3);

Observe que , e .
2.5 NULLSPACE DE UMA MATRIZ A

Por definição, Nullspace é o subespaço gerado pelos vetores que são solução de ,
onde é um vetor.

>restart:
>with(LinearAlgebra):
>A:=Matrix(2,2,[[2,4],[5,10]]);

>NullSpace(A);

Nullspace de é o núcleo de , e o comando Nullspace(A) nos dá uma base para o

núcleo de . Veja outro exemplo:

>B:=Matrix(3,3,[[2,2,3],[6,6,9],[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
GramSchmidt realiza este processo. Observe o exemplo:

>restart:
>with(LinearAlgebra):
>vv:=Vector(4,a);
>v[1]:=Vector(4,[[1],[2],[3],[4]]):
>v[2]:=Vector(4,[[3],[-2],[4],[-7]]):
>v[3]:=Vector(4,[[1],[2],[9],[3]]):
>ord:=GramSchmidt([v[1],v[2],v[3]]);

Caso seja necessário obter um conjunto de vetores ortonormais, procedemos da seguinte

maneira:

>s:=GramSchmidt({v[1],v[2],v[3]},normalized);

Exercício:
1. Aplique os comandos necessários para calcular a norma de um vetor e o produto
interno para verificar se, no exemplo anterior, os vetores encontrados são unitários e
ortogonais entre si.

>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, os vetores obtidos são dois a dois ortogonais.

2.7 FORMA CANÔNICA DE JORDAN

Dado um operador linear T 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 polinômio

característico são, respectivamente,

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 .

Observe o exemplo:

> 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ícios:
1. Verifique utilizando o comando Eigenvalues que no exemplo anterior os autovalores da
matriz T são os elementos da diagonal da matriz J.

>Eigenvectors(T);

2. Verifique se a matriz T, que tem como linhas os vetores (3, 1, -1), (2, 2, -1) e (2, 2, 0),
é diagonalizável calculando os polinômios mínimo e característico da matriz do operador.
Em seguida, calcule a forma canônica de Jordan de T.

>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);
3. Dada a matriz T cujas linhas são os vetores (1, 1, 0), (–1, 3, 0) e (–1, 1, 2), calcule os
polinômios característico e mínimo e conclua se a matriz é diagonalizável. Depois,
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));

>J:=JordanForm(T);

2.8 ELIMINAÇÃO GAUSSIANA

Dada uma matriz de ordem qualquer podemos utilizar o comando GaussianElimination

da seguinte forma:

> restart:
>with(LinearAlgebra):
> J:=Matrix(2,3,[5,4,3,2,1,0]);

> GaussianElimination(J);

> K:=Matrix(2,2,[3,4,5,6]);

> GaussianElimination(K);
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. Por exemplo, vamos
descobrir quais são os dois números em que o dobro do maior somado com o triplo do
menor resulta 16, e o maior deles somado com o quíntuplo do menor dá 1.
Para resolver esse problema escrevemos cada afirmação como uma equação matemática.
Assim se chamarmos de o número maior, o número menor, temos o seguinte
sistema de equações:

Matricialmente, podemos escrever:

[ ] [ ] [ ]
sendo
[ ] [ ], [ ]

Sabemos que o sistema tem uma única solução se o determinante da matriz for
diferente de zero. Vejamos:

>restart:
>with(LinearAlgebra):
>A:=Matrix([[2,3],[1,5]]);

>b:=Vector([[16],[1]]);

>Determinant(A);
Como sabe-se que a matriz é inversível, desta forma podemos calcular:

>x:=Multiply(MatrixInverse(A),b);

Assim, obtemos os seguintes valores para os números:

Pode-se resolver esse sistema utilizando o comando LinearSolve, como já vimos

anteriormente. Observe o exemplo:

>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 (Lower) 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:

O camando LUDecomposition(A) do MAPLE nos fornece, dada uma matriz , os fatores

, e a matriz de permutação P.

>(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 P=I 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(3,3,[2,1,1,1,3,1,1,1,4]);

>G:=LUDecomposition(A,method='Cholesky');
>Gt:=Transpose(G);

Onde verificamos que :

>Multiply(G,Gt);
 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);
d 
2
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:

> ci := y(0)=1,D(y)(1)=(0);
ci := 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,t)-diff(y(t),t)=y(t);
 d2 
edo :=  2 y( t )  y( t ) y( t )
d
 dt   dt 
> ci:=y(0)=1,D(y)(1)=(0);
ci := y( 0 )1, D( y )( 1 )0
> dsolve({edo,ci},y(t));
  5   ( 5  1 ) t
  2  1/2   2


2e e
y( t )
 5   5   5 
 1/2 2   1/2 2    2  1/2 
3e e 5 2 e
 5   ( 5  1 ) t
 1/2 2    2


2e e

 5   5   5 
 1/2 2    2  1/2    2  1/2 
2 e 3 e e 5

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 ( )

> with(DEtools):
> edo:=diff(y(t),t)-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 1 (5 t)
y( t ) cos( t ) sin( t )e _C1
13 13

Exemplo 2: Utilizando a Equação Diferencial

> with(DEtools):
> edo:=diff(y(x),x)=(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:

> with(DEtools):
> edo:=diff(y(t),t)+3*t^2*y(t)=0;
edo :=  y( t ) 3 t 2 y( t )0
d
 dt 
> dsolve(edo,y(t));
( t3 )
y( t )e _C1
> intfactor(edo);
( t3 )
e

3.2.2 EQUAÇÕES SEPARÁVEIS

Para resolvermos Equações Diferenciais Separáveis utilizamos o comando separablesol.

Exemplo:

> with(DEtools):
> edo:=diff(y(t),t)=3*t^4/(y(t));
d 3 t4
edo := y( t )
dt y( t )
> separablesol(edo,y(t));
 30 t 5150 _C1 30 t 5150 _C1
{ y( t ) , y( t ) }
5 5

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;
d x2x y( x )y( x )2
edo := 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 Exatas utilizamos o comando exactsol.

Exemplo:

> with(DEtools):
> edo:=diff(y(x),x$1)= 2*exp(2*x)+4*y(x)-3;
d ( 2 x)
edo := y( x )2 e 4 y( x )3
dx
> exactsol(edo,y(x));
2 3 4
{ y( x )( e x )  _C1 ( e x ) }
4

3.2.5 MÉTODO DE BERNOULLI

Para resolvermos Equações Diferenciais por Bernoulli utilizamos o comando

bernoulliosol.

Exemplo:

> with(DEtools):
> edo:=x^4* diff(y(x),x)+y(x)^3=x*y(x);
 edo := x4  y( x ) y( x )3x y( x )
d
 x
d 
> bernoullisol(edo,y(x));
   1 
 
 1 
  
 x2   x2 
 
 42 e    1
 erf  x4 e  
_C1 x  x
   x  ,
 y( x )  1   1 
   
  x2   x2 
 2e    1
 erf  x2 e   _C1 x
 x
  1 
 
 1 
   
 x2   x2 

 42 e    1 
 erf  x4 e  
_C1 x  x 
  
x  
y( x ) 
 1 
 
 1 
  
 x2   x2 
2e  
 erf  x2 e
1   
_C1 x 
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

sendo 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:
temos , para temos e para temos , o que
pode ser observado também no campo de direções.

> with(DEtools):
> edo:=diff(p(t),t)=0.5*p(t)-450;
d
edo := p( t )0.5 p( t )450
dt
> dfieldplot(edo,{p(t)},t=-
3..3,p=800..1000,color=magenta,title=`Campo de direções da
equação diferencial`);
Vejamos outros exemplos:

> with(DEtools):
> edo:=diff(y(t),t)+(2*y(t))=+4*(exp(3*t));
edo :=  y( t ) 2 y( t )4 e
d (3 t)

 dt 
> dfieldplot(edo,{y(t)},t=-4..4,y=-4..4,color=blue,title=`Campo
de direções da equação diferencial`);

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(-1)=-1]],y=-3..3);
Exercício: Plote o campo de direções da

utilizando o comando dfieldplot, e também utilizando o comando DEplot com a

condição inicial

> with(DEtools):
> edo:=diff(y(x),x)=(3*x+y(x))/(2*(exp(x))+y(x));
d 3 xy( x )
edo := y( x ) x
dx 2 e y( x )
> dfieldplot(edo,{y(x)},x=-5..5,y=-
5..5,color=magenta,dirgrid=[50,50],title=`Campo de direções da
equação diferencial`);

> DEplot(edo,y(x),x=-7..7,[[y(0)=-1]],colour=magenta,
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..1,
[[y(0)=0],[y(0)=1],[y(0)=-1]],colour=magenta,
linecolor=[black,blue,navy]);

> phaseportrait(Pi*diff(y(x),x)=5*y(x)-x^2-1,y(x),x=-3..3,
[[y(0)=0]],y=-3..3,colour=navy,linecolor=cyan,stepsize=5);
Exercício: Plote o plano de fase do EDO:
̇
com as condições iniciais: . 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:

> with(DEtools):
> edo:=diff(y(x),x)=-y(x)-x^2;
d
edo := y( x )y( x )x2
dx
> 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]);
 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é 4.

> for i from 1 to 4 do

10+i
od;
11
12
13
14
Se no exemplo anterior fosse necessário armazenarmos os valores obtidos poderíamos
proceder da seguinte forma:

> for i from 1 to 4 do

s[i]:=10+i
od;
s1 := 11
 s2 := 12
s3 := 13
s4 := 14

Exemplo: Utilize o comando for para escrever os números pares ( ) para

:

> 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 :

> 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é 5.

> for i from 1 to 5 do

Int(x^i,x)=int(x^i,x)
od;
2
x dx x

 2
3
x2 dx x

 3
4
x3 dx x

 4
5
x4 dx x

 5
6
x5 dx x

 6

Exemplo: Dada uma matriz (2x2), queremos somar 1 em cada uma de suas
coordenadas utilizando o comando for.

> A:=Matrix(2,2,[a,b,c,d]);
A := 
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);
a2 b2
 c2 d2
 

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]:=0;
x1 := 0
> if x[1]<=3 then n:=2 fi;
n := 2

O próximo exemplo é simples, mas posteriormente nos dará a ideia 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.

Exemplo: Dada a matriz A, A :=

2 4
 , crie uma matriz auxiliar B, tal que
 -1 9
{

> restart:with(LinearAlgebra):
> A:=Matrix(2,2,[2,4,-1,9]);
A := 
2 4

-1 9
> B:=Matrix(2,2,a);
B := 
a( 1, 1 ) a( 1, 2 )

a( 2, 1 ) a( 2, 2 )
> 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 4

0 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;
s := 0
> while s<=15 do
s:=s+1
od;
s := 1
s := 2
s := 3
s := 4
s := 5
s := 6
s := 7
s := 8
s := 9
s := 10
s := 11
s := 12
s := 13
s := 14
s := 15
s := 16

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.

Exemplo 1: Calcular o módulo de um número .

Neste exemplo temos como dado de entrada , podemos chamar o procedimento de
modulo, vejamos:

> modulo:=proc(x)
if x<=0 then
Mod(x):=-x
else
Mod(x):=x
fi;
end:
> modulo(2);
2
> modulo(-4);
4

Exemplo 2: Calcular a média aritmética para três valores dados:

> aritmetica:=proc(v1,v2,v3)
(v1+v2+v3)/3
end:
> aritmetica(2,3,4);
3
> aritmetica(10,5,16);
31
3

Exemplo 3: Calcular a média geométrica para 4 valores dados.

> geometrica:=proc(v1,v2,v3,v4)
evalf(v1*v2*v3*v4)^(1/4)
end:
> geometrica(2,3,4,5);
 3.309750920
> geometrica(1,8,4,16);
4.756828460

Exemplo 4: Somar os primeiros números naturais.

> soma:=proc(n)
local s,i;
s:=0;
for i from 1 to n do
s:=s+i
od;
end:
> soma(5);
15
> soma(340);
57970

Neste caso o comando local declara as variáveis que serão utilizadas no interior do
programa.

Exemplo 5: Declarar a função {

> 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(-5);
-5
> f(0);
0
Exemplo 6: Criar um programa que permita calcular o n-ésimo termo da sequência de
Fibonacci dado pela recursivamente por:

> 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(4);
3
> SeqFibonacci(11);
89

Exemplo 7: Calcular as matriz transposta conjugada de uma matriz de ordem .

> with(LinearAlgebra):
> transpostaconjugada:=proc(A,m,n)
local At, i,j;
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:
> B:=Matrix([ [I,2],[3,4] ]);
B := 
I 2

 3 4
> transpostaconjugada(B,2,2);
I 3
 2 4
 
Exemplo 8: Dadas duas matrizes e de ordem , criar um procedimento que
realize a soma destas matrizes.

> with(LinearAlgebra):
> Soma:=proc(A,B,m,n)
local M, i,j;
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:
> m:=2:
n:=3;
n := 3
> A:=Matrix(m,n,[[1,2,0],[0,2,1]]);
A := 
1 2 0

0 2 1
> B:=Matrix(m,n,[[1,1,1],[5,2,0]]);
B := 
1 1 1

5 2 0
> Soma(A,B,m,n);
2 3 1
 5 4 1
 
 BIBLIOGRAFIA

- ANDRADE, L. N.; Introdução à computação algébrica com o Maple. Rio de Janeiro:

Sociedade Brasileira de Matemática, 2004.

- BOLDRINI, J. L. et al. Álgebra Linear. 3 ed. São Paulo: Harbra, 1986.

- 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.

- NEVES, J. C. Programação em MAPLE. Disponível em

<http://www.slideshare.net/jeandson/introduo-programao-em-maple>. Acesso em 28
set. 2010.

- PORTUGAL, R.; Introdução ao Maple. Petrópolis - RJ, 2002.