UNIVERSIDADE FEDERAL DE SANTA MARIA

CENTRO DE CINCIAS NATURAIS E EXATAS

DEPARTAMENTO DE MATEMTICA

TPICOS DE LGEBRA LINEAR, EDO'S E PROGRAMAO NO MAPLE

ALISSON DARS SANTOS

DANIELA DE ROSSO TOLFO
LEONEL GIACOMINI DELATORRE
 SUMRIO

INTRODUO ..................................................................................................................... 4

CAPTULO 1. UTILITRIOS .................................................................................................... 5

1.1 AJUDA NO MAPLE: HELP............................................................................................ 5

1.2 PACOTES .................................................................................................................. 6

1.3 INSTRUES BSICAS ................................................................................................. 6

1.4 FUNES .................................................................................................................. 7

1.5 SOMATRIOS ............................................................................................................ 9

1.6 PRODUTRIO ........................................................................................................... 9

1.7 LIMITES..................................................................................................................... 9

1.8 DERIVADAS ............................................................................................................... 9

1.9 INTEGRAIS INDEFINIDAS .............................................................................................. 9

1.10 INTEGRAIS DEFINIDAS ............................................................................................... 9

CAPTULO 2. LGEBRA LINEAR ............................................................................................ 10

2.1 COMANDOS E OPERAES BSICAS COM MATRIZES ..................................................... 10

2.2 MATRIZES CUJAS ENTRADAS SO FUNES ................................................................... 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 ORTOGONALIZAO DE GRAM-SCHIMIDT ............................................... 19

2.7 FORMA CANNICA DE JORDAN .................................................................................. 20

2.8 ELIMINAO GAUSSIANA .......................................................................................... 23

2.9 RESOLUO DE SISTEMAS .......................................................................................... 23

CAPTULO 3. EQUAES DIFERENCIAIS ORDINRIAS .............................................................. 28

 3.1 COMANDOS BSICOS ............................................................................................... 28

3.2 COMANDOS ESPECFICOS DE EDOS DE PRIMEIRA ORDEM ............................................ 29

3.3 CAMPO DE DIREES PARA EQUAES DIFERENCIAIS DE PRIMEIRA ORDEM ...................... 31

3.3 PLANOS DE FASE ...................................................................................................... 34

3.4 EQUAO DO PNDULO .......................................................................................... 36

CAPTULO 4. PROGRAMAO ............................................................................................. 42

4.1 COMANDOS BSICOS ............................................................................................... 42

4.2 PROCEDIMENTOS NO MAPLE ................................................................................... 45

BIBLIOGRAFIA ................................................................................................................... 49
 Introduo

Esta apostila foi desenvolvida como material de apoio ao Minicurso MAPLE

Avanado, organizado pelo Grupo PET Matemtica Programa de Educao Tutorial. Os
minicursos, bem como o material didtico desenvolvido, surgem como uma proposta de
qualificar a formao de bolsistas e acadmicos na utilizao de novas tecnologias
aplicadas ao ensino e pesquisa.
Neste material sero revistos alguns comandos bsicos do MAPLE que podem ser
utilizados no clculo de limites, derivadas e integrais, porm o enfoque principal est no
uso do MAPLE como ferramenta auxiliar em disciplinas como lgebra Linear, Equaes
Diferenciais Ordinrias, alm de disciplinas que envolvam programao.
Pretendemos fazer uma abordagem sobre os comandos que, em nossa experincia
de utilizao do software, foram mais relevantes. Isso no quer dizer que outros
comandos ou tpicos sejam menos importantes, mas sim que o material desenvolvido
baseia-se, principalmente, nas necessidades de utilizao do MAPLE at o presente
momento. Alm disso, nossos conhecimentos so restritos quando comparados
amplitude e s abrangentes possibilidades de utilizao do mesmo.
 CAPTULO 1. UTILITRIOS

