Você está na página 1de 68

Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Maple Básico
Nessa apostila daremos ênfase a alguns princípios relacionados às matérias do básico dos
cursos de exatas. Será bastante proveitoso, se ao final de cada aula, o aluno resolver os
exercícios propostos para que possa se familiarizar com os comandos do Maple. Qualquer
dúvida o estudante pode verificar a ajuda do Maple. HELP>Topic Search ou HELP>Full
Text Search.

1. NÚMEROS .................................................................................................................................................... 3

2. RESOLVENDO EQUAÇÕES ................................................................................................................... 6


EXERCÍCIOS: ..................................................................................................................................................... 9
3. SIMPLIFICANDO EXPRESSÕES ..................................................................................................... 10
EXERCÍCIOS: ................................................................................................................................................... 17
4. ÁLGEBRA LINEAR.................................................................................................................................. 18
EXERCÍCIO: ..................................................................................................................................................... 22
5. GRÁFICOS.................................................................................................................................................. 23
GRÁFICOS EM DUAS DIMENSÕES:............................................................................................................. 23
GRÁFICOS DE FUNÇÕES PARAMETRIZADAS:........................................................................................... 26
GRÁFICOS EM COORDENADAS POLARES: ................................................................................................ 27
FUNÇÕES CONTÍNUAS POR PARTES:......................................................................................................... 28
GRÁFICOS EM 3D: ....................................................................................................................................... 30
GRÁFICOS SIMULTÂNEOS:.......................................................................................................................... 31
EXERCÍCIOS: ................................................................................................................................................... 32
6. CÁLCULO DIFERENCIAL E INTEGRAL ........................................................................................ 33
LIMITES, SOMATÓRIOS E PRODUTÓRIOS: ............................................................................................. 33
DIFERENCIAÇÃO: ......................................................................................................................................... 35
INTEGRAÇÃO:................................................................................................................................................ 37
EXPANSÃO EM SÉRIES: ............................................................................................................................... 39
O PACOTE STUDENT, FERRAMENTAS DE CÁLCULO:............................................................................... 40
CÁLCULO VETORIAL: ................................................................................................................................... 42
EXERCÍCIOS ..................................................................................................................................................... 44

1
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

7. PROGRAMAÇÃO...................................................................................................................................... 46
ITERAÇÕES: ................................................................................................................................................... 47
SEQÜÊNCIAS: ................................................................................................................................................ 50
ANEXO A .......................................................................................................................................................... 52

ANEXO B .......................................................................................................................................................... 53
RESOLUÇÃO DE SISTEMAS LINEARES: ..................................................................................................... 53
SOMA DE RIEMANN: .................................................................................................................................... 56
CÁLCULO DE ÁREA ENTRE DUAS CURVAS: ............................................................................................... 59
INTEGRAL POR PARTES:.............................................................................................................................. 61
EXEMPLOS DE GRÁFICOS EM COORDENADAS POLARES:....................................................................... 63
RESOLUÇÃO DE EDO COM PLOTAGEM DE GRÁFICO: ............................................................................ 64

2
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

1. Números
O Maple usualmente procura trabalhar com números de forma exata. Por exemplo,

> (23^(1/2)/11+2/5)^2;
2
 1 23 + 2 
 
 11 5 

Ou seja, se números racionais são dados na entrada, racionais também são dados na
saída. Uma aproximação decimal pode ser obtida através do comando evalf:

> evalf(%);

.6988703917

onde a "porcentagem" no argumento de evalf assumem o valor do último resultado


calculado. O resultado acima foi dado com uma precisão de dez dígitos, mas podemos
obter uma aproximação para um número qualquer de dígitos. Por exemplo, para calcular
a expressão acima com a precisão de 70 dígitos procedemos do seguinte modo:

> evalf(%%,71);

.698870391778115140215350867476295095008024974948399489661741489315245\
16

Um modo de induzir a saída em notação flutuante é fazer com que ao menos um dos
números na entrada seja introduzido desta forma:

> 2/3*1.0;

.6666666667

Há um modo de estabelecer o número de dígitos desejado em qualquer operação de


ponto flutuante sem utilizar evalf ,através da atribuição à variável Digits. O default, como
já vimos é dez:

> Digits;

10

> Digits:=30;

Digits := 30

> sin(0.3);

.295520206661339575105320745685

3
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Números irracionais não são avaliados sem que o usuário peça, embora simplificações
elementares sejam feitas automaticamente:

> Digits:=10;

Digits := 10

> 10*sin(n*Pi)/(10*3);

1
sin( n π )
3

Na expressão acima, n é normalmente subentendido como um número inteiro. Isto pode


ser declarado através do seguinte comando:

> assume(n,integer);

> sin(n*Pi);

> cos(n*Pi);

( -1 )n~

Consideremos agora números complexos. Suponhamos que queremos encontrar as


raízes cúbicas de -8:

> z:=(-8)^(1/3);
( 1/3 )
z := ( -8 )

Para encontrar explicitamente as raízes devemos converter este número para a forma
RootOf e usar em seguida o comando allvalues:

> convert(z,RootOf);

1 + RootOf( _Z 2 + 3, index = 1 )

> allvalues(%);

1+I 3

Expressões envolvendo números complexos em forma explícita são sempre simplificados.


Por exemplo:

> (2+5*I)*(3-I)^2/(5+I);

129 47
+ I
13 13

4
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Simplificações não ocorrem quando uma variável simbólica estiver envolvida:

> z:=(2-a*I)^2/(a+2*I);

( 2 − I a )2
z :=
a+2I

Para forçar a saída na forma convencional devemos usar o comando evalc (evaluate in
complex context):

> evalc(z);

( 4 − a2 ) a 8a  a2 2 ( 4 − a2 ) 
− + I  −4 − 
a2 + 4 a2 + 4  a2 + 4 a 2 + 4 

O comando evalc considera a variável a como sendo real, a menos que o usuário a
declare complexa através do comando assume. As partes real e imaginária de um
número complexo, e o seu valor absoluto, podem ser obtidos, respectivamente, da
seguinte forma:

> evalc(Re(z));

( 4 − a2 ) a 8a
2
− 2
a +4 a +4

> evalc(Im(z));

a2 2 ( 4 − a2 )
−4 −
a2 + 4 a2 + 4

> evalc(abs(z));

2 2
( 4 − a2 ) a a2 2 ( 4 − a2 ) 

8a  
−  +  −4 − 
 a 2 + 4 a 2 + 4   a2 + 4 a 2 + 4 

> simplify(%);

a2 + 4

5
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

2. Resolvendo equações
> restart:

Vamos agora considerar equações algébricas do tipo

> eq1:=a*x^2+b*x+c=0;

eq1 := a x2 + b x + c = 0

Podemos resolver esta equação para x :

> sol:=solve(eq1,x);

1 −b + b2 − 4 a c 1 −b − b2 − 4 a c
sol := ,
2 a 2 a

> sol[1];

1 −b + b2 − 4 a c
2 a

> sol[2];

1 −b − b2 − 4 a c
2 a

Consideremos algumas equações mais específicas, dando valores às constantes a , b e


c :

> eq2:=subs(a=1,b=3,c=-4/5,eq1);

4
eq2 := x2 + 3 x − = 0
5

> sol:=solve(eq2,x);

3 1 3 1
sol := − + 305 , − − 305
2 10 2 10

Em pontos flutuantes,

> evalf(sol);

.246424920, -3.246424920

6
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Poderíamos ter escrito desde o início,

> evalf(solve(eq2,x));

.246424920, -3.246424920

ou

> fsolve(eq2,x);

-3.246424920, .2464249197

Estas duas formas não sempre equivalentes, no entanto. Consideremos, por exemplo,

> eq3:=x^3-x^2+1;

eq3 := x3 − x2 + 1

> evalf(solve(eq3));

-.7548776667, .8774388331 − .7448617670 I, .8774388331 + .7448617670 I

> fsolve(eq3);

-.7548776662

Para que o comando fsolve possa encontrar também raízes complexas o argumento
complex deve ser dado:

> fsolve(eq3=0,x,complex);

-.7548776662, .8774388331 − .7448617666 I, .8774388331 + .7448617666 I

Vejamos outro exemplo com uma equação não polinomial:

> eq4:=sin(x)+x^(1/2)-3/2;

3
eq4 := sin( x ) + x −
2

> evalf(solve(eq4,x));

.7141134004

> fsolve(eq4);

3.530173727

7
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Para esclarecer este dilema façamos um gráfico:

> plot(eq4,x=0..14);

Portanto, ambos comandos dão resultados corretos mas incompletos. O conhecimento do


gráfico nos dá uma indicação da localização das raízes e fsolve pode ser utilizado para
determinar os seus valores exatos:

> r1:=fsolve(eq4,x,0..2);

r1 := .7141134004

> r2:=fsolve(eq4,x,2..4);

r2 := 3.530173727

> r3:=fsolve(eq4,x,4..6);

r3 := 5.338242169

