UNIVERSIDADE FEDERAL DE S ANTA M ARIA CENTRO DE CIÊNCIAS N ATURAIS E EXATAS DEPARTAMENTO DE M ATEMÁTICA
LGEBRA LINEAR, EDO'S E PROGRAMAÇÃO NO MAPLE TÓPICOS DE Á LGEBRA
ALISSON D ARÓS S ANTOS D ANIELA DE ROSSO TOLFO LEONEL GIACOMINI DELATORRE
SUMÁRIO INTRODUÇÃO ......................... ....................................... ........................... .......................... .......................... ........................... ........................... ......................... ............ 4 C APÍTULO 1. UTILITÁRIOS .......................... ....................................... ........................... ........................... ........................... ........................... .................... ....... 5 1.1 A 1.1 A JUDA NO MAPLE: HELP........................... ........................................ .......................... ........................... ........................... ......................... ............ 5 1.2 P ACOTES .......................... ........................................ ........................... ........................... ........................... .......................... ........................... ..................... ....... 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 C APÍTULO 2. Á 2. ÁLGEBRA LINEAR ........................... ........................................ .......................... ........................... ........................... ......................... ............ 10 2.1 COMANDOS E OPERAÇÕES B ÁSICAS COM M ATRIZES ......................... ....................................... ........................... ............... 10 2.2 M ATRIZES CUJAS ENTRADAS ........................................ ........................... ........................... .............. 14 ENTRADAS SÃO FUNÇÕES .......................... 2.3 POSTO DE UMA MATRIZ , PRODUTO ESCALAR, PRODUTO VETORIAL E NORMA DE VETORES ... 15 2.4 A 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 C ANÔNICA DE JORDAN ......................... ....................................... ........................... ........................... ........................... ................ ... 20 2.8 ELIMINAÇÃO G AUSSIANA ........................... ........................................ .......................... ........................... ........................... ....................... .......... 23 2.9 RESOLUÇÃO DE SISTEMAS ........................... ........................................ .......................... ........................... ........................... ....................... .......... 23 C APÍ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 C AMPO DE DIREÇÕES PARA EQUAÇÕES DIFERENCIAIS DE PRIMEIRA ORDEM ...................... ...................... 31 3.3 PLANOS DE F ASE .......................... ....................................... .......................... ........................... ........................... .......................... ....................... .......... 34 3.4 EQUAÇÃO DO PÊNDULO ........................... ........................................ .......................... ........................... ........................... ....................... .......... 36 C APÍ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 e nvolvam 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.
C APÍTULO 1. UTILITÁRIOS 1.1 A JUDA 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
pesquisado.
“?”
seguido
do
Exemplo: >?matrix;
Que conduzirá a seguinte janela:
tópico
a
ser
1.2 P ACOTES 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 4
A :=
2
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]);
a 2, b -1 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 2
1 2
1 2
1 2
I 3 , I 3
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 no + + = .
ponto f(2).
f
>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); 2 1 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 x 0 x 0
1.8 DERIVADAS >Diff(x^2*sin(1/x),x$1)=diff(x^2*sin(1/x),x$1); d 2 1 1 1 cos x sin 2 x sin x x x d x
1.9 INTEGRAIS INDEFINIDAS >Int(x^2, x)=int(x^2, x); x3 2 x d x 3
1.10 INTEGRAIS DEFINIDAS >Int(x^2, x=1..3)=int(x^2, x=1..3); 3
26 2 x d x 3 1
C APÍTULO 2. ÁLGEBRA LINEAR 2.1 COMANDOS E OPERAÇÕES B ÁSICAS COM M ATRIZES 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
b
d
e
c
f
B:=Matrix(3,2,[[1,7],[5,6]]);
>
1 B := 5 0
7
1 4
2
0 6
>C:=Matrix([[1,2],[4,5]]); C :=
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
d
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 0 0 0
N := ZeroMatrix(2);
>
0 0
0
0
ZeroVector(2);
>
0 0
ou restart:
>
>with(linalg): >N:=matrix(2,2,0);
0 0
N :=
0
0
>M:=Matrix(3,3,shape=identity);
1 0 0 M := 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 0
A :=
6
5
B:=Matrix(2,2,[[1,4],[9,-1]]);
>
B :=
4
1
-1
9
e os vetores v:=Vector(2,[[1],[-1]]);
>
v :=
1
u :=
2
-1
u:=Vector(2,[[2],[-3]]);
>
-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
T RAÇO DA MATRIZ Soma dos elementos da diagonal >Trace(A);
9
T RANSPOSTA DE UMA M ATRIZ >Transpose(A);
4 6
0
5
M ATRIZ 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]]); C :=
1
3
1
3
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 9
7 0
>DeleteColumn(G,3);
2 -1 4 7 9 0
8 4
>DeleteRow(G,[1,3]); [4 7 8]
2.2 M ATRIZES 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 := x 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 x2 1 2
Pode-se dessa forma obter também a derivada das entradas da matriz >Map(diff,F,x);
1 0 2 x 0
e também sua integral >Map(int,F,x); 2
x 2 1 x3 x 3
0 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): >A:=Matrix(3,3,[1,3,2,4,7,1,6,13,5]); 1 3 2
7 1 6 13 5
A := 4
>Rank(A); 2
>B:=Matrix(2,2,[1,4,9,5]);
1 9
B :=
4
5
>Rank(B); 2
>C:=Matrix(2,3,[1,3,5,4,3,7]);
1 3 5 4 3 7
C := >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 V ETORIAL >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 − O qual tem solução se − já que ≠ por definição. O polinômio é chamado característico − que será um polinômio de grau em . =
= 0
= 0 = det (
0
Cálculo do polinômio característico >restart: with(LinearAlgebra): >A:=Matrix(2,2,[[4,2],[3,-1]]);
4 2 3 -1
A :=
)
>Determinant(A-lambda*IdentityMatrix(2));
103 2
Ou simplesmente >p(lambda):=CharacteristicPolynomial(A,lambda);
p() :=10 3
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);
v, e :=
5 2 , -2 1
-1 3
1
para este exemplo, =− é autovetor associado ao autovalor -2, e = é autovetor associado ao autovalor 5. O uso do comando Eigenvectors é equivalente a resolvermos o sistema , − no qual é autovalor e autovetor.
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
1 3
2
1
2 1
= 0
Exercício: 1. Verifique se as soluções encontradas satisfazem Solução:
. =
>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
vetor.
Por definição é o subepaço gerado pelos vetores que são solução de = 0, um
>restart: >with(LinearAlgebra): >A:=Matrix(2,2,[[1,2],[3,6]]);
1 3
2
A :=
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
2 4 3 3 6
B := 2
>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 GramSchmidt realiza 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 4190 76258 10 , , 2 30 2 12570 38129 15 6285 5866 30 44 12570 19 38129 15 6285 10894
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 C ANÔ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:
→ um operador linear cujos polinômio mínimo e o polinômio característico são, respectivamente, − ∙ − ∙⋯∙ − 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 . Teorema:Seja
:
=
1
=
1
1
2
1
2
2
2
= ( )
Exemplo 1:
> restart: > with(LinearAlgebra): > T:=Matrix(2,2,[3,1,2,2]);
T :=
3
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 0
J :=
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);
4, 1 1 1
-1 2
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
2 -1 2 2 0
T := 2
>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) >J:=JordanForm(T);
1 J := 0 0
0 2 0
0
2 1
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
1
2 0
2 0
2.8 ELIMINAÇÃO G AUSSIANA Dada uma matriz de ordem qualquer o comando GaussianElimination: > restart:with(LinearAlgebra): > B:=Matrix(2,3,[1,2,3,1,3,2]); 1 B := 1
3
2
2
3
> GaussianElimination(B);
1 2 3 0 1 -1 > C:=Matrix(2,2,[1,2,5,2]);
1 5
C :=
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 laranja e
o preço do hambúrguer, o preço do suco de 1
2
o preço da cocada temos o seguinte sistema de equações. 3
3 1 + 2 + 2 3 = 21,50 8 1 + 3 2 + 5 3 = 57 1 + 2 + 3 = 10
Matricialmente pode-se escrever
⇒ e =
sendo
3 1 2 8 3 5 × 1 1 1
1 2 3
3 1 2 21,5 = 8 3 5 , = 57 1 1 1 10
21,5 = 57 10 1
=
2 3
Sabemos que o sistema tem uma única solução se o determinante da matriz for diferente de zero. Vejamos: >restart: >with(LinearAlgebra): >A:=Matrix([[3,1,2],[8,3,5],[1,1,1]]);
3 1 2 A := 8 3 5 1 1 1 >b:=Vector([[21.5],[57],[10]]);
21.5 b := 57 10
>Determinant(A); 1
≠ sabe-se que a matriz é inversível, desta forma podemos calcular:
Como det
0
>x:=Multiply(MatrixInverse(A),b);
4. x :=2.50000000000000 3.50000000000000
Assim obtemos os seguintes valores das mercadorias:
, 1 =
4
2,5 e
2 =
3 =
3,5
Pode-se resolver esse sistema utilizando o comando: >LinearSolve(A,b);
4. 2.50000000000000 3.50000000000000
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
, 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: Dado o sistema
=
=
=
=
=
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 0 0 p, L, U := 0 1 0, 0 0 1
1
0
8 3
1
1 3
2
0
3 1 1 0 , 0 3 1 0 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.50000000000000 y := -0.333333333333330 3.499999999999994 >x:=LinearSolve(U,y);
4.00000000000000 x := 2.50000000000000 3.49999999999999
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
, como produto de uma matriz por sua transposta, ou seja, Sendo uma matriz triangular inferior com os elementos da diagonal estritamente sistema
=
=
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 0 Gt := 0 0
-1 3 -1
0 1 1 0 0 9 1
0
2
Onde verificamos que >Multiply(G,Gt);
16 -4 12 -4
-4 12 -4
-1 14 -2 1 -2 83 2 -1
1
C APÍ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);
d n y( t ) d t n
Dessa forma, para declararmos uma equação diferencial no MAPLE escrevemos: > edo:=diff(y(t),t$2)-5*y(t)=2*cos(t); d 2 edo := 2 y( t ) 5 y( t ) 2 cos( t ) d t
Para resolvermos um PVI devemos declarar, além da equação diferencial, as condições iniciais do problema, procedemos da seguinte maneira: > ics := y(0)=1,(D@@(1))(y)(1)=(0);
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 y( t ) 15
e
( 5 t )
5 ( 4 5 sin( 1 ) e (e
1 3
cos( t )
( 5)
2
) 1
( 5)
)
1 15
e
( 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 x 3 2 x 2 2 x _C1 , y( x ) 1
1 x 3 2 x 2 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 d t > dsolve(edo,y(t)); 1 y( t ) 1 t
e
( t )
_C1 t
> intfactor(edo); e
t
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 ) d t 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;
d x 2 x y( x ) y( x ) 2 edo := y( x ) d x x 2
> 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.
resolvermos Equações Diferenciais Exatas utilizamos o comando exactsol. Exemplo: − Exemplo: ²
2
+
=
(2x)
=
.
+
1.
> with(DEtools): > edo:=diff(y(x),x$1)= exp(2*x)+y(x)-1; ( 2 x ) d y( x ) 1 edo := y( x ) e d x > exactsol(edo,y(x)); 2
{ y( x ) ( e ) 1 _C1 e x } 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 ) d x > bernoullisol(edo,y(x)); { y( x )
x ln( x ) _C1
}
3.3 C AMPO 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) d x 2 x y x ( ) > dfieldplot(edo,{y(x)},x=-3..3,y=3..3,color=green,dirgrid=[50,50],title=`Campo de direções da equação diferencial`);
> DEplot(edo,y(x),x=-7..7,[[y(0)=1]],linecolor=[blue], y=-5..5);
3.3 PLANOS DE F ASE 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:
− . Utilize 0 = 0,
0 = 1,
0 =
1
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 equação (1) pode ser escrita como
≈, assim a ( )
(2) E tomando e temos o seguinte sistema associado a (2) − +
=
=
= 0
=
=
=
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 ) d t d t >g1:=DEplot(sistema1,{x(t),y(t)},t=-2..2,x=6..6,[[x(0)=k,y(0)=2] $ k=-5..5],y=6..6,color=brown,dirgrid=[20,20],linecolour=blue): >g2:=DEplot(sistema1,{x(t),y(t)},t=-2..2,x=6..6,[[x(0)=k,y(0)=-2] $ k=-5..5],y=6..6,color=brown,dirgrid=[20,20],linecolour=blue): >display([g1,g2]);
O plano de fase dado acima pode ser dado também por: >restart: >with(DEtools): >with(plots): >sistema1:=[diff(x(t),t)=y(t),diff(y(t),t)=-x(t)];
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:= x( t ) y( t ), y( t ) x( t ) d t d 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 x( t ) y( t ), d y( t ) sin( x( t ) ) d t d t
sistema1:=
>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 é (3) E tomando e temos o seguinte sistema associado a (2) −− +
=
=
+
( )= 0
=
=
=
( )
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 ) ) d t d t >g1:=DEplot(sistema1,{x(t),y(t)},t=-5..5,x=10..10,[[x(0)=k,y(0)=0] $ k=-10..10],y=10..10,color=gray,dirgrid=[20,20],linecolour=blue): >g2:=DEplot(sistema1,{x(t),y(t)},t=-5..5,x=10..10,[[x(0)=k,y(0)=-2] $ k=-10..10],y=10..10,color=gray,dirgrid=[20,20],linecolour=blue): >g3:=DEplot(sistema1,{x(t),y(t)},t=-5..5,x=10..10,[[x(0)=k,y(0)=2] $ k=-10..10],y=10..10,color=gray,dirgrid=[20,20],linecolour=blue): >display([g1,g2,g3],thickness=4);
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);
C APÍ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; s
:=11
s
:=12
s
:=13
1 2 3
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;
n
1
:=2
n :=4 2
n :=6 3
n :=8 4
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 n :=7 3
n :=9 4
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 d x 2 0 2
8 2 x d x 3 0
3 x d x 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 c
A := > 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);
b
d
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. 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 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.4021717
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);
505
− − ≤ Exemplo 5: Declarar a função ≥ =
, + 1,
2,
< 2
2 < 0 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, 1, 1 +
= 0 = 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 -2 I A := 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