1.1 AJUDA NO MAPLE: HELP

O help uma maneira de conseguir ajuda caso voc saiba exatamente o tpico a
respeito do qual voc necessita de informaes. Existem pelo menos duas formas de
acess-lo:
1 Na aba Help

2 Solicitando a abertura do help a partir do

comando ? seguido do tpico a ser
pesquisado.

Exemplo:
>?matrix;

Que conduzir a seguinte janela:

1.2 PACOTES

Alguns comandos do MAPLE so de uso especfico, por isso so agrupados em

pacotes (packages). Para ativar um pacote do MAPLE, utiliza-se o comando: with(nome
do pacote), veja
>with(LinearAlgebra):

Alguns pacotes disponveis ao usurio so: plots, linalg, DEtools, LinearAlgebra, Students.

1.3 INSTRUES BSICAS

O comando restart permite limpar a memria armazenada no MAPLE em

qualquer parte do documento. aconselhvel seu uso sempre no incio 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 vrgula (;) ou dois pontos (:). A
utilizao do ponto e vrgula tornar visvel ao usurio o resultado do comando utilizado,
no caso de utilizar dois pontos a visualizao ser ocultada. Ex.:
>A:=Matrix([[1,2],[4,5]]);
A :=
1 2

4 5
>A:=Matrix([[1,2],[4,5]]):

Para declarar uma varivel 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 nmero complexo, podemos encontrar sua parte real e imaginria da
seguinte forma:
>Re(4+I);;
4
>Im(1+3*I);
3
Um comando bastante utilizado o solve, com o qual podemos encontrar tanto
solues de equaes quanto sistemas de equaes:
>solve(2*x+y=0,x);
y

2
>solve( {2*a + b = 1, a+2*b=0}, [a,b]);

a , b
2 -1


3 3

Exerccio:
1. Aplique o comando solve ao sistema de equaes e comente a soluo encontrada.
2 + + = 1
+ 2 + = 0
5 + 4 + 3 = 2

1.4 FUNES

Uma maneira para definirmos uma funo no MAPLE usarmos o operador seta (-
>, isto , sinal de menos seguido do sinal de maior). Por exemplo:
>g:= x ->x^2 + 1;
g := xx21
>g(4);
17
Devemos definir a funo desta maneira porque da forma como atribumos
anteriormente o MAPLE apenas nos daria o valor de f(x), vejamos:
>f(x):=x^2+1*x+1=0;
f( x ) := x2x10
>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 funo x

+ + = . Mas se pedirmos algum outro ele no 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);

x2 x-1
2
g :=

x -1x and x1

x3
otherwise
>plot(g,x=-1.5..1.5,thickness=2,scaling=constrained);

Abaixo apresentamos uma pequena lista da sintaxe de algumas funes

matemticas no MAPLE (lembre-se que o MAPLE escrito em ingls):
funes trigonomtricas: sin(x), cos(x), tan(x), cot(x), sec(x), csc(x);
funes trigonomtricas inversas: arcsin(x), arccos(x), arctan(x), arccot(x),
arcsec(x), arccsc(x);
funo exponencial de base e: exp(x);
funo logartmica de base e: ln(x);
funo logartmica de base a, sendo a>0 qualquer: log[a](x);
funes hiperblicas: sinh(x), cosh(x), tanh(x), sech(x), csch(x), coth(x);
funes hiperblicas inversas: arcsinh(x), arccosh(x), arctanh(x), arcsech(x),
arccsch(x), arccotgh(x).

Para acessar informaes sobre essas e outras funes no MAPLE, utiliza-se o comando:
>?inifcn

que ir redirecionar ao help do MAPLE.

1.5 SOMATRIOS
>Sum(1/n^2, n=1..infinity)=sum(1/n^2, n=1..infinity);

2
2 6
1

n 1 n

1.6 PRODUTRIO
>Product(1/n, n=1..30)=product(1/n, n=1..30);
30
n 265252859812191058636308480000000
1 1
n 1