Inequações:

Quando uma inequação é passada como argumento do solve, o Maple encontra o


intervalo que satisfaz a inequação para a variável contida entre chaves.

> solve(x^2+x<2,{x});

{ -2 < x, x < 1 }

Note que quando há mais de uma resposta, o resultado é fornecido em conjuntos


separados e não deve ser confundido com o caso em que as duas condições de um
mesmo conjunto devem ser satisfeitas simultaneamente.

> solve(x^2+x>2,{x});

{ x < -2 }, { 1 < x }

8
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Exercícios:
1. Determine todas as raízes das seguintes equações:

1
(a) sin( x ) + sin( 2 x ) − x + =0,
2

(b) x 3 − ex = 0 ,
5 4 3 2
(c) 3 x − 3 x − 7 x + 4 x − x + 3 =0.

2. Resolva a seguinte equação para x usando solve e fsolve.

48 x5 + 8 x4 − 6 x3 + 114 x2 − 37 x + 18

3. Resolva para x as seguintes equações.


(x + a )
(a) ( x + 1 ) = ( x + 1 )2

(b) 2 − sin( 1 − x ) = 2 x

2 2 2
4. Resolva o sistema { x + y = 5, x y = y − 2 } com solve e fsolve.

5. Resolva para x as seguintes inequações. Lembrando que <, >, <=, >= e <> (menor,
maior, menor-igual, maior-igual, diferente).

(a) x < x−3 3−x

x+1 x
(b) <
2−x 3+x

1 1
(c) ≤
5 x+1 x−3

(d) 3 x − 1 + x < 2

9
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

3. Simplificando expressões

O problema de simplificação de expressões é um problema clássico de


computação algébrica, e também é um dos mais difíceis. Embora heuristicamente seja
fácil ter uma noção sobre o que é a forma mais simples de uma expressão, quando se
trata de traduzir este procedimento em termos de algoritmos, formidáveis dificuldades de
programação aparecem. Em Maple há certos comandos destinados a simplificação de
expressões. Como veremos nas Seções seguintes, cabe ao usuário decidir qual comando
de simplificação utilizar em cada momento.

simplify

tentar simplificar a expressão matemática.

expand, factor e combine

são comandos mutuamente complementares. expand abre os parênteses executando as


propriedades distributivas. factor e combine tentam combinar os termos de modo a
agrupar as expressões.

normal

transforma funções racionais para suas formas normais.

O comando simplify tenta simplificar uma expressão matemática dada aplicando várias
regras de transformação. Por ser um comando geral de simplificação, a sua utilização é
sempre a primeira tentativa em tornar a expressão mais simples. Pode ser que não faça
exatamente a mudança desejada pelo usuário e neste caso outros comandos deverão ser
tentados.

> diff(x/(1-x^2),x$3);

x2 6 48 x4
48 3
+ 2
+ 4
( 1 − x2 ) ( 1 − x2 ) ( 1 − x2 )

> simplify(%);

6 x2 + x4 + 1
6 4
( −1 + x2 )

Expressões contendo trigonometria, potência e logaritmos também podem ser


simplificadas com suas respectivas propiedades de manipulação.

> sin(theta)^2+cos(theta)^2=simplify(sin(theta)^2+cos(theta)^2);

sin( θ )2 + cos( θ ) 2 = 1

O comando factor executa o processo inverso do expand tentando converter as várias


parcelas de uma soma em um conjunto de produtos

10
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> x*(x-2*b)^2*(x+a);

x ( x − 2 b )2 ( x + a )

> expand(%);

x 4 + x 3 a − 4 x 3 b − 4 x 2 b a + 4 b2 x 2 + 4 x b2 a

> factor(%);

x ( x − 2 b )2 ( x + a )

Neste comando a fatorização é feita tanto para o numerador como para o denominador
de funções racionais.

> factor((x^2+x-6)/(x^2-1));

(x + 3) (x − 2)
(x − 1) (x + 1)

Quando o factor não encontra raízes inteiras, o formato original é mantido. Entretanto,
adicionando um argumento pode ajudar o Maple na fatorização.

> factor(x^2+1);

x2 + 1

> factor(x^2+1,I);

(x − I) (x + I)

Consideremos agora a expressão

> ex1:=(x^2-2*x+1)^2+(y^2+2*y+1)^2;
2 2
ex1 := ( x2 − 2 x + 1 ) + ( y2 + 2 y + 1 )

Aplicando o comando factor obtemos

> factor(ex1);

x4 − 4 x3 + 6 x2 − 4 x + 2 + y4 + 4 y3 + 6 y2 + 4 y

O que não simplificou o problema. Notemos agora o seguinte:

> op(1,ex1);
2
( x2 − 2 x + 1 )

11
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> op(2,ex1);
2
( y2 + 2 y + 1 )

Ou seja, o comando op (operando) extrai os operandos da expressão. Portanto, podemos


fatorar ex1 eficientemente fazendo

> factor(op(1,ex1))+factor(op(2,ex1));

( x − 1 )4 + ( y + 1 )4

O comando normal é similar ao comando factor. A diferença é que normal, ao encontrar


uma razão entre duas expressões, limita-se a procurar fatores comuns entre numerador
e denominador. Por exemplo,

produzindo neste caso o mesmo resultado que factor. No entanto, a diferença reaparece
se no caso mais geral.

> g;

x30 − 1
x−1

> normal(g);

1 + x + x24 + x29 + x27 + x28 + x26 + x25 + x23 + x22 + x21 + x20 + x19 + x18 + x17 + x16 + x15
+ x14 + x13 + x12 + x11 + x10 + x9 + x8 + x7 + x6 + x5 + x4 + x3 + x2

Ou seja, normal procurou no numerador o fator comum ao denominador e expandiu o


fator restante. Em quais casos há vantagem de se usar normal em lugar de factor?

Consideremos o seguinte exemplo:

> h:=1/(1-x^20)+1/(1-x^10);

1 1
h := 20
+
1−x 1 − x10

> factor(h);

x10 + 2

( x − 1 ) ( x + 1 ) ( x4 + x3 + x2 + x + 1 ) ( x4 − x3 + x2 − x + 1 ) ( x2 + 1 ) ( x8 − x6 + x4 − x2 + 1 )

> normal(h);

x10 + 2

( −1 + x10 ) ( x10 + 1 )

12
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Como podemos ver, factor obteve o mínimo múltiplo comum entre os denominadores e
fatorizou cada expressão em termos de fatores irredutíveis. O comando normal fez o
mesmo, mas não tentou fatorizar os termos no denominador, gerando uma expressão
mais simples.

Quando uma expressão é gerada em Maple, por meio de uma entrada do usuário, ou por
meio de um cálculo, esta expressão é mantida na sua forma original, até que o usuário
determine o contrário. Ou seja, expressões algébricas são mantidas na forma em que
foram fornecidas. Por exemplo, uma expressão fatorada é mantida nesta forma até que
sua expansão seja ordenada:

> f1:=(x-a)^6;

f1 := ( x − a ) 6

> expand(f1);

x6 − 6 a x5 + 15 x4 a 2 − 20 x3 a 3 + 15 x2 a 4 − 6 x a 5 + a 6

> factor(%);

( a − x )6

O comando expand pode ser usado também para expandir funções trigonométricas,
logarítmicas exponenciais, especiais, etc.:

> f2:=cos(omega*t+delta);

f2 := cos( ω t + δ )

> expand(f2);

cos( ω t ) cos( δ ) − sin( ω t ) sin( δ )

Em determinados casos desejamos expandir somente parte de uma expressão. Vamos


supor que:

> f4:=(sin(alpha+beta)+x)^2;

f4 := ( sin( α + β ) + x ) 2

> expand(f4);

sin( α )2 cos( β )2 + 2 sin( α ) cos( β ) cos( α ) sin( β ) + 2 sin( α ) cos( β ) x + cos( α )2 sin( β )2
+ 2 cos( α ) sin( β ) x + x2

Caso não queiramos expandir a função sin, procedemos da seguinte forma:

> expand(f4,sin);

sin( α + β )2 + 2 sin( α + β ) x + x2

13
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Consideremos agora a atuação de expand sobre funções racionais:

> f6:=(x-y)^2/(x+y)^3;

( x − y )2
f6 :=
( x + y )3

> expand(f6);

x2 2xy y2
− +
( x + y )3 ( x + y )3 ( x + y )3

Ou seja, o denominador não foi expandido. Para fazer isso devemos proceder da seguinte
forma:

> normal(f6,expanded);

x2 − 2 x y + y2
x3 + 3 x2 y + 3 x y2 + y3

A operação realizada por expand é baseada num algoritmo simples. Por outro lado, a
operação inversa de fatorização

é um processo complexo baseado em um longo e complexo procedimento envolvendo


técnicas sofisticadas de álgebra. Portanto, embora seja fácil obter a expansão de
qualquer função, a fatorização requer maior cuidado e interação do usuário com o
sistema. Por exemplo:

> g1:=sin(alpha+beta)+cos(omega+delta);

g1 := sin( α + β ) + cos( ω + δ )

> expand(g1);

sin( α ) cos( β ) + cos( α ) sin( β ) + cos( ω ) cos( δ ) − sin( ω ) sin( δ )

> factor(%);

sin( α ) cos( β ) + cos( α ) sin( β ) + cos( ω ) cos( δ ) − sin( ω ) sin( δ )

Ou seja, factor não foi capaz fazer com que pudéssemos recuperar a expressão original.
Para isso é necessário especificar o tipo de fatorização que desejamos. O comando
combine é útil neste caso:

> combine(%,trig);

sin( α + β ) + cos( ω + δ )

Vejamos outros exemplos:

> g2:=(x+a)^n*(x+a)^s;

g2 := ( x + a )n ( x + a )s

14
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> combine(g2,power);
(n + s)
(x + a)

> g3:=exp(2*x)*exp(b);
(2 x)
g3 := e eb

> combine(g3,exp);
(2 x + b )
e

> g4:=exp(sin(alpha)*cos(beta))*exp(cos(alpha)*sin(beta));
( sin( α ) cos ( β ) ) ( cos ( α ) sin( β ) )
g4 := e e

> combine(g4,[trig,exp]);
sin( α + β )
e

Simplificações envolvendo ln necessitam o parâmetro adicional "simbolic". Por exemplo:

> g5:=3*ln(x)+2*ln(y);

g5 := 3 ln( x ) + 2 ln( y )

> combine(g5,ln,symbolic);

ln( x3 y2 )

Pode fazer simplificações especificando o tipo ao passar como parâmetreo um dos


argumentos: abs, conjugate, exp, ln, plus, power, product, Psi, range, trig e signum.

> 4*cos(x)^3=combine(4*cos(x)^3,trig);

4 cos( x )3 = cos( 3 x ) + 3 cos( x )

> 2*ln(3)-ln(2)=combine(2*ln(3)-ln(2),ln);

9
2 ln( 3 ) − ln( 2 ) = ln 
2

O uso dos comandos sort e collect se torna importante quando as expressões são
grandes ou quando possuem muitas variáveis. O comando sort reorganiza a expressão
ordenando os termos de acordo com a potência.

> f:=expand((a*x^2*y+b*y)^2+(x-2*y+c*y^2)^2+x^3+x^4*y^2);

f := a 2 x4 y2 + 2 a x2 y2 b + b2 y2 + x2 − 4 x y + 2 x c y2 + 4 y2 − 4 c y3 + c2 y4 + x3 + x4 y2

15
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> sort(f);

a 2 x4 y2 + 2 a x2 b y2 + x4 y2 + c2 y4 + 2 x c y2 + b2 y2 − 4 c y3 + x3 + x2 − 4 x y + 4 y2

Sem nenhum parâmetro adicional, este comando ordena os termos de acordo com a
soma das potências das variáveis de cada parcela. Normalmente a ordenação é feita em
relação a uma determinada variável, mas também é possível ordenar para duas.

> sort(f,x);

y2 a 2 x4 + y2 x4 + x3 + 2 y2 a b x2 + x2 − 4 y x + 2 y2 c x + y2 b2 + y4 c2 − 4 y3 c + 4 y2

O comando collect possui uma certa afinidade com o comando sort. Ele combina termos
que possuem uma variável em comum colocando-a em evidência.

> collect(f,x);

( a 2 y2 + y2 ) x4 + x3 + ( 1 + 2 a b y2 ) x2 + ( −4 y + 2 c y2 ) x + b2 y2 − 4 c y3 + c2 y4 + 4 y2

Pode-se especificar também duas variáveis para este comando. O critério de associação
fica sendo o de colocar em evidência em relação à primeira variável e para os termos
resultantes é que será colocada em evidência a segunda variável.

> collect(f,[x,y]);

( a 2 + 1 ) y2 x4 + x3 + ( 1 + 2 a b y2 ) x2 + ( 2 c y2 − 4 y ) x + c2 y4 − 4 c y3 + ( b2 + 4 ) y2

> collect(f,[y,x]);

c2 y4 − 4 c y3 + ( ( a 2 + 1 ) x4 + 2 a x2 b + 2 x c + b2 + 4 ) y2 − 4 x y + x2 + x3

16
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Exercícios:

6. Transforme

1
x2 + 2 x + 1 + 2
x +2x+1

em

( x + 1 )4 + 1
( x + 1 )2

e vice-versa.

2
7. Considere o polinômio ( x + x y + x + y ) ( x + y ) . Use o Maple para transformar em:

(a) x3 + 2 x2 y + x y2 + x2 + 2 x y + y2
3 2 2 2
(b) x + x + ( 2 x + 2 x ) y + ( x + 1 ) y

17
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

4. Álgebra linear
Os comandos de Álgebra Linear formam um pacote chamado linalg, que deve ser
carregado com o comando with:

> restart:

> with(linalg):

Normalmente, terminarmos o comando de carregar pacotes com dois pontos para que as
funções do pacote não sejam mostradas. Somente as mensagens de aviso de redefinição
de comandos serão mostradas. Isto é o que acontece com os comandos norm e trace,
que servem primeiramente para calcular norma de polinômios e para correção de
procedimentos, respectivamente. Após o pacote linalg ser carregado, eles passam a
calcular norma de vetores e traço de matrizes.

Definindo matrizes

Os comandos do pacote linalg para definir matrizes são: matrix, entermatrix, genmatrix,
randmatrix, band e diag. A título de exemplo, vamos definir duas matrizes e gravá-las
nas variáveis A e B:

> A := matrix( [ [1,2,3], [4,5,6] ] );

1 2 3
A :=  
4 5 6

> B := matrix(3, 2, [a,1,1,d,e,1] );

 a 1

B :=  1 d 
 
e 1 

Na primeira matriz, entramos os elementos fornecendo cada linha na forma de uma lista.
Neste caso, não é necessário especificar as dimensões da matriz. Na segunda, primeiro
estipulamos as dimensões da matriz como sendo 3x2, depois fornecemos todos os
elementos numa única lista. O próprio Maple separa as linhas de acordo com as
dimensões da matriz.

Podemos também fornecer os elementos da matriz interativamente. Primeiro, gravamos


uma matriz com dimensão especificada em uma determinada variável, e depois usamos
o comando entermatrix:

> C:=matrix(2,2);

C := array( 1 .. 2, 1 .. 2, [ ] )

> entermatrix(C);

enter element 1,1 > 1/2;

enter element 1,2 > 1/3;

enter element 2,1 > 1/5;

18
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

enter element 2,2 > 1/6;

 1 1 
 
 2 3 
 1 1 
 5 6 

Após a matriz ter sido definida, é possível trocar um elemento. Temos que atribuir o
novo valor ao elemento correspondente. Por exemplo, vamos trocar 1/6 por 1/7 na
posição <2,2> da matriz C:

> C[2,2] := 1/7;

1
C2, 2 :=
7

Vamos verificar que a mudança foi feita com sucesso. Para ver os elementos de uma
matriz temos que usar algum comando de avaliação, por exemplo evalm:

> evalm(C);

 1 1 
 
 2 3 
 1 1 
 5 7 

Quando uma matriz tem uma regra de formação, é possível repassar esta regra como
terceiro argumento do comando matrix. Os dois primeiros argumentos devem ser as
dimensões da matriz. Suponha que queiramos definir uma matriz de dimensão 3x4, onde
i
o elemento <i,j> é dado por :
j

> matrix(3, 4, (i,j) -> i/j);

 1 1 1 
1
 2 3 4 
 2 1 
 2 1 
 3 2 
 
 3 3 
3 1
 2 4 

Existem várias matrizes especiais que são usadas com freqüência em Álgebra Linear.
Muitas delas têm comandos específicos para gerá-las. Por exemplo, as matrizes
diagonais quadradas podem ser geradas através do comando diag. Neste caso, é bem
mais econômico entrar os elementos através deste comando do que com o comando
matrix, pois neste último, teríamos que fornecer os zeros fora da diagonal. Vejamos
alguns exemplos:

19
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> diag(1,2,3,4);

1 0 0 0
 
 0 2 0 0
 0 
0 3 0
0 0 0 4

> diag(a$3);

 a 0 0

 0 a 0 
 
0 0 a 

O comando a $ 3 gera uma seqüência de três elementos a , de forma que o último


comando dado acima é equivalente a diag(a,a,a). Podemos também criar matrizes
diagonais em bloco. Vamos usar a matriz C, definida acima com o comando entermatrix,
para criar a seguinte matriz:

> diag(C,C);

 1 1
 0 0 
 2 3 
 1 1 
 0 0 
 5 7 
 1 1 
 0 0
2 3 
 
 1 1 
 0 0 
 5 7 

