Maple Básico

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
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
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
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
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
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
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
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 := 3.530173727
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
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
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
> 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
> 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
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
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
> 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
> 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
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
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;
18
 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
> 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
> 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
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
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
> 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
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
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
> 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
> 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
> 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
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
> 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
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
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â-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
> 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
> 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
> 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
> 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
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);
2π
⌠
 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
>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
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
> 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
> 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
> 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
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
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
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
> 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
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
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
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=0..5 );
a0 + a1 x + a2 x2 + a3 x3 + a4 x4 + a5 x5
> add(expî,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=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
> 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
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
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
> 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
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
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
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
> 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
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):
> 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
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
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
> 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
Exemplos de gráficos em coordenadas polares:
> with(plots):
> 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
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
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
> 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
> plot( 1/1000000*cos(t),t=0..2*Pi);
67
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

Maple Básico

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Maple Básico

Hochgeladen von

Copyright:

Verfügbare Formate

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

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

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

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

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

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

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

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

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

Podemos resolver esta equação para x :

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

Poderíamos ter escrito desde o início,

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

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

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

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

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

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

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

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

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

(a) x < x−3 3−x

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

tentar simplificar a expressão matemática.

expand, factor e combine

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

transforma funções racionais para suas formas normais.

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

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

Consideremos agora a expressão

Aplicando o comando factor obtemos

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

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

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

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

Consideremos o seguinte exemplo:

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

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

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

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

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

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

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

Vejamos outros exemplos:

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

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

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

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

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

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

enter element 1,1 > 1/2;

enter element 1,2 > 1/3;

enter element 2,1 > 1/5;

enter element 2,2 > 1/6;

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

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

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

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

O comando transpose calcula a transposta.

O determinante é calculado pelo det.

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

8. Considere as seguintes matrizes

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

> fx:=tcos(t); fy:=tsin(t);