1.7 LIMITES
>Limit(x^2*sin(1/x), x=0)=limit(x^2*sin(1/x), x=0);
lim x2 sin 0
1
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
x sin 2 x sin cos
1 1
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 dx26

1 3
 CAPTULO 2. LGEBRA LINEAR

2.1 COMANDOS E OPERAES BSICAS COM MATRIZES

Os pacotes utilizados neste captulo sero essencialmente: LinearAlgebra e linalg.

Estes, embora relativos lgebra Linear, diferem em alguns comandos. Pensando nisso,
na medida do possvel, ser trabalhado paralelamente com os dois pacotes.
Para dar incio ao trabalho com matrizes, sero apresentados alguns comandos
bsicos relativos a este tpico.

2.1.1 Declarando matrizes e vetores

Existem vrias 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 b c

d e f

>B:=Matrix(3,2,[[1,7],[5,6]]);
1 7

B := 5 6

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

C :=
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 b c

d e 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);
N :=
0 0 0

0 0 0
>ZeroMatrix(2);
0 0

0 0
>ZeroVector(2);
0

0
ou
>restart:
>with(linalg):
>N:=matrix(2,2,0);
N :=
0 0

0 0
>M:=Matrix(3,3,shape=identity);

1 0 0

M := 0 1 0

0 0 1
2.1.3 Operaes bsicas

Sejam as matrizes
>with(LinearAlgebra):
>A:=Matrix(2,2,[[4,6],[0,5]]);
A :=
4 6

0 5
>B:=Matrix(2,2,[[1,4],[9,-1]]);
B :=
1 4

9 -1
e os vetores

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

ADIO DE MATRIZES E VETORES

>A+B;
5 10

9 4
>A+(-B);
3 2

-9 6
>v+u;
3

-4
>v+(-u);
-1

2
MULTIPLICAO DE MATRIZES E VETORES
>Multiply(A,B);
58 10

45 -5
>Multiply(A,u);
-10

-15

DETERMINANTE
>Determinant(A);
20
TRAO DA MATRIZ
Soma dos elementos da diagonal
>Trace(A);
 9
TRANSPOSTA DE UMA MATRIZ
>Transpose(A);
4 0

6 5
MATRIZ INVERSA
>MatrixInverse(A);
1 -3

4 10


1
0
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]]);
C :=
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 no ser inversvel.
>Determinant(C);
0

ELIMINAO 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 -1

4 7


9 0
>DeleteRow(G,[1,3]);
[4 7 8]

2.2 MATRIZES CUJAS ENTRADAS SO FUNES

Vamos agora trabalhar com matrizes cujas entradas so funes de uma varivel
>F:=Matrix(2,2,[[x,1],[x^2-1,0]]);

x 1
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 tambm vlido para funes
>f:=x^2+1;
f :=x21
>subs(x=1,f);
2
O comando Mappercorre cada coordenada da matriz realizando nessa a operao
desejada. Vejamos algumas aplicaes deste comando:
Neste exemplo estamos somando 2 a cada coordenada da matriz em questo.
>Map(x->x+2,F);
x2 3
2
x 1 2

Pode-se dessa forma obter tambm a derivada das entradas da matriz
>Map(diff,F,x);
1 0

2x 0
e tambm sua integral
>Map(int,F,x);
x
2
x
2


1 3
x x 0
3

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]);
B :=
1 4

9 5
>Rank(B);
2
>C:=Matrix(2,3,[1,3,5,4,3,7]);
C :=
1 3 5

4 3 7
>Rank(C);
2
Vamos agora apresentar comandos que forneam produto escalar, produto vetorial
norma e ngulo entre dois vetores. Dados dois vetores, , vejamos os comandos
relativos a estas operaes.
>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 especfico para calcular o ngulo dado por:
>theta:=VectorAngle(v,w);
6
:=arccos
6
Resultado que confere com a frmula para dada acima.