Para criar matrizes com valores randômicos o comando randmatrix é usado. Como
parâmetro adicional pode ser usado: sparse, symmetric, unimodular e entries. No
exemplo abaixo limitamos o intervalo de escolha aleatória dos números de 0 a 10,
quando esta opção é omitida os valores podem estar entre -99 e 99.

> randmatrix(2,2,entries=rand(0..10));

 9 4

 1 4

Manipulação de matrizes:
Os principais comandos para manipulação estrutural com matrizes são: addcol, addrow,
augment, col, row, coldim, rowdim, concat, copyinto, delcols, delrows, extend, mulrow,
mulcol, stack, submatrix, swapcol e swaprow. A maioria dos nomes dos comandos falam
por si só. As terminações ou prefixos row e col se referem a linha e coluna,
respectivamente. O comando coldim, por exemplo, fornece o número de colunas da
matriz. O comando swaprow troca duas linha de uma matriz. Vejamos alguns exemplos.
Primeiro vamos criar duas matrizes genéricas A e B:

A manipulação aritmética de matrizes, além dos comandos de soma e ponteciação vistos,


abrange os comandos transpose, det, trace, rank e map entre outros.

20
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

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

1 2 3

A := 4 -5 6
 
9 8 7

O comando transpose calcula a transposta.

> transpose(A);

1 4 9

2 -5 8
 
3 6 7

O determinante é calculado pelo det.

> det(A);

200

A matriz inversa de A pode ser obtida da seguinte forma:

> B:=evalm(A^(-1));

 -83 1 27 

 200 20 200 
 13 -1 3 
B :=  
 100 10 100 
 
 77 1 -13 
 200 20 200 

21
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Exercício:

8. Considere as seguintes matrizes

1 0 3  -3 2

A = 2 -1 3, B =  0 1
   
4 1 8  7 4

Calcule:

( -1 )
(a) A

(b) A At

(c) Bt A B

22
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

5. Gráficos
Gráficos em duas dimensões:
Comecemos com alguns exemplos.

> g1:=ln(x);

g1 := ln( x )

> plot(g1,x=0..3);

Note que no exemplo acima, o comando plot foi capaz de lidar com a singularidade de
ln( x ) em x = 0 . Vejamos outros exemplos:

> g2:=(1-x)/(1+x);

1−x
g2 :=
1+x

> plot(g2,x=-2..0);

Neste caso, para fazer com que o gráfico seja legível, devemos limitar os valores da
ordenada próximo à singularidade:

23
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> plot(g2,x=-2..0,y=-20..20);

> plot(tan(x),x=-Pi..Pi,-10..10);

Podemos esboçar gráficos de várias funções simultaneamente. Por exemplo:

> g3:=exp(-x^2)*cos(8*x);
2
( −x )
g3 := e cos( 8 x )

> plot(g3,x=-Pi..Pi);

24
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Podemos traçar este mesmo gráfico com sua envoltória:

> plot({g3,exp(-x^2),-exp(-x^2)},x=-Pi..Pi);

Podemos escolher as cores de cada gráfico:

> plot({g3,exp(-x^2),-exp(-x^2)},x=-Pi..Pi,color=[black,blue,red]);

Consideremos agora a função:

> g4:=x+30*sin(x);

g4 := x + 30 sin( x )

> plot(g4,x=0..30);

25
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Vamos supor que queremos aumentar o intervalo:

> plot(g4,x=0..300);

No caso acima, o número de pontos de default (50), não foi suficiente. Devemos então
usar a opção numpoints

> plot(g4,x=0..300,numpoints=100);

Gráficos de funções parametrizadas:

Vamos supor que uma função é dada na forma paramétrica, como no caso da espiral:

> fx:=t*cos(t); fy:=t*sin(t);

fx := t cos( t )

fy := t sin( t )

26
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> plot([fx,fy,t=0..10]);

Gráficos em coordenadas polares:

Vejamos alguns exemplos:

> plot([sin(t)/t,t,t=-Pi..Pi],coords=polar);

> plot([sin(t)/t,t,t=-2*Pi..2*Pi],coords=polar);

27
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> plot([sin(t)/t,t,t=-3*Pi..3*Pi],coords=polar);

Se não especificarmos coords=polar o gráfico acima apareceria em forma simplesmente


paramétrica:

> plot([sin(t)/t,t,t=-4*Pi..10*Pi]);

Funções contínuas por partes:

As funções contínuas por partes são definidas através do comando piecewise. Definidas
desta forma estas funções podem ser diferenciadas ou integradas. Por exemplo:

> F:=piecewise(x<-1,-1,x<=1,1,-1);

 -1 x < -1
F :=  1 x≤1

 -1 otherwise

28
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> plot(F,x=-3..3);

> plot(F,x=-3..3,-2..2);

> G:=int(F,x);

 −2 − x x ≤ -1
G :=  x x≤1

 2−x 1<x

> plot(G,x=-2..2);

29
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Gráficos em 3D:

> with(plots):

> sphereplot(1, theta=0..Pi, phi=0..3*Pi/2, scaling=constrained);

> g1:=sphereplot(5,theta=0..Pi,phi=-Pi..Pi):

> g2:=cylinderplot(3,theta=0..2*Pi,z=-7..7):

> display({g1,g2},scaling=constrained,axes=boxed);

Para ver um dos gráficos isoladamente, basta avaliar a variável onde o gráfico foi
guardado. Por exemplo, para ver a esfera:

> g2;

30
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> f1:=x^3+y^3; f2:=10*x-y;

f1 := x3 + y3

f2 := 10 x − y

> plot3d({f1,f2},x=-2..2,y=-2..2,axes=boxed);

Gráficos simultâneos:

Podemos exibir gráficos simultaneamente em duas ou três dimensões:

> h1:=sin(x); h2:=cos(x);

h1 := sin( x )

h2 := cos( x )

> plot([h1,h2],x=-Pi..Pi,color=[blue,red]);

31
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Exercícios:
sin( 2 x )
9. Plote a função x → no intervalo [ 0 .. 4 π ] .
sin( x )
x

 sin( t ) d t . Plote o seno integral no
10. O seno integral Si é definido como Si( x ) = 
 t

⌡0
intervalo (0,10), calcule lim Si( x ) e compare este resultado com aquele obtido pela
x→ ∞
observação do gráfico.
x
11. Plote a função x → e + ln( 4 − x ) no intervalo (0,5). O que você acha deste gráfico?

12. Calcule o limite com x->infinity da função e faça o gráfico.


x
1
f :=  1 + 
 x

32
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

6. Cálculo Diferencial e Integral


Limites, Somatórios e Produtórios:

O comando que calcula o limite de uma função quando ela tende a algum valor é feito
pelo comando limit. Ele é capaz de realizar o cálculo de limites mesmo quando a direta

inserção do valor crítico na função é um resultado indefinido (por exemplo, ).

Quando o comando é executado com a primeira letra maiúscula (Limit), ele assume a
forma inerte e nenhum cálculo é feito. Esta forma é muito usada para visualizar a
expressão antes que o cálculo seja realmente feito com o auxílio do value.

> Limit((sqrt(1+x)-1)/x,x=0);

1+x −1
lim
x→ 0 x

> value(%);

1
2

> Limit(tan(Pi/4+x)^cot(2*x),x=0)=limit(tan(Pi/4+x)^cot(2*x),x=0);
cot ( 2 x )
1
lim tan π + x  =e
x→ 0 4 

> Limit(x!/x^x,x=infinity)=limit(x!/x^x,x=infinity);

x!
lim =0
x→ ∞ xx

O resultado é avaliado simbolicamente sempre que possível, mesmo quando a expressão


possui variáveis desconhecidas.

> f:=(x^a-x^(-a))/(x-1/x);
( −a )
xa − x
f :=
1
x−
x

> limit(f,x=1);

O limite também pode ser calculado com funções multivariáveis. Para isso a coordenada
em que se quer calcular o limite deve ser especificada da forma {x=x0,y=y0,...}.

33
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> limit( (x+y)/x + (x+y)/y , {x=0,y=1} );

1
Quando queremos calcular o limite da função quando x → 0 o Maple não encontra
x2
1
dificuldade de dizer que é ∞ , porém para a função veja o resultado:
x

> Limit(1/x^2,x=0)=limit(1/x^2,x=0);

1
lim =∞
x→ 0 x2

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

1
lim = undefined
x→ 0 x

O motivo deste resultado é que o Maple reconhece que o limite desta função para este
valor depende da direção de aproximação.

> Limit(1/x,x=0,left)=limit(1/x,x=0,left);

1
lim = −∞
x → 0- x

> Limit(1/x,x=0,right)=limit(1/x,x=0,right);

1
lim =∞
x → 0+ x

Para representar somatório usa-se o comando sum: o primeiro parâmetro representa a


função e o segundo contém o intervalo da variável do somatório. Assim como no limite
este comando também possui a sua forma inerte.

> Sum(1/x^n,n=1..5);
5
1
∑ xn
n=1

> value(%);

1 1 1 1 1
+ 2+ 3+ 4+ 5
x x x x x