2.4 AUTOVALORES E AUTOVETORES

Definio: (autovalor e autovetor)

Seja uma matriz quadrada. Um escalar chamado de autovalor de se existe
um vetor no nulo tal que
=
qualquer vetor satisfazendo esta relao chamado de autovetor de associado ao
autovalor .
Os autovalores e autovetores da matriz podem ser calculados atravs do sistema
= 0
O qual tem soluo se
= 0
j que 0por definio. O polinmio = det ( ) chamado caracterstico
que ser um polinmio de grau em .

Clculo do polinmio caracterstico

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

A :=
4 2

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

1032
Ou simplesmente
>p(lambda):=CharacteristicPolynomial(A,lambda);

p() :=1032

Para encontrarmos os autovalores atravs do polinmio caracterstico resolvemos

>solve(p(lambda)=0);
5, -2
No MAPLE existem comandos especficos para calcular os autovalores e
autovetores de uma matriz sem utilizarmos explicitamente o polinmio caracterstico.

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 razes do
polinmio caracterstico de .

2.4.2 AUTOVETORES

Agora vamos encontrar os autovetores de P

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

5 2
-1

v, e := , 3
-2 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,
1
3 2
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.

Exerccio:
1. Verifique se as solues encontradas satisfazem = .
Soluo:
>v1:=DeleteColumn(e,2);
v1 :=
2
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 definio o subepao gerado pelos vetores que so soluo de = 0, um

vetor.

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

3 6
>NullSpace(A);
{ }
-2
1
Nullspace de o ncleo de , e o comando Nullspace(A) nos d uma base para
o ncleo 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 ORTOGONALIZAO DE GRAM-SCHIMIDT

Dado um conjunto LI de vetores a aplicao do processo de ortogonalizao 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]]);

8

5

-2
1 -17

1 -1
ord :=
10
, ,
1 1 -13

1 2
10


7

5

Caso seja necessrio 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 5866
6285


30 44 12570 19 38129

15 6285 10894
Exerccio:
1. Aplique os comandos para calcular norma de um vetor e produto escalar para verificar
se no exemplo anterior os vetores encontrados so unitrios e ortogonais entre si.
Soluo:
>DotProduct(s[1],s[1]);
1
>DotProduct(s[2],s[2]);
1
>DotProduct(s[3],s[3]);
1
Da conclumos que os vetores obtidos so unitrios.
>DotProduct(s[1],s[2]);
0
>DotProduct(s[1],s[3]);
0
>DotProduct(s[2],s[3]);
0
E ento que so dois a dois ortogonais.

2.7 FORMA CANNICA DE JORDAN

Dado um operador linear podemos escrever a Forma de Cannica de Jordan

deste operador. A Forma Cannica de Jordan descrita pelo seguinte teorema:
 Teorema:Seja : um operador linear cujos polinmio mnimo e o
polinmio caracterstico so, respectivamente,
1 2
= 1 2
e
1 2
= 1 2
Onde os so escalares distintos. Ento possui uma representao 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 so de ordem
.
(ii) A soma das ordens dos .
(iii) A quantidade dos a multiplicidade geomtrica de .
(iv) A quantidade dos blocos de uma ordem qualquer possvel unicamente
determinada por .
Exemplo 1:
> restart:
> with(LinearAlgebra):
> T:=Matrix(2,2,[3,1,2,2]);
T :=
3 1

2 2
> p(x):=factor(CharacteristicPolynomial(T,x));

p(x) :=(x1) (x4)

>m(x):=factor(MinimalPolynomial(T,x));

m(x) :=(x1) (x4)

>J:=JordanForm(T);
J :=
1 0

0 4
Exerccio: Verifique que no exemplo anterior os autovalores da matriz T, utilizando o
comando Eigenvalues.

Observao:
Cabe aqui lembrar que uma matriz diagonalizvel se o polinmio minimal mnico.
>Eigenvectors(T);
-1
4, 1 2

1 1 1

3 1 -1

Exerccio: Verifique se a matriz T := 2 2 -1 diagonalizvel, calculando os

2 2 0
polinmios minimal e caracterstico da matriz do operador. Em seguida calcule a forma
cannica 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) :=(x1) (x2)2

>m(x):=factor(MinimalPolynomial(T,x));

m(x) :=(x1) (x2)2

>J:=JordanForm(T);
1 0 0

J := 0 2 1

0 0 2

1 1 0

Exerccio: Dada a matriz T := -1 3 0 calcule o polinmio caracterstico e minimal,

-1 1 2
conclua se a matriz diagonalizvel. E ento calcule a Forma Cannica 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) :=(x2)3
>m(x):=factor(MinimalPolynomial(T,x));

m(x) :=(x2)2
>J:=JordanForm(T);

2 1 0

J := 0 2 0

0 0 2

2.8 ELIMINAO GAUSSIANA

Dada uma matriz de ordem qualquer o comando GaussianElimination:

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

1 3 2
> GaussianElimination(B);
1 2 3

0 1 -1
> C:=Matrix(2,2,[1,2,5,2]);
C :=
1 2

5 2
> GaussianElimination(C);
1 2

0 -8

2.9 RESOLUO DE SISTEMAS

Modelando situaes reais podemos nos deparar com diferentes tipos de sistemas.
Aqui sero abordados alguns mtodos para resoluo de sistemas lineares.
Exemplo:
(Fuvest 2008) Joo entrou na lanchonete BOG e pediu 3
hambrgueres, 1 suco de laranja e 2 cocadas, gastando R$
21,50. Na mesa ao lado, algumas pessoas pediram 8
hambrgueres, 3 sucos de laranja e 5 cocadas, gastando R$
57,00. Sabendo-se que o preo de um hambrguer, mais o de
um suco de laranja, mais o de uma cocada totaliza R$ 10,00,
calcule o preo de cada um desses itens.

Para resolver esse problema escrevemos cada afirmao como uma equao
matemtica. Assim se chamarmos de 1 o preo do hambrguer, 2 o preo do suco de
laranja e 3 o preo da cocada temos o seguinte sistema de equaes.
 31 + 2 + 23 = 21,50
81 + 32 + 53 = 57
1 + 2 + 3 = 10

Matricialmente pode-se escrever

3 1 2 1 21,5
= 8 3 5 2 = 57
1 1 1 3 10
sendo
3 1 2 21,5 1
= 8 3 5 , = 57 e = 2

1 1 1 10 3

Sabemos que o sistema tem uma nica soluo 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 1 2

A := 8 3 5

1 1 1

>b:=Vector([[21.5],[57],[10]]);

21.5

b := 57

10

>Determinant(A);
1
Como det 0 sabe-se que a matriz inversvel, 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 vrios tipos de decomposio de matrizes que permitem resolver sistemas

lineares, como Fatorao LU, Fatorao de Cholesky, Fatorao LDU, Decomposio
QR, Decomposio em valores singulares (SVD). Abordaremos aqui apenas a Fatorao
LU e Fatorao de Cholesky.

2.9.1 Fatorao LU

Dado o sistema = , matriz quadrada e no singular, a fatorao 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 fatorao = , 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 permutao.

>(p,L,U):=LUDecomposition(A,method='GaussianElimination');

1 0 0
3 1 2
1 0 0 8
0 -1
0,
1 1
p, L, U := 0 , 0
3
1 3
3
1
0 1 0
0 1
2 0 1
3
A matriz p, chamada matriz de permutao, determina o pivoteamento realizado.
Agora vamos resolver os sistemas determinados pela fatorao:
>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


x :=


2.50000000000000356


3.49999999999999422