Se a variável já possui um valor previamente associado então esta variável deve estar
entre aspas simples (') e o todo primeiro parâmetro também.

34
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> z:=10;

z := 10

> Sum(1/z^3,z=1..5)=sum(1/z^3,z=1..5);

Error, (in sum) summation variable previously assigned, second argument evaluates to
10 = 1 .. 5

> Sum('1/z^3','z'=1..5)=sum('1/z^3','z'=1..5);
5
1 256103
∑ =
z 3 216000
z=1

Quando se desejar fazer um somatório infinito basta especificar no intervalo.

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

1
∑ 2n
=1
n=1

Diferenciação:

Esta seção trata dos comandos relacionados ao cálculo de derivadas. O comando que
calcula a derivada é o diff. Funções definidas por equações também podem ser derivadas
pelo comando implicitdiff. O operador relacionado com a derivada é a letra d maiúscula
(D). Para o comando de derivada deve-se passar a função e a variável de derivação
como argumentos tanto para a forma normal como para a forma inerte.

> restart;

> Diff(x^3+x^2+x,x);

∂ 3 2
(x + x + x)
∂x

> value(%);

3 x2 + 2 x + 1

> Diff(x^3+x^2+x,x,x)=diff(x^3+x^2+x,x,x);

∂2 3 2
(x + x + x) = 6 x + 2
∂x 2

Para derivadas de ordem superiores a dois convém utilizar o operador dólar ($)
responsável pelas repetições.

35
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> Diff(x^3+x^2+x,x$3)=diff(x^3+x^2+x,x$3);

∂3 3 2
(x + x + x) = 6
∂x 3

Obviamente o Maple conhece todas as regras de derivação como regra da cadeia, regra
do produto e da divisão de derivadas.

> Diff(sin(cos(x)),x)=diff(sin(cos(x)),x);


sin( cos( x ) ) = −cos( cos( x ) ) sin( x )
∂x

Para funções não definidas, o operador D é usado no resultado.

> Diff(f(g(x)),x)=diff(f(g(x)),x);

∂ ∂
f( g( x ) ) = D( f )( g( x ) )  g( x ) 
∂x  ∂x 

É possível derivar em função de qualquer variável da epressão.

> Diff((x^2+y^3)^4,x,y)=diff((x^2+y^3)^4,x,y);

∂2 4 2
( x2 + y3 ) = 72 ( x2 + y3 ) x y2
∂y ∂x

Para derivadas de funções definidas implicitamente poderia ser feito o seguinte


procedimento:

> diff(x^2+y(x)^2=1,x);


2 x + 2 y( x )  y( x )  = 0
 ∂x 

> solve(%,diff(y(x),x));

x

y( x )

Porém o comando implicitdiff já resolve diretamente.

> implicitdiff(x^2+y^2=1,y,x);

x

y

Enquanto o diff é usado para funções, o D é usado para calcular a derivada de


operadores.

> D(sin);

cos

36
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> D(sin@cos);
(2)
−cos sin

Quando a função tem vários parâmetros devemos colocar entre colchetes o número
correspondente à variável sobre a qual se deseja derivar.

> f:=(x,y)->sin(x)+cos(y)+sin(x*y);

f := ( x, y ) → sin( x ) + cos( y ) + sin( x y )

> D[1](f);

( x, y ) → cos( x ) + cos( x y ) y

> D[2](f);

( x, y ) → −sin( y ) + cos( x y ) x

Podemos, ainda, passar novos valores a serem substituídos na expressão do resultado.

> D[2](f)(alpha,beta);

−sin( β ) + cos( α β ) α

Integração:

Do ponto de vista matemático, a integração simbólica é mais complexa do que a


derivação pois não há um método único que resolva todas as integrais. Existem regras
de integração capazes de reduzir expressões em formas de integrais conhecidas ou
tabeladas. O Maple possui um extenso acervo de solução algébrica de integrais, mas
certamente não resolve toda aquelas existentes na matemática. Quando encontrarmos
uma dessas é possível encontrar a sua solução numérica.

Para fazer uma integração simbólica o comando utilizado é o int sendo que, assim como
nos comandos vistos neste capítulo, quando a primeira letra é maiúscula, o comando
assume a sua forma inerte.

> Int(x^2+x^3,x);


x2 + x3 d x

> value(%);

1 3 1 4
x + x
3 4

> Int(x^2+x^3,x=a..b)=int(x^2+x^3,x=a..b);
b
⌠ 2 3 1 3 1 3 1 4 1 4
 x + x dx = 3 b − 3 a + 4 b − 4 a

⌡a

37
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Para fazer a integral numérica, dos limites devem estar definidos

> Int(x^2+x^3,x=2..3)=int(x^2+x^3,x=2..3);
3
⌠ 2 3 271
 x + x d x = 12

⌡2

O Maple não encontra dificuldade quando o integrando possui uma descontinuidade no


intervalo de integração.

> f:=cos(x)/sqrt(1-sin(x));

cos( x )
f :=
1 − sin( x )

> plot(f,x=0..2*Pi,discont=true,color=black);

> Int(f,x=0..2*Pi)=int(f,x=0..2*Pi);


 cos( x )
 dx = 0

 1 − sin( x )
⌡0

O Maple reconhece a função degrau (Heaviside) e a função delta de Dirac (Dirac) durante
o processo de integração

> Int(g(x)*Heaviside(x-2),x=0..5)=int(g(x)*Heaviside(x-2),x=0..5);
5 5
⌠ g( x ) Heaviside( x − 2 ) d x = ⌠ g( x ) d x

⌡0 
⌡2

> Diff(Heaviside(x),x)=diff(Heaviside(x),x);


Heaviside( x ) = Dirac( x )
∂x

38
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

>Int(sin(x)*Dirac(x-Pi/4),x=-infinity..infinity)=int(sin(x)*Dirac(x-Pi/4),x=-
infinity..infinity);

⌠ 1 1

 sin( x ) Dirac x − π  d x = 2

  4  2
⌡−∞

Para representar integrais múltiplas é necessário colocar um comando de integral dentro


de outro.

> Int(Int(x^2,x=0..2),x=0..3)=int(int(x^2,x=0..2),x=0..3);
3 2

 ⌠ x2 d x d x = 8
 
⌡0 ⌡0

Freqüentemente encontramos integrais que não possuem solução algébrica. Quando o


Maple não consegue encontrar uma solução algébrica é retornada a integral na forma
inerte. Para encontrar a solução numérica utiliza-se o comando evalf.

> int(sin(1/x^3),x=1..2);
2

 1
 sin 3  d x

 x 
⌡1  

> evalf(%);

.3548334332

Expansão em Séries:

O comando que faz a expansão em séries é series. Dependendo da expressão do


primeiro parâmetro, este comando pode gerar expansão em Taylor, Laurent ou séries de
potência genérica. O segundo parâmetro é o ponto de expansão e o terceiro, a máxima
potência da série. Este último é opcional e ser for omitido, o Maple usa o valor da
variável global Order que é inicializado com 6.

> series(log(x),x=1);

1 1 1 1
x − 1 − ( x − 1 )2 + ( x − 1 )3 − ( x − 1 )4 + ( x − 1 )5 + O( ( x − 1 )6 )
2 3 4 5

> series(sin(x),x=0,10);

1 1 5 1 7 1
x − x3 + x − x + x9 + O( x10 )
6 120 5040 362880

39
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

6
O tipo de saída obtido é series que caracterizado por um truncamento ( O ( x − 1 ) ). Por
este motivo, os resultados obtidos pelo comando series não podem ser processados em
seguida. Para converter a expansão para um polinômio usa-se o comando convert.

> whattype(%);

series

> pol:=convert(%%,polynom);

1 1 5 1 7 1
pol := x − x3 + x − x + x9
6 120 5040 362880

O gráfico seguinte mostra a função sin( x ) e a sua expansão em séries até potência 9.

> plot([pol,sin(x)],x=0..2*Pi,-1..1,color=black);

O Pacote student, ferramentas de cálculo:

O pacote student possui ferramentas úteis para o aluno iniciante de cálculo pois
demonstram conceitos elementares e fundamentais para o seu aprendizado. Ele deve ser
carregado com o comando with, que seguido de ponto-e-vírgula imprime todos os seus
comandos.

> with(student);

[ D, Diff, Doubleint, Int, Limit , Lineint, Product, Sum, Tripleint , changevar,


completesquare, distance, equate, integrand , intercept, intparts , leftbox, leftsum,
makeproc, middlebox, middlesum , midpoint , powsubs, rightbox, rightsum,
showtangent, simpson, slope, summand, trapezoid ]

O exemplo abaixo soluciona uma integral pelo método de substituição de variável que o
Maple não consegue resolver sem esta manipulação. Porém outras integrais podem ser
resolvidas com este comando para mostrar o procedimento do método.

40
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> p1 := Int(sin(x)^5 * cos(x), x);

p1 := ⌠

sin( x )5 cos( x ) d x

> p2 := changevar(u=sin(x), p1, u);

p2 := ⌠

u5 du

> p3 := value(p2);

1 6
p3 := u
6

> p4 := subs(u=sin(x), p3);

1
p4 := sin( x )6
6

> p1 = p4 + C;

⌠ 5 1 6
sin( x ) cos( x ) d x = 6 sin( x ) + C

Foi visto anteriormente que uma integral dupla pode ser definida pela inserção em
cascata do comando int. No pacote student existem os comandos Doubleint e Tripleint
para representar integrais duplas e triplas respectivamente.

> inter:=-infinity..infinity;

inter := −∞ .. ∞

> Doubleint(exp(-x^2-y^2),x=inter,y=inter);
∞ ∞
⌠ ⌠ ( −x2 − y2 )

 
 e dx dy

⌡ 

−∞ −∞

> value(%);

Para mostrar como uma aproximação numérica de integrais opera podemos utilizar os
comandos leftbox, middlebox ou rightbox. Com eles pode-se visualizar os retângulos
representando as áreas que serão somadas na aproximação.

41
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> leftbox(sqrt(x),x=1..3,8);

Cálculo Vetorial:

As operações gradiente, divergente, rotacional e laplaciano estão programadas no Maple


como as funções grad, diverge, curl e laplacian. Estes comandos devem ter no mínimo
dois argumentos, onde o primeiro é uma função, ou melhor, uma expressão que
depende de certas variáveis, e o segundo uma lista de variáveis que representam as
coordenadas. O sistema de coordenadas default é o sistema cartesiano. Vamos dar um
apelido para a expressão f(x,y,z), e calcular o gradiente, divergente o laplaciano desta
função:

> restart;with(linalg):

Warning, the protected names norm and trace have been redefined and unprotected

> alias(f=f(x,y,z));

> v:=[x,y,z]; # lista das coordenadas

v := [ x, y, z ]

> grad(f,v);

 ∂ f , ∂ f, ∂ f 
 
 ∂x ∂y ∂z 

> diverge(%,v);

 ∂ 2   ∂ 2   ∂ 2 
 ∂x2 f  +  ∂y2 f  +  ∂z 2 f 
     

42
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> laplacian(f,v);

 ∂2   ∂2   ∂2 
 f +  f +  f
 ∂x2   ∂y2   ∂z 2 

O rotacional deve ser aplicado a uma função vetorial. Assim, vamos dar apelidos para
g(x,y,z) e h(x,y,z):

> alias(g=g(x,y,z),h=h(x,y,z));

f, g, h

> curl([f,g,h],v);

  ∂ h  −  ∂ g ,  ∂ f  −  ∂ h ,  ∂ g  −  ∂ f  
            
  ∂y   ∂z   ∂z   ∂x   ∂x   ∂y  

Podemos confirmar que o divergente do rotacional é zero:

> diverge(%,v);

e, da mesma forma, confirmar que o rotacional do gradiente é o vetor nulo:

> curl(grad(f,v), v);

[ 0, 0, 0 ]

Todas estas operações podem ser feitas em sistemas de coordenadas não-cartesianas.


Vamos ver um exemplo de cálculo de gradiente no sistema de coordenadas esféricas:

> f1 := r^2*sin(theta)*cos(phi);

f1 := r 2 sin( θ ) cos( φ )

> v:= [r, theta, phi];

v := [ r, θ, φ ]

> grad(f1, v, coords=spherical);

[ 2 r sin( θ ) cos( φ ), r cos( θ ) cos( φ ), −r sin( φ ) ]

Além de coordenadas cartesianas, esféricas e cilíndricas que são as mais utilizadas, o


Maple conhece mais de 40 sistemas de coordenadas em 2 e 3 dimensões. Para ter
acesso a lista completa destes sistemas, pode ser visto pela ajuda da forma ?coords.

43
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Exercícios
x2 + 2 x + 1
13. Calcular a derivada da função f( x ) = .Calcule a derivada de f(x) no
x2 + 3 x
ponto 3.

14. Seja a função y( x ) definida implicitamente por x + y = 1 . Calcule a derivada y' e


a segunda derivada y''.

15. Calcule as seguintes integrais definidas:


1

 1
(a) 
 dx
 1 − x2
⌡0


⌠ e ( −x ) ln( x ) d x
(c) 

⌡0



 (− t )
 e
(d) 
 1 dt

  

 t 4
1 − e
(− t)
⌡ 0



 ln( x )
16. Calcule  d x , para ‘a’ positivo.

 (x + a) (x − 1)
⌡0


 ln( x2 + 1 )
17. Calcule 
 x2 + 1 d x .



2 y
⌠⌠
18. Calcular   x y2 d x d y
 
⌡1 ⌡1 − y

19. Calcule os seguintes limites:

sin( x )
(a) lim
x→ 0 x

44
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

1
 
x
(b) lim sin( x )
x→ 0

1 − cos( x )
(c) lim
x→ 0 x

20. Calcule os seguintes limites:

ln( x )
(a) lim
x→ ∞ x

ln( x )
(b) lim
x→ ∞ ex

x2 + sin( x )
(c) lim
x→ ∞ 2 x2 + cos( 4 x )

45
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

7. Programação

A linguagem de programação do Maple e a linguagem que o usuário emprega quando


está fazendo um cálculo para resolver um certo problema, são as mesmas. Os comandos
para resolver um problema específico poderão ser usados no momento da elaboração de
um programa. E vice-versa, qualquer comando de programação pode ser usado no modo
interativo. Existem alguns comandos que são freqüentemente utilizados em programas e
que raramente são utilizados de modo interativo. Por exemplo, o comando for do od para
gerar iterações, em geral, só é empregado em programação.

Veremos primeiro as operações básicas para trabalharmos com listas ou vetores e


conjuntos:

> lista1:=[a,b,c];

lista1 := [ a, b, c ]

> conjunto1:={1,2,3};

conjunto1 := { 1, 2, 3 }

> op(2,lista1);

> op(2,conjunto1);

A diferença entre listas e conjuntos está no fato de que as listas preservam o


ordenamento e a repetição de elementos enquanto que os conjuntos ordenam os
elementos segundo o endereçamento de memória interno dos elementos, que pode
variar de um computador para outro, e além disso, os conjuntos eliminam as repetições.
Por exemplo:

> { 5, 5, 5, 4, 3, 2, 3, 2, 1};

{ 1 , 2 , 3 , 4, 5 }

Os conjuntos seguem as regras usuais de conjuntos definidos na Matemática. Podemos


fazer a união, intersecção e subtração através dos comandos union, intersect e minus.
Esses comandos são operadores que devem ser colocados entre os operandos, como é o
caso da multiplicação. Por exemplo:

> S1 := {1/2,3/2,5/2};

1 3 5
S1 := { , , }
2 2 2

> S2 := {1,2,3};

S2 := { 1, 2, 3 }

46
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> S1 union S2;

1 3 5
{ 1, 2, 3, , , }
2 2 2

> % minus {3,5/2};

1 3
{ 1, 2, , }
2 2

> % intersect S1;

1 3
{ , }
2 2

Iterações:

Existem duas formas de executar iterações através do comando for:

for contador from valor_inicial by intervalo to valor_final while expressão_booleana

do comando_1;

comando_2;

comando_3;

...

od;

for variável in expressão while expressão_booleana

do comando_1;

comando_2;

comando_3;

...

od;

Vejamos um exemplo da primeira forma. Os números pares podem ser gerados da


seguinte forma.

> for i to 5 do 2*i; od;

47
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

10

Na ausência do comando from, o valor inicial do contador é 1. Uma forma quase


equivalente do mesmo comando é

> for i from 2 by 2 to 10 do i; od;

10

Segue um exemplo da segunda forma de executar iterações. Seja L uma lista de


funções.

> L:=[exp(x^2),x^3,ln(x),cos(x)];
2
(x )
L := [ e , x3, ln( x ), cos( x ) ]

Queremos calcular uma aproximação para integral definida de 1 a 2 dessas funções.

> for i in L do Int(i,x=1..4)=evalf(int(i,x=1..4)); od;


4
⌠ ( x2 )

 e d x = .1149399172 10 7

⌡ 1

4
⌠ 3
 x d x = 63.75000000

⌡1

4

 ln( x ) d x = 2.545177445
⌡1

4
⌠ cos( x ) d x = -1.598273480

⌡1

Note que o contador i no comando acima recebe funções como valor. Vejamos o valor

48
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

final de i .

> i;

cos( x )

Considere o seguinte problema. Suponha que temos uma lista de funções na variável x.

> L := [ x^2, g(x), sin(x), a*exp(x^2)];


2
(x )
L := [ x2, g( x ), sin( x ), a e ]

Queremos construir a lista das derivadas. O próximo comando não resolve o problema.

> for i in L do diff(i,x); od;

2x


g( x )
∂x

cos( x )

2
(x )
2axe

O valor que o contador assume no final da iteração pode ser importante, como é o caso
no seguinte problema. Qual é o maior número primo menor que 808?

> for i from 808 by -1 while not isprime(i) do od;

O valor do contador contém a informação que desejamos:

> i;

797

Exceto o do od, todos as outras partes são opcionais. Vejamos um exemplo do comando
while. Suponha que N tem o valor 68.

> N := 68;

N := 68

Queremos dividir N por 2 enquanto N for par.

> while type(N,even) do N := N/2 od;

N := 34

N := 17

49
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Existem dois nomes especiais para serem usados dentro de iterações que são break e
next. A variável break faz com que a iteração seja imediatamente interrompida. Por
exemplo, no comando seguinte conseguimos interromper a iteração sem que o contador
tenha um valor final.

> i:=0;

i := 0

> do

> i:=i+1;

> if i=10 then break fi;

> od;

Existem três formas particulares do comando for que são seq, add e mul. As sintaxes
desses comandos são iguais, de forma que vamos apenas descrever o comando add que
executa um somatório. A sua sintaxe é uma das seguintes formas

add( f, i = a .. b )

add( f, i = L )

onde f é uma expressão que geralmente depende do índice i . Na primeira forma, o


índice i assume valores inteiros de a até b , onde a e b tem que ser numéricos. Na
segunda forma o índice assume valores da expressão ou estrutura de dados L . Por
exemplo:

> add( a[i]*x^i, i=0..5 );

a0 + a1 x + a2 x2 + a3 x3 + a4 x4 + a5 x5

> add(exp^i,i=0..10);

1 + exp + exp2 + exp3 + exp4 + exp5 + exp6 + exp7 + exp8 + exp9 + exp10

Seqüências:

As seqüências são encadeamentos de objetos separados por vírgula. O comando que


gera seqüências é o seq, cuja sintaxe é seq(termo(i), i=a..b ), onde a e b são
números.

> seq( a^i, i=1..5 );

a, a 2, a 3, a 4, a 5

> seq( 11-i, i=1..10 );

10, 9, 8, 7, 6, 5, 4, 3, 2, 1

50
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> seq( sin((2*i-1)*x/Pi), i=1..3 );

x x x
sin , sin 3 , sin 5 
π  π  π

Exemplo:

Construir uma lista [tan(x), tan(tan(x)), tan(tan(tan(x))), ...].

> restart:

> L:=[tan(x)];

L := [ tan( x ) ]

> L:=[L[1],tan(L[1])];

L := [ tan( x ), tan( tan( x ) ) ]

> L:=[L[1],L[2],tan(L[2])];

L := [ tan( x ), tan( tan( x ) ), tan( tan( tan( x ) ) ) ]

> nops(L);

Agora que já temos uma idéia de como devemos fazer a iteração, podemos então fazer
um loop.

> restart:

> L:=[tan(x)];

L := [ tan( x ) ]

> for i to 10 do

> L:=[op(L),tan(L[nops(L)])]:

> od:

> print(L);

[ tan( x ), tan( tan( x ) ), tan( tan( tan( x ) ) ), tan( tan( tan( tan( x ) ) ) ), tan( tan( tan( tan( tan( x ) ) ) ) ),
tan( tan( tan( tan( tan( tan( x ) ) ) ) ) ), tan( tan( tan( tan( tan( tan( tan( x ) ) ) ) ) ) ),
tan( tan( tan( tan( tan( tan( tan( tan( x ) ) ) ) ) ) ) ),
tan( tan( tan( tan( tan( tan( tan( tan( tan( x ) ) ) ) ) ) ) ) ),
tan( tan( tan( tan( tan( tan( tan( tan( tan( tan( x ) ) ) ) ) ) ) ) ) ),
tan( tan( tan( tan( tan( tan( tan( tan( tan( tan( tan( x ) ) ) ) ) ) ) ) ) ) ) ]

51
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

ANEXO A

Antes de começar a usar o Maple leia esse anexo para facilitar o entendimento do
programa.

1 - Para criar uma nova linha de comando:

Existe várias maneiras de se criar isso, com atalho Ctrl- J, no botão [ > ou Insert /
Execution Group > After Cursor

2 - Criar uma nova região de texto:

De forma análoga: Ctrl-T, no botão T ou Insert / Text

3 - Ponto e Vírgula e Dois Pontos:

Todo fim de comando deve ser finalizado com ; ou com : (para que fique oculto).

4 - Remover todos os cálculos da Worksheet:

Usando o menu: Edit / Remove Output > From Worksheet

5 - Expandindo ou "Escondendo" todas seções:

Usando o menu: View / Expand All Sections (ou Collapse All Sections).

6 - Usando a ajuda:

O Maple possui um sistema de ajuda muito bem organizada e com exemplos para cada
comando. Para verificar a ajuda do Maple, HELP>Topic Search ou HELP>Full Text
Search, para busca de algum comando ou assunto. Assim você encontrará muitos exemplos
de notações e comandos do maple.

Exemplo de cores utilizadas pelo Maple:

Aquamarine black blue navy coral cyan brown gold green gray grey khaki

Magenta maroon orange pink plum red sienna tan turquoise violet wheat white

Yellow

Assim, podem ser implementadas em gráficos, textos e etc

52
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

ANEXO B

Aqui estão alguns exemplos de exercícios, que estão resolvidos para serem consultados e
alguns tópicos de matéria em que não foram apresentadas no curso por ser um curso
rápido.

Resolução de sistemas lineares:

Vamos resolver o sistema A X = B . Usaremos o pacote de álgebra linear e os


parâmetros estudados no tópico 4.

Resolva o sistema:

2x+4y−2z=8

x+2y+z=6

3x+y−3z=2

> restart:

Resolvendo:

> with(linalg):

Warning, the protected names norm and trace have been redefined and unprotected

> A:=matrix([[2,4,-2],[1,2,1],[3,1,-3]]); # Definindo matriz

2 4 -2

A := 1 2 1
 
3 1 -3

> B:=matrix(3,1,[8,6,2]); # Definindo matriz

 8
B :=  6
 
 2

> AB:=augment(A,B); # Fazendo a matriz aumentada

2 4 -2 8

AB := 1 2 1 6
 
3 1 -3 2

53
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> C:=mulrow(AB,1,1/AB[1,1]); # Dividindo a linha 1 pelo elemento AB[1,1]

1 2 -1 4

C := 1 2 1 6
 
3 1 -3 2

> C:=addrow(C,1,2,-C[2,1]); # Equivalente a: L2 = -L1 + L2

1 2 -1 4

C := 0 0 2 2
 
3 1 -3 2

> C:=addrow(C,1,3,-C[3,1]); # Equivalente a: L3 = -3*L1 + L3

1 2 -1 4

C := 0 0 2 2
 
0 -5 0 -10

> C:=swaprow(C,2,3); # Aqui foi feita a troca da linha 2 pela 3.

1 2 -1 4

C := 0 -5 0 -10

 
0 0 2 2

> C:=mulrow(C,3,1/2); # Equivalente a: L3 = (1/2) * L3

1 2 -1 4

C := 0 -5 0 -10
 
0 0 1 1

> C:=mulrow(C,2,-1/5); # Equivalente a: L2 = (-1/2) * L2

1 2 -1 4

C := 0 1 0 2
 
0 0 1 1

> C:=addrow(C,3,1); # Equivalente a: L1 = L3 + L1

1 2 0 5

C := 0 1 0 2
 
0 0 1 1

> C:=addrow(C,2,1,-C[1,2]); # Equivalente a: L1 = -2*L2 + L1

1 0 0 1

C := 0 1 0 2
 
0 0 1 1

54
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Portanto, temos como resposta:

> x3:=evalf(C[3,4]/C[3,3]);

x3 := 1.

> x2:=evalf(C[2,4]-C[2,3]*x3);

x2 := 2.

> x1:=evalf(C[1,4]-C[1,3]*x3-C[1,2]*x2);

x1 := 1.

Podemos calcular diretamente através do Maple e assim conferir:

> AA:=augment(A,B);

2 4 -2 8

AA := 1 2 1 6
 
3 1 -3 2

> BB:=gausselim(AA);

2 4 -2 8

BB := 0 -5 0 -10
 
0 0 2 2

> Resp2:=backsub(BB);

Resp2 := [ 1, 2, 1 ]

Logo verificamos que está correto o cálculo.

55
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Soma de Riemann:

Nessa lição, nós iremos ver exemplos da Soma de Riemann e mostrar a relação com a
integral definida.

> restart: with(student): with(plots):

Warning, the name changecoords has been redefined

Seja f(x) = x2 + 3 . Vamos então defini-la como uma função:

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

f := x → x2 + 3

Fazendo o gráfico, temos:

> plot(f(x), x = 0..4, color = blue);

Agora vamos analisar o gráfico da função com um preenchimento de vários retângulos


inscritos.

> leftbox(f(x), x = 0..4, 16, color = blue, shading = magenta);

56
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Pelo somatório das áreas dos retângulos, teremos uma aproximação da área dessa
função no intervalo x=(0,4)

> leftsum(f(x), x = 0..4, 16);


15
1   1 i 2 + 3  
 ∑ 
4  i = 0  16
 
 

> evalf(%);

31.37500000

Assim obtivemos a chamada Soma de Riemann, que nos deu uma aproximação razoável
da área. Agora iremos efetuar o cálculo com uma subdivisão de 128 retângulos, ou seja,
teremos uma boa aproximação:

> leftbox(f(x), x = 0..4, 128, color = blue, shading = magenta);

> leftsum(f(x), x = 0..4, 128);


127
1   1 i 2 + 3  
 ∑
32  i = 0  1024
 
 

> evalf(%);

33.08398438

Agora vamos analisar o resultado com o valor exato calculado pela integral.

> Int(f(x),x)=int(f(x),x);

⌠ 2 1 3
x + 3 d x = 3 x + 3 x

57
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> int(f(x),x= 0..4);

100
3

> evalf(%);

33.33333333

Vemos então que a partir do momento que aumentamos o número de subdivisões,


diminuímos o erro com uma precisão tal qual possamos desejar.

58
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Cálculo de área entre duas curvas:

Sejam as seguintes funções:


2
f(x) = 2x + 5 e g(x) = x +2

Encontrar a área da região de interseção entre as duas curvas em x = 0 até x = 6

> restart:

> with(plots):

Warning, the name changecoords has been redefined

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

> f:= x -> 2*x + 5;

g := x → x2 + 2

f := x → 2 x + 5

> a:= plot(g(x), x = -2..6, color = red):

> b:= plot(f(x), x = -2..6, color = blue):

> display({a,b});

Nós precisamos encontrar os pontos de interseção dos dois gráficos:

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

3, -1

Logo, a área da região delimitada pelos gráficos variando de x = 0 até x = 6 é:


3 6
⌠ 2 ⌠ x2 + 2 − 2 x − 5 d x . Área da curva superior menos a inferior
 2 x + 5 − x − 2 dx + 
 
⌡0 ⌡3

59
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

variando no intervalo de x.

> int(2*x + 5 - x^2 - 2, x = 0..3);

> int(x^2 + 2 - 2*x - 5, x = 3..6);

27

Portanto a área é 9 + 27 = 36 U.A (Unidade Área)

60
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Integral por partes:

(a) - ⌠
5
sin( x ) cos( x ) d x

> with(student):

> p1 := Int(sin(x)^5 * cos(x), x);

p1 := ⌠

sin( x )5 cos( x ) d x

> p2 := changevar(u=sin(x), p1, u); # fazendo mudança de variável

p2 := ⌠

u5 du

> p3 := value(p2);

1 6
p3 := u
6

> p4 := subs(u=sin(x), p3); # Substituindo novamente na equação

1
p4 := sin( x ) 6
6

> p1 = p4 + C;

⌠ 5 1 6
sin( x ) cos( x ) d x = 6 sin( x ) + C

(b) ⌠
4 2
tan( x ) sec( x ) d x

> p1 := Int( tan(x)^4 * sec(x)^2 , x);

p1 := ⌠

tan( x )4 sec( x ) 2 d x

> p2 := changevar( u=tan(x), p1, u);

p2 := ⌠

u4 du

61
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> p3 := value(p2);

1 5
p3 := u
5

> p4 := subs( u=tan(x), p3);

1
p4 := tan( x ) 5
5

> p1 = p4 + C;

⌠tan( x ) 4 sec( x )2 d x = 1 tan( x ) 5 + C



 5

62
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Exemplos de gráficos em coordenadas polares:

> with(plots):

Warning, the name changecoords has been redefined

> polarplot( cos(.95*theta), theta = 0..40*Pi);

> polarplot( 4 + 3*sin(7*theta), theta = 0..2*Pi, scaling = constrained);

> polarplot( 10 + sin(2*Pi*theta), theta = 0..20*Pi, color = coral,

scaling = constrained);

63
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Resolução de EDO com plotagem de gráfico:

 ∂2  ∂
Exemplo 1:  y( x )  + 3  y( x )  + 2 y( x ) = e x
  ∂x
2 
 ∂
 x 

> restart:

> with(plots,odeplot);

[ odeplot ]

> eq:=diff(y(x),x$2)+3*diff(y(x),x)+2*y(x)=exp(x);

 ∂ 2  ∂
eq :=  2 y( x )  + 3  y( x )  + 2 y( x ) = e x
 ∂x   ∂x 

> inits:=y(1)=2, D(y)(1)=4;

> p:=dsolve({eq,inits},y(x),type=numeric);

inits := y( 1 ) = 2, D( y )( 1 ) = 4

p := proc (rkf45_x) ... end proc

> odeplot(p,[x,y(x)],-2..10);

p(0);

 x = 0, y( x ) = -19.4207642746757437, ∂ y( x ) = 57.3932551267091427 
 
 ∂x 

64
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Exemplo 2:

> restart:

> Order:=8;

Order := 8

> eq := diff(y(x),x,x)+x*diff(y(x),x)+(2*x^2-1)*y=0;

 ∂2  ∂
eq :=  2 y( x )  + x  y( x )  + ( 2 x2 − 1 ) y = 0
 ∂x  ∂
 x 

> serie := dsolve( {eq}, y(x), type=series);

1 5 1 1
serie := y( x ) = y( 0 ) + D( y )( 0 ) x + y( 0 ) x2 − y( 0 ) x4 − D( y )( 0 ) x5 − y( 0 ) x6 +
2 24 10 80
1
D( y )( 0 ) x7 + O( x8 )
105

> D(y)(0):=a[1];

D( y )( 0 ) := a1

> serie;

1 5 1 1 1
y( x ) = y( 0 ) + a1 x + y( 0 ) x2 − y( 0 ) x4 − a1 x5 − y( 0 ) x6 + a x7 + O( x8 )
2 24 10 80 105 1

> y(0):=a[0];

y( 0 ) := a0

> eq:=serie;

1 5 1 1 1
eq := y( x ) = a0 + a1 x + a0 x2 − a0 x4 − a1 x5 − a0 x6 + a1 x7 + O( x8 )
2 24 10 80 105

> eq:=convert(eq,polynom);

1 5 1 1 1
eq := y( x ) = a0 + a1 x + a0 x2 − a0 x4 − a1 x5 − a0 x6 + a x7
2 24 10 80 105 1

> eq:=collect(eq,a[1]);

1 1 7 1 1 5
eq := y( x ) =  − x5 + x + x  a1 + a0 − a0 x6 + a0 x2 − a0 x4
 10 105  80 2 24

65
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> eq:=collect(eq,a[0]);

1 1 5 1 1 7
eq := y( x ) =  1 − x6 + x2 − x4  a0 +  − x5 + x + x a
 80 2 24   10 105  1

Exemplo 3: Circuito LC

A equação diferencial final para esse circuito é dada por:

 ∂ 2  1 q
 ∂t 2 q  + LC = 0
 
Condições iniciais:

L=1H

C=1F

q(0) = 1 µ C

q'(0) = 0 A

Resolução Algébrica

> restart:

> Ed:=(Diff(q(t),`$`(t,2))+1*q(t)/(L*C) =0);

 ∂2  q( t )
Ed :=  2 q( t )  + =0
 ∂t  L C

> Q:=dsolve({Ed,q(0)=10^(-6),D(q)(0)=0});

1  LC t
Q := q( t ) = cos 
1000000  LC 

> L:=1;C:=1;

L := 1

C := 1

> Q;

1
q( t ) = cos( t )
1000000

q(t) é dado em Coulomb.

66
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

> plot( 1/1000000*cos(t),t=0..2*Pi);

67
Grupo PET Engenharia Elétrica Curso Básico de Maple 6

Referências

Maplesoft - www.maplesoft.com

Fernando Deeke Sasse - www.geocities.com/fsasse

Departamento de Matemática

Universidade Estadual de Santa Catarina (UDESC)

Prof. Renato Portugal - Portugal@Lncc.br

Laboratório Nacional de Computação Científica

Rui Marcos de O. Barros

Departamento de Matemática

Universidade Estadual de Maringá (UEM)

University of Wisconsin-Milwaukee Department of Mathematics

www.uwm.edu - kmbrucks@uwm.edu

É desonroso para os homens sábios desperdiçarem seu tempo como escravos no trabalho
de cálculo, que poderia ser relegado, com segurança, a qualquer um que usasse uma
máquina.

(Gottfried Wilhelm Leibnitz , 1646-1716)

Grupo Pet Engenharia Elétrica - Udesc/Joinville-SC

Agosto 2002

Gostaríamos de agradecer ao pessoal do DEE (Departamento de Engenharia Elétrica) e


ao professor Fernando Deeke Sasse do DMAT (Departamento de Matemática) que nos
incentivou a realização deste curso.

** Apostila elaborada por Cristófaro Pompermaier - udesc@uol.com.br **

68

Você também pode gostar