Como a matriz permutao altera as linhas do sistema, a mesma deve ser

multiplicada pelo vetor a fim de realizar a mesma permutao neste vetor. Como no
exemplo anterior a matriz de permutao a identidade as linhas do vetor no sero
alteradas, mas importante prestar ateno a este detalhe, pois = no um caso
geral.
2.9.2 Fatorao de Cholesky

Esta fatorao prope decompor a matriz simtrica 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 -1 14 -2

-4 -2 83
1
 CAPTULO 3. EQUAES DIFERENCIAIS ORDINRIAS

Para obter resultados relacionados a equaes diferenciais ordinrias no MAPLE

utilizamos o pacote DEtools. Esse pacote permite encontrar a soluo de algumas
equaes, resolver problemas de valor inicial, plotar o grfico de suas solues e plotar o
campo de direes.

3.1 COMANDOS BSICOS

Para declarar uma EDO precisamos identificar a ordem de cada derivada presente
na equao. Por exemplo, se quisermos declarar a derivada de ordem de uma
funono MAPLE, escrevemos:
>diff(y(t),t$n);
dn
y( t )
dtn
Dessa forma, para declararmos uma equao 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, alm da equao diferencial, as

condies 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));
( 5 t) ( 5) ( 5 t ) ( 5) ( 5)
1 e 5 ( 4 5 sin( 1 ) e ) 1 e e ( 20 e 5 sin( 1 ) )
y( t ) 2
2
15 ( 5) 15 ( 5)
(e ) 1 (e ) 1
1
cos( t )
3
 Utilizando o comando dsolve obtemos uma soluo para a equao diferencial,
porm este comando no identifica o mtodo utilizado. Para isso utiliza-se o comando
infolevel. O valor identificado no comando infolevel varia nos nveis:
- Nvel 2,3: informaes gerais, incluindo a tcnica ou algoritmo usado.
- Nvel 4,5: informaes mais detalhadas sobre como o problema est sendo resolvido.

Vejamos alguns exemplos:

Exemplo 1: Utilizando a Equao 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 1 (5 t )
y( t ) cos ( t ) sin( t )e _C1
13 13

3+4+2
Exemplo 2: Utilizando a Equao Diferencial = 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 1x32 x22 x_C1 , y( x )1 1x32 x22 x_C1

3.2 COMANDOS ESPECFICOS DE EDOS DE PRIMEIRA ORDEM

3.2.1 Fator Integrante

 Para resolvermos as equaes por fator integrante usamos o comando dsolve, mas se
desejarmos saber qual o fator integrante na Equao Diferencial, usamos o comando
intfactor.

Exemplo: + + 1 = .

> with(DEtools):
> edo:=t*diff(y(t),t)+(t+1)*y(t)=t;
>
edo := t y( t ) ( t1 ) y( t )t
d
dt
> dsolve(edo,y(t));
( t )
1 e _C1
y( t )1
t t
> intfactor(edo);
et

3.2.2 Equaes Separveis

Para resolvermos Equaes Diferenciais Separveis utilizamos o comando

separablesol.
12
Exemplo: = .
()

> with(DEtools):
> edo:=diff(y(t),t)=(1-2*t)/y(t);

d 12 t
edo := y( t )
dt y( t )

> separablesol(edo,y(t));

{ y( t ) 2 t2 t 22 _C1 , y( t ) 2 t2 t 22 _C1 }

3.2.3 EQUAES HOMOGNEAS

Para resolvermos Equaes Diferenciais Homogneas utilizamos o comando

genhomosol.
+
Exemplo: = .

> with(DEtools):
> edo:= diff(y(x),x$1)=(x^2+x*y(x)+y(x)^2)/x^2;
 d x 2x y( x )y( x ) 2
edo := y( x )
dx x2
> genhomosol(edo,y(x));

{ y( x )tan( ln( x )_C1 ) x }

3.2.4 Equaes Exatas

Para resolvermos Equaes Diferenciais por Bernoulli utilizamos o comando

bernoulliosol.

Exemplo: + 2
= .

resolvermos Equaes Diferenciais Exatas utilizamos o comando exactsol.

Exemplo: = (2x) + 1.

> with(DEtools):
> edo:=diff(y(x),x$1)= exp(2*x)+y(x)-1;
d (2 x )
edo := y( x )e y( x )1
dx

> exactsol(edo,y(x));
2
{ y( x )( e x ) 1_C1 e x }

3.2.5 Mtodo de Bernoulli

> with(DEtools):
> edo:=x^2* diff(y(x),x$1)+y(x)^2=x*y(x);
edo := y( x ) x 2y( x ) 2x y( x )
d
dx
> bernoullisol(edo,y(x));
x
{ y( x ) }
ln( x )_C1

3.3 CAMPO DE DIREES PARA EQUAES DIFERENCIAIS DE PRIMEIRA ORDEM

Para plotar o campo de direes de Edo utilizamos o comando dfieldplot. Vamos

atravs de um exemplo construir o campo de direes.
Exemplo (Boice 2006): Seja uma populao de presas dada pela equao
diferencial

= 0.5 450

sendo 0.5 a taxa de crescimento da populao de presas por ms na ausncia de
predadores e 450 o nmero de presas mortas pelos predadores por ms.
Podemos observar que para valores de temos:

> 900 temos > 0, para < 900 temos < 0 e para = 900 temos = 0, o que

pode ser observado tambm no campo de direes.

> 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 direes da
equao 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 direes da equao diferencial dy/dt-2*y(t)=3*(exp(t))`);
 Caso deseja-se plotar no campo de direes uma soluo da equao, dadas as
condies iniciais podemos utilizar o comando DEplot. Exemplo:

> DEplot(edo,y(t),t=-3..3,[[y(0)=1]],y=-3..3);

Exerccio: Plote o campo de direes da

4 + 3
=
2 +
utilizando o comando dfieldplot, e tambm utilizando o comando DEplot com a
condio inicial 0 = 1.

> restart:
> with(DEtools):
> edo:=diff(y(x),x)=(-((4*x)+(3*y(x)))/((2*x)+(y(x))));
d 4 x3 y( x)
edo := y( x)
dx 2 xy( x)
> dfieldplot(edo,{y(x)},x=-3..3,y=-
3..3,color=green,dirgrid=[50,50],title=`Campo de direes da
equao 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 construdo com a utilizao do comando phaseportrait, no

qual so explicitadas as condies iniciais que desejamos plotar as solues, 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);

Exerccio: Plote o plano de fase do EDO:

= 2
com as condies iniciais: 0 = 0, 0 = 1, 0 = 1. Utilize o Ttulo Plano de
FAse, como cor das solues defina, azul, preto e vermelho, e como cor do campo de
direes 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 EQUAO DO PNDULO

Nesta seo vamos obter os planos de fase da equao do pndulo. Para isso
consideraremos as seguintes situaes: pndulo no amortecido, com pequenas
oscilaes e com oscilaes maiores e o pndulo amortecidos. Para cada caso ser
construdo o plano de fase com uma animao em relao ao tempo.

3.4.1 Pndulo no amortecido

A equao que modela o movimento do pndulo simples no amortecido

+ () = 0 (1)

Para o caso com pequenas oscilaes, podemos considerar () , assim a

equao (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)];
sistema1:= x( t )y( t ), y( t )x( t )
d d
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 tambm 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);
sistema1:=
d d
dt x( t )y( t ), dt y( t )x( t )

O plano de fase animado para a equao (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 oscilaes maiores temos a equao (1) que pode ser
representada como o sistema de equaes de primeira ordem,
=
= sin ()
>restart:
>with(DEtools):
>with(plots):
>sistema1:=[diff(x(t),t)=y(t),diff(y(t),t)=-sin(x(t))];
sistema1:= x( t )y( t ), y( t )sin( x( t ) )
d d
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 Pndulo com amortecimento

A equao que modela o movimento do pndulo simples no 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))];
sistema1:= x( t )y( t ), y( t )y( t )4 sin( x( t ) )
d d
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=`Vibrao
do Pndulo`,dirfield=300,color=magnitude,linecolor=blue,
animate=true);
 CAPTULO 4. PROGRAMAO

Neste captulo procura-se apresentar alguns dos comandos bsicos para

programao, e alguns exemplos de programas simples.

4.1 COMANDOS BSICOS

4.1.1 Comando: for

O comando for uma estrutura de programao que permite realizar iteraes,

loop. Este comando dado da seguinte forma:
for i from a to b do
comando a ser realizado
od;
Sendo:
i: varivel do loop;
a: valor inicial;
b: valor final.
Observao: O comando for sempre deve ser encerrado com od.
Exemplo: Somar 10 uma varivel 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 necessrio armazenarmos os valores obtidos
poderamos 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 nmeros 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

Exerccio: Utilizando o comando para obter os alguns nmeros pares, obtenha

agora os nmeros 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

Exerccio: Calcule as integrais das funes = 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 dx2

0
2
x2 dx8

0 3
2
x3 dx4

0

Exemplo: Dada uma matriz , queremos somar 1 em cada uma de suas

coordenadas utilizando o comando for.
 Observao: Essa operao j foi realizada utilizando o comando Map.
> restart:
> 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);
a1 b1

c1 d1
4.1.2 Comando: if

A estrutura if permite que executemos um determinado comando sob certas

condies. De maneira geral executado da seguinte forma:
if condio then comando1 else comando2 fi;
Observao: 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 prximo exemplo simples, mas posteriormente nos dar a idia de como

definir uma funo.
> 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
, , , > 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 4

0 9
4.1.3 Comando: while

Com o comando while permite tambm criarmos uma espcie de loop. Para
este comando utilizamos a seguinte estrutura.
while do b od;
onde:
: condio;
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
programao. 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 variveis que representam os dados de
entrada do programa. Geralmente coloca-se um nome neste programa, para que
posteriormente possamos acion-lo. Vamos atravs de um exemplo ilustrar as
observaes realizadas acima.
Exemplo 1: Calcular o mdulo de um nmero .
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 mdia aritmtica para trs valores dados:
> restart:
aritmetica:=proc(v1,v2,v3)
(v1+v2+v3)/3
end:

> aritmetica(7,8,9);
8
Exemplo 3: Calcular a mdia geomtrica 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 nmeros 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 variveis que sero utilizadas no interior do
programa.
> soma(100);
5050
, < 2
Exemplo 5: Declarar a funo = + 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);
4
Exemplo 6: Criar um programa que permita calcular o n-simo termo da sequncia 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]]);
A :=
I 2 -2I

4 0 2
> transpostaconjugada(A,m,n);
I 4

2 0


2 I 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. Programao em MAPLE. Disponvel em

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

- ANDRADE, L. N.; Introduo computao algbrica com o MAPLE. Rio de Janeiro:

Sociedade Brasileira de Matemtica, 2004.

- PORTUGAL, R.; Introduo ao MAPLE. Petrpolis - RJ, 2002.

- RUGGIERO, M. A. G. & LOPES, V. L. R. Clculo numrico: aspectos tericos e

computacionais. 2.ed. So Paulo, Makron, 1997.

- LIPSCHUTZ, S. lgebra Linear. 3.ed. COLEAO SCHAUM. Porto Alegre, bookman,

2008.

- BOYCE, W. E.; Di PRIMA, R. C. Equaes Diferenciais Elementares e Problemas de

Valores de Contorno. Traduo de Valria Magalhes. 8. Ed. Rio de Janeiro: LTC, 2006.