x - Fernando Deeke Sasse

Aplicações de Maple em Cálculo e Álgebra Linear
Fernando Deeke Sasse
[email protected]
Departamento de Matemática, UDESC - Joinville
1 Introdução
O Maple foi criado nos anos 80 pelos matemáticos Keith Geddes e Gaston Gonnet, na Universidade
Waterloo e é considerado uma plataforma de computação algébrica genérica com sólida base
matemática. Computação algébrica é o mesmo que computação simbólica, ou seja, computação
envolvendo a manipulação de símbolos. A computação numérica também pode ser realizada pelo
Maple, embora de forma mais lenta do que programas tradicionais, como Fortran e C. A integração
numérica/simbólica e a excelência da sua linguagem de programação, fazem com que o Maple sirva
muito bem como uma ferramenta de criação de protótipos de programas. Há vários anos o Maple
vem sendo desenvolvido em várias partes do mundo, graças ao fato dele ser construído sobre sua
própria linguagem, não compilada. Somente um pequeno núcleo básico é compilado, por razões de
velocidade.
2 Gráficos
Esta seção foi baseada em parte nas worksheets de Peter Stone, School of Life and Physical
Sciences, RMIT.
2.1 plot,implicitplot,with(plots),display,seq
O comando do Maple plot pode ser utilizado para traçar gráficos. Sua versatilidade reside no
fato de que ele pode lidar com várias formas de parâmetros de entrada.
Os seguintes comandos fazem o gráfico da função y = x4 K4 x3 C3 de x = K2 a x = 2.
O intervalos que a variável x pode assumir é especificada na forma mostrada, utilizando dois
pontos .. e constitui uma estrutura de dados do Maple denominada range. Inicialmente
definimos a expressão:
O restart:
O y:=x^4-4*x^3+3;
y := x4 K4 x3 C3
(2.1.1)
O plot(y,x=-2..2);
50
40
30
20
10
K2
0
K1
K10
1
x
2
1
x
2
Para rotular também o eixo vertical com um y, digitamos:
O plot(y,x=-2..2,'y');
50
40
30
y
20
10
K2
0
K1
K10
Podemos restringir ou estender o gráfico na direção vertical digitando o intervalo de valores para
y:
O plot(y,x=-2..2,'y'=-10..10);
10
y
K2
5
0
K1
1
x
2
K5
K10
Podemos escolher a cor do gráfico adicionando uma opção do tipo color=??.
ou colour=??.
O plot(y,x=-2..2,'y',colour=magenta);
50
40
30
y
20
10
K2
0
K1
K10
1
x
2
As escolhas para a opção colour são: aquamarine, black, blue, coral, cyan, brown, gold,
green, grey, khaki, magenta, maroon, navy, orange, pink, plum, red, sienna, tan, turquoise,
violet, wheat, white, yellow.
Podemos escolher a cor definindo-a em termos de componentes de vermelho, verde e azul (RGB)
.
O plot(y,x=-4..4,color=COLOR(RGB,.7,0,0.8));
500
400
300
200
100
K4
K3
K2
K1
0
1
2
x
3
4
2
x
3
4
Podemos dar nome à cor:
O purpura := COLOR(RGB,.7,0,1);
plot(x^2,x=-4..4,color=purpura);
purpura := COLOR RGB, 0.7, 0, 1
16
14
12
10
8
6
4
2
K4
K3
K2
K1
0
Alternativamente é possível usar uma macro.
1
O macro(darkgreen=COLOR(RGB,0,0.6,0));
plot(x^2,x=-4..4,color=darkgreen);
darkgreen
16
14
12
10
8
6
4
2
K4
K3
K2
K1
0
1
2
x
3
4
Gráficos simultâneos podem ser construídos definindo uma lista de expressões, cujos gráficos
queremos traçar:
O [x^2,x+1];
2
x , x C1
(2.1.2)
O plot([x^2,x+1],x=-2..2,'y');
4
3
y 2
1
K2
K1
0
K1
1
x
Podemos escolher as cores dos gráficos definindo a respectiva lista de cores: .
O plot([x^2,x+1],x=-2..2,'y',color=[blue,green]);
2
4
3
y
2
1
K2
K1
0
1
x
K1
2
Note que usamos aspas simples para retardar a avaliação de y, que já tem um valor atribuído. O
seguinte exemplo mostra um tipo de erro devido ao fato da variável já ter um valor atribuído:
O x := 5;
plot(2*x-x^2,x=-1..3);
x := 5
Error, (in plot) unexpected option: 5 = -1 .. 3
Este problema pode ser resolvido removendo a atribuição de x:
O x := 'x':
plot(2*x-x^2,x=-1..3);
1
K1
0
1
2
3
x
K1
K2
K3
Podemos atribuir nomes aos gráficos, para depois exibi-los. Antes disso devemos carregar a
bibliteca plots:
O with(plots):
O g1:=plot(sin(x)^2,x=-Pi..Pi,color=blue):
O g2:=plot(sin(x^2),x=-Pi..Pi):
O display([g2,g1]);
1
0.8
0.6
0.4
0.2
K3
K2
K1
1
K0.2
2
3
x
K0.4
K0.6
K0.8
Os gráficos são desenhados com a espessura de um pixel, a menos que uma espessura maior que 1
seja especificada com a opção "thickness" .
O plot(2*x-x^2,x=-1..3,thickness=2);
1
K1
0
K1
1
2
x
K2
K3
Para plotar funções parametrizadas o procedimento é o seguinte:
O plot([t*cos(2*Pi*t), t*sin(2*Pi*t), t=0..4], scaling=
constrained, axes=box);
3
3
2
1
0
K1
K2
K3
K3
K2
K1
0
1
2
3
4
Gráficos de funções definidas implicitamente podem ser traçados com o comando
implicitplot:
O implicitplot(sin(x*y)+y=2,x=-6..6,y=0..4);
4
3
x4 K4 x3 C3 2
1
0
1
1.5
2
2.5
3
3.5
x
O implicitplot(sin(x*y)+y=2,x=-6..6,y=0..4,numpoints=10000);
4
3
x4 K4 x3 C3 2
1
0
1
1.5
2
2.5
3
3.5
x
As coordenadas de um ponto podem ser representadas em Maple por meio de uma lista com dois
números. Por exemplo, o ponto (1,2) é escrito como [1,2].
Definimos a seguir a lista de pontos dados por K2, 2 , K1, K2 , 1, 2 , 2, 3 .
O mypoints := [[-2,2],[-1,-2],[1,2],[2,3]];
mypoints := K2, 2 , K1, K2 , 1, 2 , 2, 3
Podemos plotar estes pontos em gráfico usando plot.
O plot(mypoints,style=point);
(2.1.3)
3
2
1
K2
K1
0
1
2
K1
K2
As escolhas das cores são as mesmas que foram definidas para plotar gráficos. Os símbolos
podem ser escolhidos como box, cross, circle, point, e diamond.
Você pode também digiter estes tipos de pontos em maiúsculas, BOX,CROSS,CIRCLE,
POINT,DIAMOND, mas não misture maiúsculas e minúsculas.
O plot(mypoints,style=point,colour=blue,symbol=circle);
3
2
1
K2
K1
0
1
2
K1
K2
Mais informações sobre as opções para o procedimento plot podem ser obtidas na página help
associada. .
Os três modos de acesso à página de ajuda para as opções de plot são
• Clique no hyperlink: plot[options].
• Selecione a palavra plot[options] com o mouse e escolha Help on "plot[options]" que deve
aparecer na segunda linha do menu help.
• Digite ?plot[options] em uma linha de comando e execute.
O ?plot[options]
A sequência de números 1, 4, 9, 16, 25, . . . , 100 de todos os quadrados dos números de 1 a 10
podem ser construídos usando o procedimento seq.
O seq(i^2,i=1..10);
1, 4, 9, 16, 25, 36, 49, 64, 81, 100
(2.1.4)
Esta sequência pode ser transformada em uma lista colocando colchêtes em torno do comando
O [seq(i^2,i=1..10)];
1, 4, 9, 16, 25, 36, 49, 64, 81, 100
(2.1.5)
O seguintes comandos plotam os pontos 0, 1 , 1, 3 , 2, 5 , 3, 7 , 4, 9 , 5, 11 , 6, 13 .
Estes pontos tem a forma k, 2 k C1 onde os parâmetro k toma valores todos os valores inteiros
de t 0 a 6 inclusive, de modo que podemos usar seq.
A opção view pode ser utilizada para especificar o intervalo vertical a ser empregado no plot.
O point_list := [seq([k,2*k+1],k=0..6)];
point_list :=
0, 1 , 1, 3 , 2, 5 , 3, 7 , 4, 9 , 5, 11 , 6, 13
(2.1.6)
O plot(point_list,style=point,symbol=box,color=brown,view=0.
.13);
12
10
8
6
4
2
0
0
1
2
3
4
5
6
2.2 pointplot,pointplot3d
Outro modo de fazer gráfico com pontos é através do comando pointplot:
O restart:
O with(plots):
O pointlist:=[[1,2],[2,6],[4,4],[3,2]];
pointlist := 1, 2 , 2, 6 , 4, 4 , 3, 2
(2.2.1)
A opção connect=true pode ser utilizada para conectar os pontos por segmentos ou curvas:
O pointplot(pointlist,color=blue,connect=true);
6
5
4
3
2
1
2
3
Também podemos fazer gráficos de pontos em três dimensões:
4
O points:= [ seq([cos(Pi*T/40),sin(Pi*T/40),T/40],T=0..40) ]:
O pointplot3d(points,axes=boxed,connect=true);
0.0
0.5
1.0
1.0
-1
0.5
0
0.0
1
2.3 plot3d,implicitplot3d
Maple pode também plotar gráficos em 3D. A superfície pode ser girada com o mouse.
O restart:
O plot3d(x^2+y^2,x=-2..2,y=-2..2,axes=boxed);
8
6
4
-2
2
0
2
-1
1
0
y
0
x
1
-1
2-2
Quando temos uma função definida implicitamente, podemos utilizar o comamdo implictplot3D:
O implicitplot3d(sin(x*y)+y*z^2-z,x=-1..1,y=-1..1,z=-1..1,
axes=boxed);
implicitplot3d sin x y Cy z2 Kz, x = K1 ..1, y = K1 ..1, z = K1 ..1, axes = boxed
(2.3.1)
O implicitplot3d(x^3+y^3+z^3+1=(x+y+z+1)^3, x=-2..2, y=-2..2,
z=-2..2, grid=[10,10,10],axes=frame);
3
3
3
3
implicitplot3d x Cy Cz C1 = x Cy Cz C1 , x = K2 ..2, y = K2 ..2, z = K2 ..2, grid (2.3.2)
= 10, 10, 10 , axes = frame
No seguinte exemplo utilizamos coordenadas esféricas:
O implicitplot3d(r=(3)^x*sin(y), r=0.1..5, x=-1..2*Pi, y=0..
Pi, coords=spherical);
implicitplot3d r = 3x sin y , r = 0.1 ..5, x = K1 ..2 π, y = 0 ..π, coords = spherical
(2.3.3)
Agora utilizamos coordenadas cilíndricas:
O implicitplot3d(r^2+z^2=1, r=0..1, theta=-Pi..Pi, z=-1..1,
coords=cylindrical,axes=frame);
implicitplot3d r2 Cz2 = 1, r = 0 ..1, θ = Kπ ..π, z = K1 ..1, coords = cylindrical, axes
(2.3.4)
= frame
No seguinte exemplo tivemos que aumentar o número mínimo total de pontos utilizado para gerar
gráfico para a obtenção de um resultado satisfatório (default 625 = 25^2):
O implicitplot3d([y=sin(x*z+6), y=cos(-x*z)], x=-Pi..Pi, y=Pi..Pi, z=-1..1,color=[blue,red],axes=frame, numpoints=
2000);
implicitplot3d
y = sin x z C6 , y = cos x z , x = Kπ ..π, y = Kπ ..π, z = K1 ..1, color
(2.3.5)
= blue, red , axes = frame, numpoints = 2000
No próximo exemplo usamos a opção scaling=constrained que faz com que as escalas
dos diferentes eixos sejam as mesmas.
O implicitplot3d([(x+2)^3+(y+2)^2+(z+2)^2=9, (x-2)^2+(y-2)^2+
(z-2)^2=15], x=-5..7, y=-8..8, z=-8..7, color=[blue,green],
scaling=constrained, axes=boxed);
implicitplot3d
x C2 3 C y C2 2 C z C2 2 = 9, x K2 2 C y K2 2 C z K2 2
(2.3.6)
= 15 , x = K5 ..7, y = K8 ..8, z = K8 ..7, color = blue, green , scaling = constrained,
axes = boxed
Para ver a diferença, modifique esta opção para scaling=unconstrained (default).
2.3 polygonplot,polygonplot3d,with(plottools),animate
O procedimento polygonplot, que logo abaixo é utilizado para plotar o triângulo (cheio) com
vértices em 0, 0 , 0, 1 , 1, 1 and 1, 0 :
O with(plots);
animate, animate3d, animatecurve, arrow, changecoords, complexplot, complexplot3d,
(2.4.1)
conformal, conformal3d, contourplot, contourplot3d, coordplot, coordplot3d,
densityplot, display, dualaxisplot, fieldplot, fieldplot3d, gradplot, gradplot3d,
graphplot3d, implicitplot, implicitplot3d, inequal, interactive, interactiveparams,
intersectplot, listcontplot, listcontplot3d, listdensityplot, listplot, listplot3d,
loglogplot, logplot, matrixplot, multiple, odeplot, pareto, plotcompare, pointplot,
pointplot3d, polarplot, polygonplot, polygonplot3d, polyhedra_supported,
polyhedraplot, rootlocus, semilogplot, setcolors, setoptions, setoptions3d,
spacecurve, sparsematrixplot, surfdata, textplot, textplot3d, tubeplot
O triangle := [[0,0],[0,1],[.5,1]]:
polygonplot(triangle,axes=none,color=orange);
O ngon := n -> [seq([cos(2*Pi*i/n), sin(2*Pi*i/n)], i = 1..n)
];
2πi
2πi
ngon := n/ seq cos
, sin
, i = 1 ..n
(2.4.2)
n
n
O display([polygonplot(ngon(5)), textplot([0,0,`Octagon`])],
color=magenta);
0.8
0.6
0.4
0.2
K0.8K0.6K0.4
Octagon
0.2 0.4 0.6 0.8 1
K0.2
K0.4
K0.6
K0.8
O pacote plots também contém o procedimento polygonplot3d que pode ser usado da
seguinte forma pra traçar um cubo:
O plots[polygonplot3d]([[[0,0,0],[1,0,0],[1,1,0],[0,1,0]],
[[0,0,1],[1,0,1],[1,1,1],[0,1,1]],
[[0,0,0],[0,1,0],[0,1,1],[0,0,1]],
[[1,0,0],[1,1,0],[1,1,1],[1,0,1]],
[[0,0,0],[1,0,0],[1,0,1],[0,0,1]],
[[0,1,0],[1,1,0],[1,1,1],[0,1,1]]],
lightmodel=light4,scaling=constrained,style=patchnogrid);
Alguns objetos geométricos em 3D, assim como as operações de reflexão, rotação e translação
destes objetos são encontrados no pacote plottools. Note que este pacote deve ser carregado
junto plots.
O with(plottools);
arc, arrow, circle, cone, cuboid, curve, cutin, cutout, cylinder, disk, dodecahedron,
(2.4.3)
ellipse, ellipticArc, hemisphere, hexahedron, homothety, hyperbola, icosahedron,
line, octahedron, parallelepiped, pieslice, point, polygon, project, rectangle, reflect,
rotate, scale, semitorus, sphere, stellate, tetrahedron, torus, transform, translate, vrml
O C1 := cone([0,0,0], 1/2, 2):
O display( C1,axes=frame );
-0.5
0.0
2.0
0.5
-0.5
1.5
1.0
0.0
0.5
0.0
0.5
Note que a manipulação do gráfico admite dois graus de liberdade de rotação. No caso acima, não
conseguimos fazer o vértice do cone apontar na direção horizontal. No entanto, ao aplicar uma
π
rotação de
com relação a um dos eixos do plano ortogonal ao eixo de simetria do cone temos
2
O C2:=rotate(C1,Pi/2,0,0):
O display(C2,axes=frame,scaling=unconstrained);
0.0
0.5
1.0
0.5
1.5
2.0
-0.5
0.25
0.0
-0.25
0.0
-0.25
0.25
-0.5
0.5
Mesmo com dois graus de liberdade somente podemos agora fazer o vértice apontar em qualquer
uma das três direções espaciais . Por quê ?
Façamos um objeto composto:
O sorvete := cone([0,0,-2],0.7,2,color=tan),
sphere([0,0,0.1],0.68,color=wheat):
O plots[display](sorvete, scaling=constrained);
O f := dodecahedron([0,0,0],0.8), torus([1,1,1], 0.5, 1.4):
plots[display](f,orientation=[45,0],scaling=constrained);
Tente colocar o dodecaedro no centro do toro.
2.4 animate
Gráficos podem ser animados.
O animate( 3*exp(-0.2*t-x^2)*sin(Pi*(x+t)),x=-5..5,t=0..20,
view=[-3..3,-3..3],axes=normal, frames=50,numpoints=500);
3
2
1
K3
K2
K1
0
K1
1
2
3
x
K2
K3
Este comando pode ser utilizado também em 3D:
O animate( plot3d, [sin(t)*(x^2+y^2), x=-2..2, y=-2..2], t=0.
.2*Pi,axes=boxed );
t = 0.
-2
-1
0
y
1
7
2
-2
2
-1
0
-3
1
-8
x
2
O ;
2.5 Exercícios
4
3
2
1. Plote a curva y = x K4 x Kx C5 x K1 para mostrar as principais características do gráfico.
Em particular, certifique-se que todas as intersecções e pontos de retorno apareçam no figura. A
4
3
2
equação x K4 x Kx C5 x K1 = 0 possui alguma solução inteira? Explique.
2. (a) Plote o gráfico de y = x sin 60 x no intervalo de x = 0 a x = 3 π usando a opção
"numpoints" , se necessário, para obter um bom resultado.
(b) Plote as curvas y = x sin 60 x , y = x e y = K x simultaneamente para mostrar como a
curva y = x sin 60 x está "presa" entre as curvas y = x e y = K x .
3. Plote the gráficos dados pelas equações abaixo. Em cada caso escolha um intervalo
conveniente que mostre as principais características do gráfico. I
(a) y = x2 K5 x K3
(b) y = x3 Kx
(c) y2 = x
(d) x2 Ky2 = 2
Para o gráfico em (d), mostre também as assíntotas y = x e y = Kx .
2
4. Plote as funções y = x K5 x C6 e y =
1
juntas. Experimente diferentes intervalos
x K2 2
para y de modo que ambos gráficos sejam mostrados de forma satisfatória.
5. Faça o mesmo com f x = sec x C4 no intervalo 0, 2 π .
x
6. Estime graficamente onde as funções definidas por f x = 20 Kx e h x = 1.012 se
interceptam.
n
7. Faça gráficos comparativos das funções y = x , para diferentes valores de n. Faça uma
animação.
8. Faça o gráfico simultâneo das superfícies definidas por sin x y Ccos z C2 = 0 e
x C2 y Kx = 3.
9. Faça o gráfico das seguintes funções parametrizadas:
t2 K1
2t
(a) r t = 2
, 2
, para t pertencendo a KN ..N .
t C1 t C1
4 t3
14 t2
t
4 t3
t2
14 t
(b) r t =
K
C C1, K
K
C
, para t pertencendo a (0,1)
9
9
9
9
9
9
10. Desenhe um pentágono inscrito numa circunferência.
11. Desenho um toro que possa ser interativamente orientado em qualquer direção espacial.
12. Plote o Folium, que é definido como o gráfico em coordenadas polares de seguinte função
2
radial: cos θ 4 sin θ K1 . Utilize a opção coords=polar (veja exemplos no menu help)
para traçar o gráfico em coordenadas polares.
3 Expressões e Funções
3.1 Seta, eval
Ao usar Maple é importante distinguir cuidadosamente expressões e funções. Por exemplo,
x2 K4 x C3 and x C2 são funções na variável x.
Elas são introduzidas como já fizemos antes, atribuindo nomes se necessário:
O x^2-4*x+3;h:=sqrt(x)+2;
x2 K4 x C3
h :=
x C2
(3.1.1)
Em matemática utilizamos tais expressões para definir funções, como f x = x2 K4 x C3 e
g x = x C2.
Em Maple as funções f e g devem ser entendidas agora de uma forma bastante precisa, como
nomes de ações ou procedimentos associados com valores computados destas expressões para
um dado número de entrada x.
No Maple funções são facilmente definidas utilizado a seta. Por exemplo,
O f := x -> x^2-4*x+3;
f := x/x2 K4 x C3
(3.1.2)
Uma vez que tal comando foi executado a função f pode ser utilizada durante a seção como
qualquer outra função definida previamente.
Assim,
O f(1/2);
5
(3.1.3)
4
O f(3);
(3.1.4)
0
Entradas simbólicas também podem ser utilizadas.
O f(s);
2
s K4 s C3
O f(s+1);
s C1
2
(3.1.5)
(3.1.6)
K4 s K1
A função pode plotada:
O plot(f(x),x=0..4);
3
2
1
0
K1
ou
O plot(f,0..4);
1
2
x
3
4
3
2
1
0
1
2
3
4
K1
Outras funções podem ser definidas em termo de f:
O g := x -> f(x-1);
h := x -> f(x-2);
g := x/f x K1
(3.1.7)
h := x/f x K2
O plot([f(x),g(x),h(x)],x=0..6,y=-1..3,color=[red,aquamarine,
gold],thickness=2);
3
2
y
1
0
1
2
3
x
4
5
6
K1
Uma vez que a função foi definida, o Maple lembrará desta função durante toda a seção. É
possível sobrescrever a definição de uma função com uma nova definição.
Por exemplo, se queremos mudar a definição da função f x =
executar o comando:
x
, devemos digitar e
x C1
2
O f := x -> x/(x^2+1);
f := x/
x
x C1
2
(3.1.8)
A presente (nova) definição da função f pode ser confirmada da seguinte forma:
O f(x);
x
x C1
2
(3.1.9)
ou, utilizando o comando de avaliação,
O eval(f);
x/
x
2
x C1
Digitando simplesmente f; em uma linha de comando não é suficiente:
O f;
f
Note: Note que com a nova definição de f, g e h també, mudam:
O g(x);
x K1
x K1 2 C1
O h(x);
x K2
x K2
2
C1
(3.1.10)
(3.1.11)
(3.1.12)
(3.1.13)
No entanto, a aplicação de eval a g confirma as definições de g in termos de f, mas não diz
nada sobre f:
O eval(g);
x/f x K1
(3.1.14)
O plot([f(x),g(x),h(x)],x=-5..7,color=[red,aquamarine,gold],
thickness=2);
0.4
0.2
K4
K2
0
2
4
6
x
K0.2
K0.4
Para limpar a atribuição de f sem redefini-lo fazemos
O f := 'f';
f := f
(3.1.15)
Um certo número de funções, digamos, f, g, h, podem ter suas atribuições limpadas
simultaneamente:
O unassign('f','g','h');
Para economizar memória é sempre bom limpar as atribuições de funções e variáveis, ao iniciar
um novo problema. Alternativamente podemos sempre usar
restart; para limpar tudo da memória.
3.2 unapply, map
Uma expressão como
O F:= x^2-4*x+3;
F := x2 K4 x C3
(3.2.1)
pode ser transformada em uma função com o comando unapply:
O f:=unapply(F,x);
f := x/x2 K4 x C3
(3.2.2)
Podemos calcular o valor da função em x = 3, por exemplo, de dois modos.
O f(3);
0
(3.2.3)
O eval(F,x=3);
0
O comando subs pode ser também usado para avaliar a expressão num dado ponto:
O subs(x=3,F);
0
(3.2.4)
(3.2.5)
O procedimento de Maple map é um exemplo de procedimento que funciona somente com
funções e não expressões.
O g := x -> x^2;
map(g,[1,2,3,4,5,6]);
2
g := x/x
1, 4, 9, 16, 25, 36
(3.2.6)
O comando evalf avalia um número em dígitos flutuantes até uma precisão especificada. Vamos
então construir a função:
O evalf15 := x -> evalf(x,15);
evalf15(Pi);
evalf15 := x/evalf x, 15
3.14159265358979
(3.2.7)
3.3 proc
Outro modo de definir funções é através de procedimentos:
O h:=proc(a,b)
if a<0 then print(erro) else
O plot(sqrt(x)+1,x=a..b)
end if;
O end;
h := proc a, b
if a ! 0 then print erro else plot sqrt x C1, x = a ..b end if
end proc
O h(0,1);
(3.3.1)
2
1.8
1.6
1.4
1.2
1
0
0.2
0.4
0.6
0.8
1
x
O h(b);
Error, (in h) cannot determine if this expression is true or false: b <
0
Podemos também definir funções de várias variáveis:
O g:=(x,y)->x*y^2+x-y^2;
2
2
g := x, y /x y Cx Ky
ou
O F:=proc(x,y)
O x*sin(y)+x^2
O end;
O F(1,2);
F := proc x, y x * sin y Cx^2 end proc
(3.3.3)
sin 2 C1
(3.3.4)
O Ff:=proc(x,y)
O evalf(x*sin(y)+x^2)
O end;
Ff := proc x, y evalf x * sin y Cx^2 end proc
O Ff(Pi,Pi);
(3.3.2)
9.869604404
O seq(map(Ff, [1,2,3], 1+i),i=1..3);
1.909297427, 5.818594854, 11.72789228 , 1.141120008, 4.282240016,
9.423360024 , 0.2431975047, 2.486395009, 6.729592514
(3.3.5)
(3.3.6)
(3.3.7)
3.4 Exercícios 2
x3 C3 x2 K1
1 (a) Construa a função f x =
4
x C4
usando a notação seta.
(b) Determine f K1 , f 0 e f 1 .
(c) Faça o gráfico de f sobre o intervalo de x = K4 a x = 4.
x3 C3 x2 K1
(d) Use o procedimento eval para avaliar a expressão
para x = K1, x = 0 e x = 1.
4
x C4
2 Construa uma função cuja entrada é uma lista qualquer e cuja saída é uma lista que avalia o seno
de cada elemento da lista de entrada.
4. Solução de Equações Algébricas
4.1 solve, fsolve
O restart:
Vamos agora considerar equações algébricas do tipo
O eq1:=a*x^2+b*x+c=0;
eq1 := a x2 Cb x Cc = 0
(4.1.1)
Podemos resolver esta equação para x:
O sol:=solve(eq1,x);
b2 K4 a c
1 bC
,K
a
2
1 Kb C
sol :=
2
b2 K4 a c
a
(4.1.2)
O sol[1];
1 Kb C
2
b2 K4 a c
a
1 bC
2
b K4 a c
a
(4.1.3)
O sol[2];
K
2
(4.1.4)
Consideremos algumas equações mais específicas, dando valores às constantes a, b e c :
O eq2:=subs(a=1,b=3,c=-4/5,eq1);
4
eq2 := x2 C3 x K
=0
5
O sol:=solve(eq2,x);
sol := K
Em pontos flutuantes,
O evalf(sol);
3
1
C
2
10
305 , K
3
1
K
2
10
0.246424920, K3.246424920
305
(4.1.5)
(4.1.6)
(4.1.7)
Poderíamos ter escrito desde o início,
O evalf(solve(eq2,x));
0.246424920, K3.246424920
ou
O fsolve(eq2,x);
(4.1.8)
K3.246424920, 0.2464249197
(4.1.9)
printlevel := 1
(4.1.10)
O printlevel:=1;
Estas duas formas não sempre equivalentes, no entanto. Consideremos, por exemplo,
O eq3:=x^3-x^2+1;
3
2
eq3 := x Kx C1
(4.1.11)
O evalf(solve(eq3));
K0.7548776667, 0.8774388331 K0.7448617670 I, 0.8774388331 C0.7448617670 I (4.1.12)
O fsolve(eq3);
(4.1.13)
K0.7548776662
Para que o comando fsolve possa encontrar também raízes complexas o argumento complex deve
ser dado:
O fsolve(eq3=0,x,complex);
K0.7548776662, 0.8774388331 K0.7448617666 I, 0.8774388331 C0.7448617666 I (4.1.14)
Vejamos outro exemplo com uma equação não polinomial:
O eq4:=sin(x)+x^(1/2)-3/2;
eq4 := sin x C x K
O evalf(solve(eq4,x));
O fsolve(eq4);
3
2
(4.1.15)
0.7141134004
(4.1.16)
3.530173727
(4.1.17)
Para esclarecer este dilema façamos um gráfico:
O plot(eq4,x=0..14);
3
2
1
0
2
4
6
8
10
12
14
x
K1
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:
O r1:=fsolve(eq4,x,0..2);
r1 := 0.7141134004
(4.1.18)
O r2:=fsolve(eq4,x,2..4);
r2 := 3.530173727
(4.1.19)
O r3:=fsolve(eq4,x,4..6);
r3 := 5.338242169
(4.1.20)
4.2 Exercícios 3
Resolva as equações abaixo e ilustre graficamente
1
1 sin x Csin 2 x Kx C
= 0,
2
2 x 3 Kex = 0,
4 3 x5 K3 x4 K7 x3 C4 x2 Kx C3=0.
5. 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.
Comando factor
Vamos supor que temos a seguinte expressão algébrica:
O restart:
O q:=(x^2-x-2);
q := x2 Kx K2
(5.1.1)
O comando factor, como o nome sugere, fatoriza esta expressão:
O factor(q);
x C1 x K2
(5.1.2)
Do mesmo modo, se
O p:=(x^2-1);
p := x2 K1
temos
O factor(p);
x C1
(5.1.4)
x2 K1
x2 Kx K2
(5.1.5)
x K1
Portanto, numa expressão tal como
O f:=p/q;
f :=
(5.1.3)
O comando factor produz uma simplificação:
O factor(f);
x K1
x K2
(5.1.6)
Consideremos agora a expressão
O ex1:=(x^2-2*x+1)^2+(y^2+2*y+1)^2;
ex1 := x2 K2 x C1
2
C y2 C2 y C1
2
Aplicando o comando factor obtemos
O factor(ex1);
x4 K4 x3 C6 x2 K4 x C2 Cy4 C4 y3 C6 y2 C4 y
(5.1.7)
(5.1.8)
o que não simplificou o problema. Notemos agora o seguinte:
O op(1,ex1);
x2 K2 x C1
O op(2,ex1);
y2 C2 y C1
2
2
(5.1.9)
(5.1.10)
Ou seja, o comando op extrai os operandos da expressão. Portanto, podemos fatorar ex1
eficientemente fazendo
O factor(op(1,ex1))+factor(op(2,ex1));
x K1 4 C y C1 4
(5.1.11)
Se tivéssemos uma expressão muito longa este método seria trabalhoso. Um modo mais eficiente
para resolver este problema é utilizando o comando map :
O map(factor,ex1);
4
4
x K1 C y C1
(5.1.12)
O comando factor aplicado à expressão definida por
O g:=(x^30-1)/(x-1);
x30 K1
g :=
x K1
produz consequências desastrosas:
O factor(g);
2
2
x C1 x Cx C1 x Kx C1
7
5
4
3
Kx Cx Kx Cx Kx C1
4
3
(5.1.13)
2
x Cx Cx Cx C1
8
7
5
4
4
3
2
x Kx Cx Kx C1
8
x (5.1.14)
3
x Cx Kx Kx Kx Cx C1
Resolveremos este problema através do comando normal.
Comando normal
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,
O q;
x2 Kx K2
(5.2.1)
O normal(q);
O p;
O normal(p);
Entretanto,
O p/q;
O normal(p/q);
2
x Kx K2
(5.2.2)
x2 K1
(5.2.3)
x2 K1
(5.2.4)
x2 K1
x2 Kx K2
(5.2.5)
x K1
x K2
(5.2.6)
produzindo neste caso o mesmo resultado que factor. No entanto, a diferença reaparece se no caso
mais geral
O g;
x30 K1
(5.2.7)
x K1
O normal(g);
29
28
27
26
25
24
23
22
21
20
19
18
17
16
1 Cx Cx Cx Cx Cx Cx Cx Cx Cx Cx Cx Cx Cx Cx
15
14
13
12
11
10
9
8
7
2
4
3
6
(5.2.8)
5
Cx Cx Cx Cx Cx Cx Cx Cx Cx Cx Cx Cx Cx Cx Cx
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:
O h:=1/(1-x^20)+1/(1-x^10);
1
1
h :=
C
(5.2.9)
20
10
1 Kx
1 Kx
O factor(h);
10
K x C2
x K1
C1
8
6
4
x C1
4
3
2
x Cx Cx Cx C1
4
3
2
x Kx Cx Kx C1
2
x
(5.2.10)
2
x Kx Cx Kx C1
O normal(h);
K
x10 C2
10
K1 Cx
10
x C1
(5.2.11)
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.
Comando expand
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 usurio 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:
O f1:=(x-a)^6;
f1 := x Ka 6
(5.3.1)
O expand(f1);
6
5
4 2
3 3
2 4
5
6
x K6 x a C15 x a K20 x a C15 x a K6 x a Ca
O factor(%);
a Kx
6
(5.3.2)
(5.3.3)
O comando factor pode ser usado também para expandir funções trigonométricas, logarítmicas
exponenciais, especiais, etc.:
O f2:=cos(omega*t+delta);
f2 := cos ω t Cδ
(5.3.4)
O expand(f2);
O f3:=ln(x^2*y);
O expand(f3);
cos ω t cos δ Ksin ω t sin δ
(5.3.5)
f3 := ln x2 y
(5.3.6)
ln x2 y
(5.3.7)
O Psi(4*x);
(5.3.8)
Ψ 4x
O expand(%);
1
1
1
2 ln 2 C
Ψ x C
Ψ xC
4
4
4
C
1
1
Ψ xC
4
2
C
1
3
Ψ xC
4
4
(5.3.9)
onde Ψ x é a função digamma.
Em determinados casos desejamos expandir somente parte de uma expressão. Vamos supor que
O f4:=(sin(alpha+beta)+x)^2;
2
f4 := sin α Cβ Cx
(5.3.10)
O expand(f4);
sin α
2
2
cos β
Ccos α
2
C2 sin α cos β cos α sin β C2 sin α cos β x
sin β
2
(5.3.11)
C2 cos α sin β x Cx2
Caso não queiramos expandir a função sin, procedemos da seguinte forma:
O expand(f4,sin);
sin α Cβ
2
C2 sin α Cβ x Cx2
(5.3.12)
Vejamos outro exemplo:
O f5:=sin(omega*(t-t0)+delta);
f5 := sin ω t Kt0 Cδ
(5.3.13)
O expand(f5);
sin ω t cos ω t0 cos δ Csin ω t sin ω t0 sin δ Kcos ω t sin ω t0 cos δ
(5.3.14)
Ccos ω t cos ω t0 sin δ
O expand(f5,t-t0);
sin ω t Kt0
cos δ Ccos ω t Kt0
sin δ
Consideremos agora a atuação de expand sobre funções racionais:
O f6:=(x-y)^2/(x+y)^3;
x Ky 2
f6 :=
x Cy 3
O expand(f6);
x2
x Cy
3
K
2xy
x Cy
3
C
y2
x Cy
3
(5.3.15)
(5.3.16)
(5.3.17)
Ou seja, o denominador não foi expandido. Para fazer isso devemos proceder da seguinte forma:
O normal(f6,expanded);
x2 K2 x y Cy2
(5.3.18)
x3 C3 x2 y C3 x y2 Cy3
Comando combine
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,
O g1:=sin(alpha+beta)+cos(omega+delta);
g1 := sin α Cβ Ccos ω Cδ
(5.4.1)
O expand(g1);
sin α cos β Ccos α sin β Ccos ω cos δ Ksin ω sin δ
(5.4.2)
O factor(%);
sin α cos β Ccos α sin β Ccos ω cos δ Ksin ω sin δ
(5.4.3)
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:
O combine(%,trig);
sin α Cβ Ccos ω Cδ
(5.4.4)
Vejamos outros exemplos:
O g2:=(x+a)^n*(x+a)^s;
g2 := x Ca
O combine(g2,power);
O combine(g3,exp);
x Ca
s
(5.4.6)
g3 := e2 x eb
(5.4.7)
e2 x C b
(5.4.8)
O g4:=exp(sin(alpha)*cos(beta))*exp(cos(alpha)*sin(beta));
g4 := esin α cos β ecos α sin β
O combine(g4,exp);
O combine(%,trig);
esin α
(5.4.5)
n Cs
x Ca
O g3:=exp(2*x)*exp(b);
n
cos β C cos α sin β
esin α C β
Podemos executar a simplificação acima, de uma só vez, da seguinte forma:
O combine(g4,[trig,exp]);
esin α C β
(5.4.9)
(5.4.10)
(5.4.11)
(5.4.12)
Simplificações envolvendo ln necessitam o parâmetro adicional "simbolic". Por exemplo,
O g5:=3*ln(x)+2*ln(y);
g5 := 3 ln x C2 ln y
(5.4.13)
O combine(g5,ln,symbolic);
ln x3 y2
(5.4.14)
Comando convert
Embora o comando convert seja de utilidade mais geral, ele pode ser utilizado em simplificações,
como veremos nos próximos exemplos. Sua sintaxe é
convert(expressão, forma)
onde onde argumento "forma" pode ser um dos seguintes: trig, tan, ln, exp expln, expsincos,
rational, parfrac, radians, degree, GAMMA, factorial, etc. Por exemplo,
O m1:=(exp(I*theta)+exp(-I*theta))/2;
1 Iθ
1 KI θ
m1 :=
e C
e
(5.5.1)
2
2
O convert(m1,trig);
cos θ
O convert(%,exp);
O m2:=arcsinh(x);
1 Iθ
1 KI θ
e C
e
2
2
m2 := arcsinh x
(5.5.2)
(5.5.3)
(5.5.4)
O convert(m2,ln);
ln x C
2
x C1
(5.5.5)
O convert(n!,GAMMA);
Γ n C1
(5.5.6)
n!
(5.5.7)
n!
(5.5.8)
O convert(%,factorial);
O expand(%);
O convert(binomial(n,k),factorial);
n!
k! n Kk !
(5.5.9)
Comando simplify
O comando simplify é um comando geral de simplificação, que busca funções dentro de uma
expressão que podem ser simplificadas utilizando propriadades pré-definidas no sistema.
Entretanto, podemos usar este comando de forma selecionada, como no exemplo:
O n1:=(sin(x)^2+2*cos(x)^2)*exp(y)/exp(y+x);
sin x 2 C2 cos x 2 ey
n1 :=
(5.6.1)
ex C y
O simplify(n1);
O simplify(n1,trig);
eKx cos x 2 C1
(5.6.2)
y
e
2
cos x C1
ex C y
(5.6.3)
Ou seja, somente simplifícações trigonométricas foram efetuadas no último comando. Os
argumentos em simplify podem ser trig, hypergeom, radical, power, exp, ln, sqrt, Bessel, BesselJ,
BesselK, BesselY, Ei, GAMMA, RootOf, LambertW, dilog, polylog, pg, pochhammer e atsign. O
comando simplify pode muito útil na simplificação de expressões envolvendo vínculos. Por
exemplo, vamos supor que a expressão
O n2:=x^2+2*x*y+y^3;
2
3
n2 := x C2 x y Cy
(5.6.4)
está sujeita aos vínculos
O vinculos:={x+y+z=3, x^2+y=1, x-y+z^2=0};
2
2
vinculos := x Cy = 1, x Ky Cz = 0, x Cy Cz = 3
(5.6.5)
O simplify(n2,vinculos);
K35 x2 C23 x C17 x3 K14
(5.6.6)
Outra utilidade de simplify é na substituição de produtos em expressões por outras expressões ou
múmeros. Por exemplo, suponhamos que
O n3:=x^2*y^5*z;
2 5
n3 := x y z
(5.6.7)
Se queremos examinar o resultado da substituição z = 1 na expressão acima utilizamos o
comando subs
O subs(z=1,n3);
2 5
x y
(5.6.8)
2 4
Entretanto, se quisermos substituir x y = z sin z na expressão n3, o comando subs é inefetivo:
O subs(x^2*y^4=sin(z)*z,n3);
2 5
x y z
(5.6.9)
2 4
Podemos utilizar simplify onde x y = z sin z é considerado como um vínculo:
O simplify(n3,{x^2*y^4=sin(z)*z});
z2 y sin z
(5.6.10)
Podemos fazer com que o comando simplify assuma as hipóteses feitas utilizando o comando
assume. Por exemplo,
O p1:=(x^2*y^4)^(1/2);
p1 :=
x2 y4
(5.6.11)
O simplify(p1,assume=nonneg);
x2 y4
Acima, a opção assume=nonneg fez com que todas as variáveis sejam declaradas
temporariamente não-negativas.
6. Cálculo Diferencial e Integral
(5.6.12)
6.1 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,
N
N ). 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 a auxílio do value.
O Limit((sqrt(1+x)-1)/x,x=0);
1 Cx K1
lim
(6.1.1)
x/0
x
O value(%);
1
2
(6.1.2)
O 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
π Cx
=e
(6.1.3)
x/0
4
O Limit(x!/x^x,x=infinity)=limit(x!/x^x,x=infinity);
x!
lim
=0
x/N x
x
(6.1.4)
O resultado é avaliado simbolicamente sempre que possível, mesmo quando a expressão possui
variáveis desconhecidas.
O f:=(x^a-x^(-a))/(x-1/x);
xa KxKa
f :=
(6.1.5)
1
xK
x
O limit(f,x=1);
(6.1.6)
a
O limite também pode ser calculado com funções multivariáveis. Para isso o coordenada em que
se quer calcular o limite deve ser especificada da forma {x=x0,y=y0,...}.
O limit( (x+y)/x + (x+y)/y , {x=0,y=1} );
undefined
(6.1.7)
Quando queremos calcular o limite da função
1
quando x/0 o Maple não encontra dificuldade
x2
1
veja o resultado:
x
O Limit(1/x^2,x=0)=limit(1/x^2,x=0);
de dizer que é N, porém para a função
(6.1.8)
1
=N
2
x
lim
x/0
O Limit(1/x,x=0)=limit(1/x,x=0);
1
lim
= undefined
x/0 x
(6.1.8)
(6.1.9)
O motivo deste resultado é que o Maple reconhece que o limite desta função para este valor
depende da direção de aproximação.
O Limit(1/x,x=0,left)=limit(1/x,x=0,left);
1
lim
= KN
(6.1.10)
x/0K x
O Limit(1/x,x=0,right)=limit(1/x,x=0,right);
1
lim
=N
x/0C x
(6.1.11)
Para representar somatórios 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.
O Sum(1/x^n,n=1..5);
5
> x1
(6.1.12)
1
1
1
1
1
C 2 C 3 C 4 C 5
x
x
x
x
x
(6.1.13)
n
n=1
O value(%);
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.
O z:=10;
z := 10
(6.1.14)
O 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
O Sum('1/z^3','z'=1..5)=sum('1/z^3','z'=1..5);
5
> z1
z= 1
3
256103
216000
=
(6.1.15)
Quando se desejar fazer um somatório infinito basta especificar no intervalo.
O Sum(1/2^n,n=1..infinity)=sum(1/2^n,n=1..infinity);
N
> 21
n= 1
n
=1
(6.1.16)
Se você quiser construi somatórios de algumas variáveis pode-se colocar um somatório dentro de
outro. O exemplo seguinte mostra como o sum é usado para construir uma fórmula que usa
elementos de uma matriz como coeficiente.
O Sum(Sum(k[i,j]*y^(i+j),i=1..3),j=1..3);
3
3
> >k
i Cj
i, j y
j=1 i= 1
O value(%);
2
3
4
3
4
5
4
5
6
k1, 1 y Ck2, 1 y Ck3, 1 y Ck1, 2 y Ck2, 2 y Ck3, 2 y Ck1, 3 y Ck2, 3 y Ck3, 3 y
(6.1.17)
(6.1.18)
A mesma sintaxe do sum pode ser usada para o comando product que calcula o produtório
especificado no primeiro parâmetro.
O Product(x,x=1..5);
5
?x
(6.1.19)
120
(6.1.20)
x= 1
O value(%);
O Product(1+1/x^2,x=1..10)=product(1+1/x^2,x=1..10);
10
?
1C
x= 1
1
x2
=
2200962205
658409472
O product( 1+1/x^2 , x=1..infinity );
sinh π
π
O evalf(%);
3.676077910
(6.1.21)
(6.1.22)
(6.1.23)
6.2 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 derivads 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.
O restart;
O Diff(x^3+x^2+x,x);
O value(%);
d
dx
x3 Cx2 Cx
3 x2 C2 x C1
(6.2.1)
(6.2.2)
O Diff(x^3+x^2+x,x,x)=diff(x^3+x^2+x,x,x);
d2
x3 Cx2 Cx = 6 x C2
2
dx
(6.2.3)
Para derivadas de ordem superiores a dois convém utilizar o operador dólar ($) responsável pelas
repetições.
O Diff(x^3+x^2+x,x$3)=diff(x^3+x^2+x,x$3);
3
d
3
2
x Cx Cx = 6
(6.2.4)
3
dx
Obviamente o Maple conhece todas as regras de derivação como regra da cadeia, regra do produto
e da divisão de derivadas.
O Diff(sin(cos(x)),x)=diff(sin(cos(x)),x);
d
sin cos x = Kcos cos x sin x
(6.2.5)
dx
Para funções não definidas, o operador D é usado no resultado.
O Diff(f(g(x)),x)=diff(f(g(x)),x);
d
d
f g x =D f g x
g x
dx
dx
É possível derivar em função de qualquer variável da epressão.
O Diff((x^2+y^3)^4,x,y)=diff((x^2+y^3)^4,x,y);
v2
2
3 4
2
3 2
2
x Cy
= 72 x Cy x y
vy vx
(6.2.6)
(6.2.7)
Para derivadas de funções definidas implitamente poderia ser feito o seguinte procedimento:
O diff(x^2+y(x)^2=1,x);
d
2 x C2 y x
y x =0
(6.2.8)
dx
O solve(%,diff(y(x),x));
K
x
y x
Porém o comando implicitdiff já resolve diretamente.
O implicitdiff(x^2+y^2=1,y,x);
x
K
y
(6.2.9)
(6.2.10)
Enquanto o diff é usado para funções, o D é usado para calcular a derivada de operadores.
O D(sin);
cos
(6.2.11)
O D(sin@cos);
Kcos 2 sin
Quando a função tem vários parâmetros devemos colocar entre colchetes o número
correspondente à várivel sobre a qual se deseja derivar.
O f:=(x,y)->sin(x)+cos(y)+sin(x*y);
f := x, y /sin x Ccos y Csin y x
O D[1](f);
O D[2](f);
(6.2.12)
(6.2.13)
x, y /cos x Ccos y x y
(6.2.14)
x, y /Ksin y Ccos y x x
(6.2.15)
Podemos, ainda, passar novos valores a serem substituídos na expressão do resultado.
O D[2](f)(alpha,beta);
Ksin β Ccos β α α
(6.2.16)
Algumas vezes o formato D é mais desejado, outras o diff se torna mais conveniente. Para mudar
de um para outro pode ser usado o comando convert. E o lprint auxilia na visualização da estrutura
interna da expressão. Sendo que no Release 5 este comando se torna obsoleto, pois a estrutura
interna de uma expressão no format output pode ser obtido no format input posicionando o cursor
no próprio resultado e pressionando [Enter].
O restart;
O diff(f(x,y,z),x,y,z$2);
v4
f x, y, z
(6.2.17)
vz2 vy vx
O convert(%,D);
x, y, z
(6.2.18)
v4
f x, y, z
vz2 vy vx
(6.2.19)
D1, 2, 3, 3 f
O lprint(%);
(D[1, 2, 3, 3](f))(x, y, z)
O convert(%,diff);
O lprint(%);
diff(diff(diff(diff(f(x, y, z), x), y), z), z)
6.3 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 todas 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.
O Int(x^2+x^3,x);
x2 Cx3 dx
(6.3.1)
O value(%);
1 3
1 4
x C
x
3
4
(6.3.2)
O Int(x^2+x^3,x=a..b)=int(x^2+x^3,x=a..b);
b
2
3
x Cx
dx =
a
1 3
1 3
1 4
1 4
b K
a C
b K
a
3
3
4
4
(6.3.3)
Para fazer a integral numérica, od limites devem estar definidos
O Int(x^2+x^3,x=2..3)=int(x^2+x^3,x=2..3);
3
x2 Cx3 dx =
2
271
12
(6.3.4)
O Maple não encontra dificuldade quando o integrando possui uma descontinuidade no intervalo
de integração.
O f:=cos(x)/sqrt(1-sin(x));
cos x
f :=
(6.3.5)
1 Ksin x
O plot(f,x=0..2*Pi,discont=true,color=black);
1
0.5
0
K0.5
1
2
3
4
5
6
x
K1
O Int(f,x=0..2*Pi)=int(f,x=0..2*Pi);
(6.3.6)
2π
0
cos x
(6.3.6)
dx = 0
1 Ksin x
O Maple reconhece a função degrau (Heaviside) e a função delta de Dirac (Dirac) durante o
processo de integração
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 K2 dx =
0
g x dx
(6.3.7)
2
O Diff(Heaviside(x),x)=diff(Heaviside(x),x);
d
Heaviside x = Dirac x
dx
(6.3.8)
O Int(sin(x)*Dirac(x-Pi/4),x=-infinity..infinity)=int(sin(x)*
Dirac(x-Pi/4),x=-infinity..infinity);
N
sin x Dirac x K
KN
1
1
π dx =
4
2
2
(6.3.9)
Para representar integrais múltiplas é necessário colocar um comando de integral dentro de outro.
O Int(Int(x^2,x=0..2),x=0..3)=int(int(x^2,x=0..2),x=0..3);
3 2
x2 dx dx = 8
(6.3.10)
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 é retornado a integral na forma inerte. Para encontrar a
solução numérca utiliza-se o copmando evalf.
O int(sin(1/x^3),x=1..2);
2
(6.3.11)
0.3548334332
(6.3.12)
1
O evalf(%);
1
x3
dx
sin
6.4 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 Orderque é inicializado com
6.
O series(log(x),x=1);
1
1
2
x K1 K
x K1 C
x K1
2
3
3
K
1
4
x K1
4
C
1
5
x K1
5
CO
x K1
O series(sin(x),x=0,10);
1 3
1
1
1
5
7
9
10
xK
x C
x K
x C
x CO x
6
120
5040
362880
6
(6.4.1)
(6.4.2)
6
O tipo da saída obtido é series que caracterizado por um truncamento (O x K1 ). Por este
motivo, os resultados obtidos pelo comando serires não podem ser processados em seguida. Para
converter a expansão para um polinômio usa-se o comando convert.
O whattype(%);
series
(6.4.3)
O pol:=convert(%%,polynom);
1 3
1
1
1
pol := x K
x C
x5 K
x7 C
x9
6
120
5040
362880
(6.4.4)
O gráfico seguinte mostra a função sin x e a sua expansão em séries até potência 9.
O plot([pol,sin(x)],x=0..2*Pi,-1..1,color=black);
1
0.5
0
1
2
3
4
5
6
x
K0.5
K1
O comando mtaylor calcula a expansão em série de Taylor para funções multi-variáveis, pois o
series só efetua o cálculo para apenas uma. As suas sintaxes são iguais, sendo que para a expansão
com muitas variáveis o segundo parâmetro deve ser uma lista de pontos sobre os quais se deseja
realizar a expansão. Antes de usar o comando é necessário carregá-lo com readlib.
O ### WARNING: persistent store makes one-argument readlib
obsolete
readlib(mtaylor);
proc
... end proc
(6.4.5)
O mtaylor(log(x+y),[x=1,y=Pi],3);
y Kπ
x K1
1
ln 1 Cπ C
C
K
2
1 Cπ
1 Cπ
2
x K1
1 Cπ
2
K
y Kπ
x K1
1 Cπ
2
1
K
2
y Kπ
1 Cπ
2
2
(6.4.6)
O pacote powseries contém comandos auxiliares para o processamento de séries. Pode ser usado
para manipular series que possuem uma regra geral de expansão realizando adições, subtrações,
multiplicações, divisões, derivações e inversões destas séries. Devemos carregar o pacote com o
comando with.
O with(powseries);
compose, evalpow, inverse, multconst, multiply, negative, powadd, powcos, powcreate, (6.4.7)
powdiff, powexp, powint, powlog, powpoly, powsin, powsolve, powsqrt, quotient,
reversion, subtract, tpsform
Suponha que queremos calcular a série cuja fórmula geral é:
O p(n)=(1+(-1)^(n+1))/2*(-1)^((n-1)/2)/n!;
p n =
1
2
1 C K1
n C1
K1
1
1
nK
2
2
n!
(6.4.8)
O comando que cria a série é o powcreate que não mostra nenhuma saída mas faz a atribuição a
variável p que não pode ter nenhum conteúdo neste momento. O comando tpsform é usado para
visualizar a série gerada.
O powcreate(%);tpsform(p,x,9);
1 3
1
1
xK
x C
x5 K
x7 CO x9
(6.4.9)
6
120
5040
Veja como executar uma operação matemática ou uma inversão com a série criada e compare o
resultado obtido com o comando series.
O q:=evalpow(p*p):tpsform(q,x,9);
1 4
2 6
1
x2 K
x C
x K
x8 CO x9
(6.4.10)
3
45
315
O series(sin(x)^2,x,9);
1 4
2 6
1
x2 K
x C
x K
x8 CO x10
3
45
315
(6.4.11)
O r:=reversion(p):tpsform(r,x,9);
1 3
3 5
5
xC
x C
x C
x7 CO x9
6
40
112
(6.4.12)
O series(arcsin(x),x,9);
1 3
3 5
5
xC
x C
x C
x7 CO x9
6
40
112
(6.4.13)
6.5 O Pacote student: Ferramentas de Cálculo
O pacote student possue ferramentas úteis para o aluno iniciante de cálculo pois demonstram
conceitos elementares e fundamentais para o seu apredizado. Ele deve ser carregado com o
comando with, que seguido de ponto-e-vírgula imprimie todos os seus comandos.
O with(student);
D, Diff, Doubleint, Int, Limit, Lineint, Product, Sum, Tripleint, changevar,
(6.5.1)
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.
O A:=Int(tan(1/3*arctan(x)),x=0..1);
1
A :=
tan
0
O value(%);
1
tan
0
1
arctan x
3
1
arctan x
3
(6.5.2)
dx
(6.5.3)
dx
O changevar(1/3*arctan(x)=theta,A,theta);
1
π
12
tan θ
3 C3 tan 3 θ
2
(6.5.4)
dθ
0
O value(%);
1
1
2
18
5
sin
π
4 sin
12
5
π
12
2
C32 ln 4 sin
5
π
12
5
π
12
2
K24 ln 4 sin
K60 sin
2
K3
4
K3 sin
5
π
12
5
π
12
2
K3 sin
5
π
12
4
C69 sin
C48 ln sin
5
π
12
K64 ln sin
5
π
12
5
π
12
2
(6.5.5)
2
sin
5
π
12
5
π
12
4
sin
K9
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.
O inter:=-infinity..infinity;
(6.5.6)
(6.5.6)
inter := KN ..N
O Doubleint(exp(-x^2-y^2),x=inter,y=inter);
N
N
Kx2 K y2
e
(6.5.7)
dx dy
KN KN
O value(%);
(6.5.8)
π
Para mostrar como uma aproximação numérica de integrais opera podemos utilizar os comando
leftbox, middlebox ou rightbox. Com eles pode-se visualizar os retângulos representando as áreas
que serão somadas na aproximação.
O leftbox(sqrt(x),x=1..3,8);
1.6
1.4
1.2
1
0.8
0.6
0.4
0.2
0
1
1.5
2
x
2.5
3
O valor da aproximação é calculado com leftsum, middlesum ou rightsum que pode ser expresso
por um somátório e por ponto flutuante. Compare o resultado com a integração numérica do
Maple.
O leftsum(sqrt(x),x=1..3,8)=evalf(leftsum(sqrt(x),x=1..3,8));
1
4
7
>
i=0
1C
1
i = 2.704829825
4
(6.5.9)
O 1/4*Sum(sqrt(1+1/4*i),i = 0 .. 7) =
2.704829825827190957978159653324903678488;
1
4
7
> 12
4 Ci = 2.704829825827190957978159653324903678488
(6.5.10)
i= 0
O Int(sqrt(x),x=1..3)=int(sqrt(x),x=1..3.0);
3
x dx = 2.797434948
1
(6.5.11)
6.6 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 uma apelido para a expressão f(x,y,z), e calcular o
gradiente, divergente o laplaciano desta função:
O restart;with(linalg):
O alias(f=f(x,y,z));
f
(6.6.1)
O v:=[x,y,z];
# lista das coordenadas
v := x, y, z
(6.6.2)
O grad(f,v);
O diverge(%,v);
O laplacian(f,v);
v
v
v
f
f
f
vx
vy
vz
(6.6.3)
v2
v2
v2
f
C
f
C
f
vx2
vy2
vz2
(6.6.4)
v2
v2
v2
f
C
f
C
f
vx2
vy2
vz2
(6.6.5)
O rotacional deve ser aplicado a uma função vetorial. Assim, vamos dar apelidos para g(x,y,z) e h
(x,y,z):
O alias(g=g(x,y,z),h=h(x,y,z));
f, g, h
(6.6.6)
O curl([f,g,h],v);
v
v
hK
g
vy
vz
v
fK
vz
v
h
vx
v
gK
vx
v
f
vy
(6.6.7)
Podemos confirmar que o divergente do rotacional é zero:
O diverge(%,v);
0
(6.6.8)
e, da mesma forma, confirmar que o rotacional do gradiente é o vetor nulo:
O curl(grad(f,v), v);
0 0 0
(6.6.9)
Todas estas operações podem ser feitas em sistemas de coordenadas não-cartesianos. Vamos ver
um exemplo de cálculo de gradiente no sistema de coordenadas esféricas:
O f1 := r^2*sin(theta)*cos(phi);
f1 := r2 sin θ cos φ
(6.6.10)
O v:= [r, theta, phi];
(6.6.11)
v := r, θ, φ
O grad(f1, v, coords=spherical);
2 r sin θ cos φ
r cos θ cos φ
Kr sin φ
(6.6.12)
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, pedimos ajuda da forma ?coords.
6.7 Exercícios
1. Explique porque os seguintes comandos chegam a zero em vez de 2 x C2 y C2 z
O F:=[x^2,y^2,z^2]:
O X:=[x,y,z]:
O sum('diff(F[i],X[i])',i=1..3);
2 x C2 y C2 z
(6.7.1)
O for i to 3 do diff(F[i],X[i]); od;
2x
2y
(6.7.2)
2z
2. Seja f x = x3 Csin arctan x Ktan arcsin x .
(a) Encontre a primeira e a segunda derivadas de menores ordens que possuem um valor não nulo
em x = 0 e os seus valores correspondentes.
O f:= x^3+sin(arctan(x))-tan(arcsin(x));
x
x
3
f := x C
K
(6.7.3)
2
2
1 Cx
1 Kx
O i:=1;
(6.7.4)
i := 1
O f[0]:=f;
f0 := x3 C
O g:=0:
O while g=0 do
O
f[i]:=diff(f[i-1],x):
O
g:=subs(x=0,f[i]):
O
i:=i+1:
x
K
2
1 Cx
x
2
1 Kx
(6.7.5)
O od:
O 'i'=i-1;
O f[i+1]:=diff(f[i],x):
O diff('f(x)',x$i)=f[i-1];
8
4
291060 x6
d
198450 x
f
x
=
K
C
2 13 /2
2 11 /2
dx8
1 Cx
1 Cx
8
K
(6.7.6)
i=7
135135 x
2 15 /2
6
K
1 Cx
291060 x
2 13 /2
1 Kx
2
44100 x
2 9/2
1 Cx
4
K
198450 x
2 11 /2
1575
K
1 Cx
2
K
1 Kx
(6.7.7)
2 7/2
44100 x
2 9/2
1 Kx
K
1575
2 7/2
1 Kx
8
K
135135 x
2 15 /2
1 Kx
O
O
O
O
O
O
O
O
i:=9:
g:=0:
while g=0 do
f[i]:=diff(f[i-1],x):
g:=subs(x=0,f[i]):
i:=i+1:
od:
'i'=i-1;
(6.7.8)
i=9
(b) Deduza a regra geral para a ordem das derivadas não nulas em x = 0.
(c) Plote f x nos intervalo x=-10..10 e x = K0.001 ..0.001.
3. Com o auxílio do Maple resolva as seguintes integrais:
(a)
1
1
5
x Kx
1
3
(b) x ln 2 x C
dx
1 Cx2
dx
O A:=int(x*ln(2*x+sqrt(1+x^2)),x);
A := x ln 2 x C
1 Cx2
u := ln 2 x C
1 Cx2
dx
(6.7.9)
O u:=op(1,A)/x;
(6.7.10)
O diff(u,x);
x
2C
2
1 Cx
2 xC
O v:=x^2/2;
v :=
(6.7.11)
2
1 Cx
1 2
x
2
(6.7.12)
O A2:=u*v-int(v*diff(u,x),x);
1
1 2
1
1
A2 :=
ln 2 x C 1 Cx2 x2 K
x K
ln 3 x2 K1 C
arcsinh x
2
4
12
3
8
2
K
3
3
3
1
C
arctanh
4
12
9 xC
1
3
9 xK
1
3
xC
1
3
3
2
3
2
8
C
3
3
1
3
K
arctanh
12
4
3
K6
3
3
xK
xC
1
3
C6
3
3
1
3
3
2
3
xK
(6.7.13)
3
C12
3
1
3
3
C12
Outro procedimento utilizando o pacote student:
O with(student);
D, Diff, Doubleint, Int, Limit, Lineint, Product, Sum, Tripleint, changevar,
(6.7.14)
completesquare, distance, equate, integrand, intercept, intparts, leftbox, leftsum,
makeproc, middlebox, middlesum, midpoint, powsubs, rightbox, rightsum,
showtangent, simpson, slope, summand, trapezoid
O intparts(Int(x*ln(2*x+sqrt(1+x^2)),x),ln(2*x+sqrt(1+x^2)));
x
x2 2 C
1
1
1 Cx2
ln 2 x C 1 Cx2 x2 K
dx
(6.7.15)
2
2
2
2 x C 1 Cx
O value(%);
1
ln 2 x C 1 Cx2
2
1
3
C
arctanh
12
4
x2 K
1 2
1
1
x K
ln 3 x2 K1 C
arcsinh x
4
12
3
8
2
K
3
3
9 xC
1
3
3
xC
1
3
3
2
3
K6
3
xC
3
1
3
3
C12
(6.7.16)
8
2
C
3
3
3
1
arctanh
4
12
K
0
(c)
2
xK
1
3
3
2
1
3
9 xK
3
3
C6
3
xK
3
1
3
3
C12
4
x Kx dx
K1
4. Use o Maple para decidir se as séries convergem ou divergem:
N
> ln 1n
(a)
n=2
O sum(1/ln(n),n = 2 .. infinity);
N
> ln 1n
(6.7.17)
n=2
O value(%);
N
> ln 1n
(6.7.18)
n=2
N
(b)
>
n=1
n!
2n !
O S:=Sum(n!/(2*n)!,n = 1 .. infinity);
N
>
S :=
n= 1
O value(S);
1
K
4
N
(c)
> sin
n=1
4 e
1
4
π
n!
2n !
K1 Cerfc
(6.7.19)
1
2
(6.7.20)
1
n
O S:=Sum(sin(1/n),n = 1 .. infinity);
N
S :=
1
n
> sin
n=1
O value(S);
N
> sin
n=1
1
n
(6.7.21)
(6.7.22)
3
5. calcule a derivada da função f x = max x , x .
O f:=max(x^3,x);
f := max x, x3
(6.7.23)
O plot(f,x=-2..2);
8
6
4
2
K2
0
K1
1
x
K2
2
O diff(f,x);
1
x ! K1
undefined
x = K1
2
3x
x !0
undefined
x=0
1
x !1
undefined
x=1
3 x2
1 !x
(6.7.24)
6. Seja a função y x definida implicitamente por x C y = 1. Calcule a derivada y' e a segunda
derivada y''.
O eq:=sqrt(x)+sqrt(y) = 1;
eq := x C y = 1
(6.7.25)
O implicitdiff(eq,y,x);
K
y
(6.7.26)
x
7. Seja a função de duas variáveis z x, y implicitamente definida por h x, y, z = 0, para uma
função de três variáveis h. Determine a fórmula para
v
v2
ze
z. Qual é o resultado para
vx
vy vx
h = x C y C z K1?
O restart:
O d1:=implicitdiff(h(x,y,z),z(x,y),x);
D1 h x, y, z
d1 := K
D3 h x, y, z
(6.7.27)
O d2:=implicitdiff(h(x,y,z),z(x,y),x,y);
1
2
d2 :=
KD1, 2 h x, y, z D3 h x, y, z CD1, 3 h
3
D3 h x, y, z
y, z D3 h
x, y, z CD1 h
z D3, 3 h
x, y, z D2 h
x, y, z D2, 3 h
x, y, z D3 h
x, y, z D2 h
x, y, z KD1 h
x,
(6.7.28)
x, y,
x, y, z
O h := sqrt(x)+sqrt(y)+sqrt(z)-1:
O d1:=implicitdiff(h,z,x);
z
d1 := K
(6.7.29)
x
O d2:=implicitdiff(h,z,x,y);
d2 :=
2
1
x
(6.7.30)
y
8. Calcule as seguintes integrais definidas:
10
(a)
1
4 x4 C4 x3 K2 x2 K10 x C6
dx
x5 C7 x4 C16 x3 C10 x2
O Int((4*x^4+4*x^3-2*x^2-10*x+6)/(x^5+7*x^4+16*x^3+10*x^2),x
= 1 .. 10);
10
1
4 x4 C4 x3 K2 x2 K10 x C6
dx
x5 C7 x4 C16 x3 C10 x2
O value(%);
27
308
159
308
19
14
C
arctan 4 K
ln 2 K
arctan 13 K
ln 5 C
ln 11
50
25
50
25
50
5
O evalf(%);
2.366004897
(6.7.31)
(6.7.32)
(6.7.33)
π
2
4
(b)
x sin x cos x dx
0
1
5
1
(c)
1
7
K1
(d)
K2
dx
2
5 x K6 x C1
x
1
dx
x
9. Calcule as seguintes integrais definidas:
1
1
(a)
1 Kx
0
(b)
dx
2
N
eKa x cos b x
2
dx, para um número real positivo a.
0
O Int(exp(-a*x)*cos(b*x)^2,x = 0 .. infinity);
N
Ka x
e
cos b x
2
dx
(6.7.34)
0
O assume(a>0):
O value(%);
(c)
a~2 C2 b2
a~2 C4 b2 a~
(6.7.35)
N
eKx ln x dx
0
O int(exp(-x)*ln(x),x = 0 .. infinity);
Kγ
O evalf(%);
K0.5772156649
(6.7.36)
(6.7.37)
O restart:
N
eK
(d)
0
t
1
4
t
1 KeK
dt
t
O int(exp(-sqrt(t))/(t^(1/4)*sqrt(1-exp(-sqrt(t)))),t = 0 ..
infinity);
(6.7.38)
N
K t
e
1/4
0
N
(e)
1
1
t
dt
(6.7.38)
K t
1 Ke
dx
4
x K1
O int(1/sqrt(x^4-1),x = 1 .. infinity);
1
1
2 EllipticK
2
2
2
(6.7.39)
π
2
(f)
tan x dx
0
O int(sqrt(tan(x)),x = 0 .. Pi/2);
1
π 2
2
N
(g)
0
1
cosh a x
N
10. Calcule
0
(6.7.40)
dx, para um número real positivo a.
ln x
x Ca x K1
dx, para a positivo.
O int(ln(x)/((x+a)*(x-1)),x = 0 .. infinity);
a !0
undefined
1
π Cln
a
1
2
1 Ca
2
2
ln x2 C1
dx.
x2 C1
O A:=Int(ln(x^2+1)/(x^2+1),x);
ln x2 C1
A :=
x2 C1
(6.7.41)
otherwise
11. Calcule
dx
(6.7.42)
O with(student):
O intparts(A,ln(x^2+1),x);
(6.7.43)
2
ln x C1 arctan x K
2 x arctan x
2
x C1
dx
12. Calcule o produto dos primeiros 32 números primos.
O nextprime(2);
3
O restart:
O product(ithprime(i),i=1..32);
525896479052627740771371797072411912900610967452630
13. Calcule os seguintes limites:
sin x
(a) lim
x/0
x
O limit(sin(x)/x,x = 0);
(b) lim sin x
1
(6.7.43)
(6.7.44)
(6.7.45)
(6.7.46)
1
x
x/0
O limit(sin(x)^(1/x),x = 0);
undefined
1 Kcos x
x/0
x
O limit((1-cos(x))/x,x = 0);
(6.7.47)
(c) lim
0
(6.7.48)
x
π
(d) x/
limN 1 C
x
O limit((1+Pi/x)^x,x = infinity);
eπ
(6.7.49)
sin x
(e) lim x
x/0
O limit(x^sin(x),x = 0);
(f) x/
limN 2x C3
1
x x
14. Calcule os seguintes limites:
ln x
(a) x/
limN
x
ln x
(b) x/
limN
ex
x2 Csin x
(c) x/
limN
2 x2 Ccos 4 x
1
(6.7.50)
(d) lim
x/0
1
K
1
x
1 Ce
O limit(1/(1+exp(-1/x)),x = 0);
undefined
(e) x/
limN sinh tanh x
(6.7.51)
Ktanh sinh x
O limit(sinh(tanh(x))-tanh(sinh(x)),x = infinity);
1
1 K1
eK
e K1
2
2
(6.7.52)
7. Álgebra linear
7.1 Introdução
Os comandos de Álgebra Linear formam um pacote chamado linalg, que deve ser carregado com
o comando with:
O restart;
O 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. No
presente contexto, queremos saber quais são estas funções:
O with(linalg);
BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp, QRdecomp, Wronskian,
(7.1.1)
addcol, addrow, adj, adjoint, angle, augment, backsub, band, basis, bezout,
blockmatrix, charmat, charpoly, cholesky, col, coldim, colspace, colspan, companion,
concat, cond, copyinto, crossprod, curl, definite, delcols, delrows, det, diag, diverge,
dotprod, eigenvals, eigenvalues, eigenvectors, eigenvects, entermatrix, equal,
exponential, extend, ffgausselim, fibonacci, forwardsub, frobenius, gausselim,
gaussjord, geneqns, genmatrix, grad, hadamard, hermite, hessian, hilbert,
htranspose, ihermite, indexfunc, innerprod, intbasis, inverse, ismith, issimilar, iszero,
jacobian, jordan, kernel, laplacian, leastsqrs, linsolve, matadd, matrix, minor,
minpoly, mulcol, mulrow, multiply, norm, normalize, nullspace, orthog, permanent,
pivot, potential, randmatrix, randvector, rank, ratform, row, rowdim, rowspace,
rowspan, rref, scalarmul, singularvals, smith, stackmatrix, submatrix, subvector,
sumbasis, swapcol, swaprow, sylvester, toeplitz, trace, transpose, vandermonde,
vecpotent, vectdim, vector, wronskian
7.2 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:
O A := matrix( [ [1,2,3], [4,5,6] ] );
A :=
1 2 3
4 5 6
(7.2.1)
O B := matrix(3, 2, [a,1,1,d,e,1] );
a 1
B :=
1 d
(7.2.2)
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 declarar C como matriz e depois definir as componentes:
O C:=matrix(2,2);
C := array 1 ..2, 1 ..2,
(7.2.3)
O C[1,1]:=1;C[1,2]:=3;C[2,2]:=4;C[2,1]:=-2;
C1, 1 := 1
C1, 2 := 3
C2, 2 := 4
C2, 1 := K2
(7.2.4)
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:
O C[2,2] := 1/7;
1
C2, 2 :=
(7.2.5)
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:
O evalm(C);
1
3
K2
1
7
(7.2.6)
As operações de soma e potenciação de matrizes são feitas com os operadores ``+'' e ``^'' usuais
de soma e potenciação de números. A multiplicação de matrizes, não sendo comutativa, é feita
pelo operador ``&*'' (ampersand vezes). As expressões matriciais devem ser envolvidas pelo
comando evalm, acrônimo de evaluate in matrix context. Por exemplo:
O evalm((A&*B + C)^(-1));
71 C35 d
K
,
(7.2.7)
125 a C21 a d K66 K63 d C81 e K21 e d
7 7 C2 d
,
125 a C21 a d K66 K63 d C81 e K21 e d
7 4 a C3 C6 e
,
125 a C21 a d K66 K63 d C81 e K21 e d
K
7 a C3 C3 e
125 a C21 a d K66 K63 d C81 e K21 e d
A potenciação por um número negativo, quer dizer a inversão da matriz, e subseqüente
potenciação pelo módulo do número. A inversa também pode ser encontrada através do comando
inverse:
O inverse(matrix([[a,b],[c,d]]));
d
a d Kb c
K
c
K
a d Kb c
b
a d Kb c
a
a d Kb c
(7.2.8)
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 o elemento <i,j> é dado por
i
:
j
O matrix(3, 4, (i,j) -> i/j);
1 1 1
1
2 3 4
2
1
2
3
1
2
3
3
2
1
3
4
(7.2.9)
Existem várias matrizes especiais que são usadas com frequê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 diagoanal. Vejamos alguns exemplos:
O diag(1,2,3,4);
1 0 0 0
0 2 0 0
(7.2.10)
0 0 3 0
0 0 0 4
O diag(a$3);
a 0 0
(7.2.11)
0 a 0
0 0 a
O comando a$3 gera uma sequê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:
O diag(C,C);
1 3 0 0
K2
1
7
0
0
0
0
1
3
0
0
K2
1
7
(7.2.12)
Um caso particular de matriz diagonal é a matriz identidade. Ela pode ser criada com o comando
diag, da seguinte forma: diag(1$n), onde n é a dimensão da matriz identidade. Existem outras
formas não equivalentes de definir a matriz identidade. Podemos definí-la com o comando array
com a função de indexação identity. Por exemplo:
O ID := array(identity, 1..3, 1..3);
ID := array identity, 1 ..3, 1 ..3,
(7.2.13)
O evalm(ID);
1 0 0
0 1 0
(7.2.14)
0 0 1
Existe uma forma mais abstrata da matriz identidade no Maple que é ``&*( )''. Esta forma assume
a repesentação usual dependendo do contexto. Por exemplo:
O evalm(C - &*()*lambda);
(7.2.15)
1 Kλ
3
K2
1
Kλ
7
(7.2.15)
Neste exemplo, a matriz ``&*( )'' assumiu a dimensão 2 porque ela está somada a matriz C que
tem dimensão 2. Na maioria dos casos, não é necessário usar a matriz identidade, pois o Maple
assume que, quando um número está somando a uma matriz, este número está multiplicado pela
matriz identidade de dimensão conveniente. De forma que o comando acima é equivalente ao
comando evalm(C-lambda).
Vamos ver outras matrizes especiais. Se a matriz for uma faixa em torno da diagonal, podemos
usar o comando band:
O band([-1,1,2],4);
1 2 0 0
K1
1
2 0
0 K1
1 2
0
(7.2.16)
0 K1 1
O último argumento é a dimensão da matriz. O primeiro argumento é a lista dos elementos da
faixa.
A matriz de Toeplitz é gerada pelo comando toeplitz:
O toeplitz([alpha,1,beta,2]);
α 1 β 2
1 α 1 β
(7.2.17)
β 1 α 1
2 β 1 α
A matriz Jacobiana é criada pelo comando jacobian. O exemplo a seguir mostra claramente como
os elementos são calculados. O comando alias foi usado para expressar a dependência das funções
f, g e h em relação às variáveis x, y e z.
O alias(f=f(x,y,z),g=g(x,y,z),h=h(x,y,z));
f, g, h
(7.2.18)
O jacobian([f,g,h],[x,y,z]);
v
v
f
f
vx
vy
v
v
g
g
vx
vy
v
v
h
h
vx
vy
v
f
vz
v
g
vz
v
h
vz
(7.2.19)
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.
O randmatrix(2,2,entries=rand(0..10));
6 9
(7.2.20)
5 1
O comando hilbert cria a matriz de Hilbert. O comando sylvester cria a matriz de Sylvester a
partir de dois polinômios, e o comando frobenius cria a matriz na forma canônica racional de
outra matriz. Podemos citar ainda os comandos como hessian, hermite e smith entre outros.
7.3 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:
O A := matrix(2,3, (i,j) -> A.i.j);
Error, recursive assignment
O B := matrix(2,3, (i,j) -> beta.i.j);
2β 3β
β
B :=
2β 4β 6β
(7.3.1)
Podemos juntar as matrizes A e B lateralmente com o comando augment, e verticalmente com o
comando stackmatrix:
O augment(A,B);
1 2 3
β
2β 3β
4 5 6 2β 4β 6β
(7.3.2)
O stackmatrix(A,B);
1
2
3
4
5
6
β
2β 3β
(7.3.3)
2β 4β 6β
Podemos extrair uma sub-matriz de uma matriz com o comando submatrix:
O submatrix(%,2..3,1..2);
(7.3.4)
4
5
β 2β
(7.3.4)
Podemos multiplicar uma determinada coluna de uma matriz por um escalar:
O mulcol(A,1,alpha);
2 3
α
4α 5 6
(7.3.5)
Usando o último resultado, podemos apagar uma ou mais linha com o comando delrows:
O delrows(%,2..2);
α 2 3
(7.3.6)
A manipulação aritméticas de matrizes, além dos comandos de soma e ponteciação vistos,
abrange os comandos transpose, det, trace, rank e map entre outros.
O A:=matrix([[1,2,3],[4,-5,6],[9,8,7]]);
1 2 3
A :=
4 K5 6
9
O comando transpose calcula a transposta.
O transpose(A);
1
8 7
4 9
2 K5 8
3
O determinante é calculado pelo det.
O det(A);
O trace retorna o traço da matriz.
O trace(A);
(7.3.7)
(7.3.8)
6 7
200
(7.3.9)
3
(7.3.10)
A matriz inversa de A pode ser obtida da seguinte forma:
O evalm(A^(-1));
(7.3.11)
K
83
200
13
100
77
200
1
20
K
27
200
1
10
1
20
3
100
K
(7.3.11)
13
200
O rank mostra o número de linhas ou de colunas linearmente indepententes existentes na matriz
(posto):
O rank(A);
3
(7.3.12)
O rank([[1,2],[3,6]]);
1
(7.3.13)
O map será visto em maiores detalhes na parte de programação mas por enquanto nos serve para
realizar a mesma operação para todos os elementos da matriz.
O map(x->x^2,A);
1 4 9
16 25 36
(7.3.14)
81 64 49
O maple também é capaz de resolver um sistemas de equação em forma de matriz. O comando é o
linsolve que encontra o vetor solução x do sistema A*x = b.
O b:=vector([14,12,46]);
b := 14 12 46
(7.3.15)
O linsolve(A,b);
1 2 3
(7.3.16)
8. Programação básica
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 frequentemente 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.
O Maple é uma linguagem interativa, porque ele permite que cada comando venha imediatamente
acompanhado de sua resposta. Isso não quer dizer que não seja possível agrupar uma série de
comandos, cuja resposta é dada por bloco. Na verdade, é isso que faz um programa. Estamos
chamando de ``uso interativo'', o modo comando-resposta que geralmente é empregado para resolver
problemas específicos. A título de exemplo, vamos resolver dois problemas simples usando o modo
interativo. A partir da solução particular, vamos transformá-la em um programa, que é capaz de
resolver o problema proposto e qualquer outro do mesmo tipo.
Um programa de Maple é essencialmente um grupo de comandos pré-definidos que o Maple sempre
executa em conjunto. O modo mais simples para criar um programa de Maple (ou procedimento) é
encapsular a sequência de comandos que seriam usados de modo interativo. Vamos inicialmente ver
os procedimentos iterativos.
Iterações (Renato Portugal)
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;
e
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.
O restart:
O for i to 5 do 2*i; od;
2
4
6
8
10
(8.1.1)
Na ausência do comando from, o valor inicial do contador é 1. Um forma quase equivalente do
mesmo comando é
O for i from 2 by 2 to 10 do i; od;
2
4
6
8
10
(8.1.2)
Segue um exemplo da segunda forma de executar iterações. Seja L uma lista de funções.
O L:=[exp(x^2),x^3,ln(x)];
2
L := ex , x3, ln x
Queremos calcular uma aproximação para integral definida de 1 a 2 dessas funções.
O for i in L do Int(i,x=1..2)=evalf(int(i,x=1..2)); od;
2
2
ex dx = 14.98997601
1
(8.1.3)
2
3
x dx = 3.750000000
1
2
ln x dx = 0.386294361
(8.1.4)
1
Note que o contador i no comando acima recebe funções como valor. Vejamos o valor final de i.
O i;
ln x
(8.1.5)
Considere o seguinte problema. Suponha que temos uma lista de funções na variável x.
O L := [ x^2, g(x), sin(x), a*exp(x^2)];
x2
2
L := x , g x , sin x , a e
(8.1.6)
Queremos construir a lista das derivadas. O próximo comando não resolve o problema.
O for i in L do diff(i,x); od;
2x
d
g x
dx
cos x
2
2 a x ex
(8.1.7)
A solução através do uso do comando de iteração requer primeiramente a inicialização de uma
lista nula.
O derivadas := [ ];
derivadas :=
(8.1.8)
Agora vem a iteração.
O for i in L do
O
derivadas := [ op(derivadas), diff(i, x) ];
O od:
Note que terminamos o comando for do od com dois pontos para que nada seja mostrado na tela.
Os comandos dentro da iteração podem terminar com dois pontos ou ponto e vírgula. Isso não
tem efeito algum em termos de mostrar resultados na tela. Vejamos o resultado.
O derivadas;
2
d
2 x,
g x , cos x , 2 a x ex
(8.1.9)
dx
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?
O for i from 808 by -1 while not isprime(i) do od;
O valor do contador contém a informação que desejamos:
O i;
797
(8.1.10)
Exceto o do od, todos os outras partes são opcionais. Vejamos um exemplo do comando while.
Suponha que N tem o valor 68.
O N := 68;
(8.1.11)
N := 68
(8.1.11)
Queremos dividir N por 2 enquanto N for par.
O while type(N,even) do N := N/2 od;
N := 34
N := 17
(8.1.12)
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.
O i:=0;
i := 0
(8.1.13)
O do
O
i:=i+1;
if i=2 then break fi;
O
O od;
i := 1
i := 2
(8.1.14)
A variável next por sua vez não interrompe a iteração, mas quando avaliada faz com que uma
volta seja pulada. Vamos imprimir os números ímpares da seguinte forma.
O for i to 10 do
if type(i,odd) then next fi;
O
O
print(i);
O od;
2
4
6
8
10
(8.1.15)
Existem três formas particulares do comando for que são seq, add e mul. A sintaxe 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
O add( a[i]*x^i, i=0..5 );
a0 Ca1 x Ca2 x2 Ca3 x3 Ca4 x4 Ca5 x5
(8.1.16)
O add( sin(i), i=[theta,omega,tau]);
sin θ Csin ω Csin τ
(8.1.17)
Procedimentos
Já vimos procedimentos que definem funções. Vamos examinar agora como dar um nome e
encapsular de forma eficiente uma sequência de comandos.
Vamos construir um procedimento, chamado plotdif que plota uma expressão f(x), junto com sua
derivada f '(x), no intervalo a, b . Interativamente podemos computar a derivada da função
utilizando diff e plotar as duas funções utilizando plot . Por exemplo:
O y:=x^3-4*x^2-3*x-4;
3
2
y := x K4 x K3 x K4
(8.2.1)
O dy:=diff(y,x);
2
(8.2.2)
dy := 3 x K8 x K3
O plot([y,dy],x=-2..7,color=[red,blue]);
120
100
80
60
40
20
K2
0
K1
1
2
3
4
x
K20
O seguinte procedimento combina a sequência de passos
1. Gráficos simultâneos
O plotdiff:=proc(y,x,a,b)
O
local dy;
O
dy:=diff(y,x);
5
6
7
O
plot([y,dy],x=a..b,color=[blue,black]);
O end;
plotdiff := proc y, x, a, b
(8.2.3)
local dy;
dy := diff y, x ; plot y, dy , x = a ..b, color = blue, black
end proc
O plotdiff(x*sin(x),x,-2,2);
1.5
1
0.5
K2
0
K1
1
x
2
K0.5
K1
Este procedimento pode agora ser utilizado em outras rotinas. A declaração local assegura que dy
é uma variável local, ou seja, este nome não terá qualquer atribuição fora do procedimento.
Vários dos comando iterativos apresentados na seção anterior podem ser reescritos na forma de
procedimentos.
Consideremos no próximo exemplo um procedimento que devolve o valor absoluto de um
número, que vamos chamar de ABS (para distinguir de abs, que já está definido pelo Maple)
2.Valor absoluto de um número
O ABS:=proc(x)
O
if x<0 then
O
-x;
O
else
O
x;
O
fi;
O end;
ABS := proc x if x ! 0 then Kx else x end if end proc
O ABS(-4.3);
O ABS(3);
(8.2.4)
4.3
(8.2.5)
3
(8.2.6)
O procedimento ABS não pode lidar com uma entrada não-numérica:
O ABS(a);
Error, (in ABS) cannot determine if this expression is true or false: a
< 0
Como o sistema não sabe nada sobre a, não sabe o que fazer com ele. Em tais casos o
procedimento deveria ser capaz de retornar a entrada não avaliada. Para obter isso notemos o
seguinte exemplo:
O 'ABS'(A);
ABS A
(8.2.7)
Estas aspas simples fazem com que a avaliação de ABS seja retardada. Portanto, podemos
modificar o procedimento ABS para a seguinte forma;
O ABS:=proc(x)
O
if type(x,numeric) then
O
if x<0 then -x else x fi;
O
else
O
'ABS'(x);
O
fi
O
end;
ABS := proc x
(8.2.8)
if type x, numeric then if x ! 0 then Kx else x end if else 'ABS' x end if
end proc
O ABS(a);
ABS a
3. Raízes de um polinômio
Vamos construir um procedimento que plota raízes reais e complexas de um polinômio
O raizplot:=proc(p::polynom(constant,x))
O
local R, points;
O
R:=[fsolve(p,x,complex)];
O
points:=map(z->[Re(z),Im(z)],R);
O
plot(points,style=point,symbol=circle);
O end;
(8.2.9)
(8.2.10)
raizplot := proc p:: polynom constant, x
(8.2.10)
local R, points;
R := fsolve p, x, complex ;
points := map z/ Re z , Im z , R ;
plot points, style = point, symbol = circle
end proc
O y:=x^8-3*x^4+4*x^3-x^2+x-5;
8
4
3
2
y := x K3 x C4 x Kx Cx K5
(8.2.11)
O raizplot(y);
1
0.5
K1.5
K1
0
K0.5
0.5
1
K0.5
K1
O comando randpoly gera um polinômio randômico:
O y:=randpoly(x,degree=120);
y := 87 x115 K56 x76 K62 x25 C97 x10 K73 x2
O raizplot(y);
(8.2.12)
1
0.5
K1
K0.5
0
0.5
1
K0.5
K1
9. Apêndice: Referências Básicas
Worksheets
Nos microcomputadores com o Maple instalado, a worksheet é disparada clicando-se no ícone do
programa. Em outros sistemas, ela é disparada pelo comando xmaple (ou maple) dado no sinal
de pronto do sistema operacional. Ela é o principal meio para gravar e ler os trabalhos
desenvolvidos no Maple.
A worksheet utiliza os recursos de janelas para facilitar interação do usuário com o Maple. Por
exemplo, um comando batido errado pode ser facilmente corrigido voltando-se o cursor para a
posição do erro e substituindo os caracteres errados. Não há necessidade de digitar todo o
comando novamente. Na worksheet, um usuário pode desenvolver a solução de um problema
usando o Maple, tecer comentários, colar gráficos e gravar todo o conjunto em um arquivo para
ser lido e eventualmente modificado posteriormente. A worksheet pode ser impressa
selecionando-se a opção print ou pode ser automaticamente convertida em um arquivo Latex. Um
exemplo de uso das worksheets é esse curso. Ele foi apresentado e as notas impressas a partir de
worksheets.
A worksheet é um caderno virtual de anotações de cálculos. A vantagem do caderno virtual é
que qualquer coisa já escrita pode ser modificada sem necessidade de fazer outras alterações. O
resto do trabalho se ajusta automaticamente às mudanças. Essa idéia é a mesma dos
processadores de textos que vêm gradativamente substituindo as máquinas de escrever. A
worksheet não é um processador de textos. Ela funciona de maneira satisfatória como um editor
de textos, e a parte referente ao processamento de textos pode ser feita no Latex, pois a worksheet
tem interface com este processador. No desenvolvimento de um trabalho usando a worksheet, é
importante que ele seja feito em ordem e que todo rascunho seja apagado assim que cumprido seu
objetivo. O comando restart pode encabeçar o trabalho. Depois de gravar a worksheet, o usuário
pode sair do Maple. No momento em que a worksheet é lida novamente, os resultados que
aparecem na tela não estão na memória ativa do Maple. É necessário processar os comandos
novamente para ativar os resultados.
A worksheet tem quatro tipos de linhas que são: as linhas de entrada de comando, geralmente
precedidas pelo sinal de pronto ``>'', as linhas de saída dos comandos, as linhas de texto e as
linhas de gráfico. Algumas dessas linhas podem ser convertidas umas nas outras. Em geral, as
linhas de entrada, de saída e de texto podem ser convertidas entre si. As versões de worksheet
para estações de trabalho e para microcomputadores não são iguais entre si, porém na grande
maioria dos casos, tudo o que um usuário faz na worksheet de uma estação de trabalho pode ser
feita na worksheet de um micro e vice-versa.
As linhas de saída usam os recursos gráficos das janelas para escrever as letras, os símbolos e
desenhar os gráficos. O sinal de integral aparece na tela como int, o somatório como sum e as
letras gregas como alpha, beta, gamma, ... . Existe uma opção que faz com que as linhas de saídas
usem os mesmos caracteres do teclado. Essa opção é útil para gravar resultados em um arquivo
ASCII (acrônimo de American Standard Code for Information Interchange). A worksheet pode
ser gravada com a terminação .mws, sendo ela própria é um arquivo ASCII. Isso significa que
ela pode ser enviada por correio eletrônico. É claro que a pessoa que recebe tem que editá-la e
retirar o cabeçalho do correio para que ela seja lida corretamente pelo Maple. Se a worksheet for
salva com o a terminação .m , ela é salva no formato interno do Maple.
A versão V Release 4 e 5 e a versão 6 possuem diversos recursos para escrever textos. É possível
criar seções e sub-seções. As letras podem ter diversos tamanhos e estilos, podem ser em itálico
ou em negrito. É possível criar hiperlinks que conectam diversas worksheets. A partir desses
hiperlinks pode-se navegar através das worksheets.
Na próxima seção faremos uma breve exposição sobre a manipulação de worksheets.
Noções básicas sobre a manipulação de worksheets
O ambiente de worksheet do Maple consiste em um conjunto de construtos de documentação:
grupos de execução, spreadsheets (planilhas), parágrafos, seções e hyperlinks.
Grupos de execução e spreadsheets ajudam o usuário a interagir com a máquina computacional
do Maple. Eles fornecem os meios primários pelos quais o Maple é requisitado para executar
tarefas específicas e mostrar os resultados.
Parágrafos, seções e hyperlinks existem para ajudar o usuário a documentar e organizar os
resultados.
Interagindo com Maple
Grupos de execução
Sequencias de comandos de Maple, chamadas grupos de execução, servem para dar uma
descrição algorítmica de como um particular problema matemático é resolvido. Os grupos
de execução dão os elementos fundamentais de computação da worksheet. Seu objetivo
primário é combinar um ou mais comandos de Maple e seus resultados em uma única
unidade reexecutável. Ele é fácilmente reconhecível pelo grande colchete imediatamente à
esquerda do prompt de comando. Um grupo de execução é criado através do menu insert .
Exemplo1. Quando o cursor é colocado em qualquer ponto do grupo de execução, e o
comando enter é dado, as as operações evidentes na expressão de entrada abaixo são
realizadas em sequencia e o resultado é apresentado no final :
O restart:
O y:=expand((x+4*a)^2-(x+4*a)^3+x^3);
y := x2 C8 x a C16 a2 K12 x2 a K48 x a2 K64 a3
(9.2.1.1.1)
O cursor é levado automaticamente para uma nova linha de comando em outro grupo de
execução. Note que para modificar os polinômios envolvidos na expressão acima, basta
levar o cursor novamente à linha de comando no grupo de execução, fazer as modificações
e dar enter.
Exercício1. Modifique o lado direito da expressão anterior.
Exemplo2. Um grupo de execução pode conter vários comandos, na mesma ou em
diferentes linhas de comando:
O y:=diff(sin(x)^x,x); z:=int(sin(x)^2,x);
O plot(y+z,x=1..3);
x cos x
y := sin x x ln sin x C
sin x
z := K
1
1
sin x cos x C
x
2
2
1.4
1.2
1.0
0.8
0.6
0.4
0.2
1
1.5
2
x
2.5
3
Exercício2. (a) Volte ao Exemplo1 e faça um gráfico y(x), para algum valor específico de
do parâmetro a, utilizando o prompt em aberto. Não esqueça de definir y novamente no
grupo de execução anterior, casa contrário a expressão para y será aquela definida no
Exemplo 2. (b) Coloque estes dois comandos em um mesmo grupo de execução utilizando
a opção join execution groups (ou F4) no menu Edit.
Spreadsheets
Spreadsheets ou planilhas similares às do Excell são disponíveis nas versões W98, NT e
Macintosh do Maple. Uma planilha simbólica pode ser criada através do menu insert. Ela
vai aparecer dentro de um grupo de execução. Como exemplo vamos construir uma tabela
x
para integrais envolvendo e .
Exercício 3. Reconstrua a planilha acima.
As fórmulas nas células podem ser transportadas para linhas de comando da worksheet
através de copy/paste e vice versa.
Construindo e executando comandos
Há três modos básicos para criar comandos e resultados em Maple
Comandos digitados e paletas
Linhas de comando vazias podem ser criadas inserindo um grupo de execução
(utilizando o menu insert ou o símbolo [> no menu de ferramentas). Os comandos são
executados escrevendo-os no prompt do Maple e pressionando enter. Algumas
operações e símbolos, assim como matrizes, podem ser introduzidos através de três
paletas. Elas podem ser ativadas a partir do menu View/Palletes.
Exercício 4. Utilize o comando inverse(A) do Maple para inverter a matriz
4 5 0
K1 3 5
.
9 6 6
Nota: Para que esta operação seja possível é necessário carregar antes o pacote de
álgebra linear linalg, o que pode ser feito com o comando with(linalg) .
Utilizando menus de contexto
Resultados de Maple já existentes podem ser utilizados para sugerir e construir novas
ações. Para obter na tela uma lista de ações sugeridas, marque e pressione o botão
direito do mouse sobre o objeto (um resultado). A lista de ações resultante é chamada
um menu de contexto, e está customizada para refletir as propriedades do objeto
selecionado.
Exercício 5. Reproduza em uma worksheet separada o procedimento abaixo. No caso
selecionamos a segunda solução e, escolhendo a opção copy transformamos-la para o
formato de entrada (paste). O nome s1 foi adicionado manualmente.
O solve(a*x^2-3*x+a,x);
1 3C
2
9 K4 a2
1 K3 C 9 K4 a2
,K
a
2
a
(9.2.1.3.2.1)
O s1:=1/2*(2-2*sqrt(1-a^2))/a;
s1 :=
1 2 K2 1 Ka2
2
a
(9.2.1.3.2.2)
Exercício 6.
(a) Considere resultado do primeiro grupo de execução do Exercício 5. Utilize o menu
de contexto para determinar a integral das duas soluções com relação a a. Faça com
elas tenham respectivamente os nomes int1 e int2.
(b) Considere o resultado do segundo grupo de execução acima. Utilize o menu de
contexto para converter a igualdade para o formato LaTex (neste caso, em que a
expressão aparece sozinha, não é necessário marcar a expressão).
Exercício 7. Utilize o menu de contexto para obter o gráfico da função y = sin x z .
Dragging e Dropping
O restart:
Fórmulas podem ser transportadas entre linhas de comando de qualquer worksheet
diretamente por seleção e arraste. Uma expressão no formato de saída pode ser
convertida para o formato de entrada simplesmente selecionando a expressão e
arrastando-a para uma linha de comando vazia. .Gráficos simultâneos podem ser
construídos arrastando-se a expressão no formato de se saída do Maple até o ambiente
gráfico existente, anteriormente criado via smartplots.
Exercício 8. Selecione o lado esquerdo da expressão que define s1, no formato de
saída, no Exercício 5 e arraste-o até uma linha de comando vazia. Repita o mesmo
procedimento selecionando agora a expressão inteira. Qual a diferença ?
v
cos x2 Cz .
Exercício 9a. Utilize o menu de contexto para gerar o gráfico de y :=
vx
(Arraste a expressão acima para uma worksheet e depois a recupere com undo). Em
seguida arraste o gráfico para uma linha vazia sem o prompt. Modifique a expressão e
arraste de volta a expressão para o ambiente gráfico. Este procedimento só funciona
para smartplots 3D.
Exercício 9b. Gere gráficos simultâneos em 2D utilizando arraste .Este procedimento
só funciona com smartplots.
Organizando documentos
Documentos consistem de uma sequencia de parágrafos descritivos, grupos de execução,
spreadsheets e gráficos. Estes componentes podem ser reorganizados em uma estrutura
hierárquica baseada em seções de subseções. Marcadores de referências, chamados
bookmarks, podem ser colocados ao longo do documento e hyperlinks podem ser usados para
saltar de um lugar a outro dentro de um documento. Trataremos esses tópicos com detalhe a
seguir
3.2.1 Parágrafos e texto
Um parágrafo em uma worksheet é análogo ao parágrafo encontrado em um típico
processador de textos. Parágrafos podem conter texto com estilos particulares, modo
matemático e gráficos, incluindo cópias de saídas de Maple. Um parágrafo pode estar
contido em um grupo de execução . Parágrafos podem ser criados clicando Insert na
barra de menus. O estilo dos parágrafos pode ser personalizado escolhendo Styles, do menu
Format. Estilos em trechos selecionados podem escolhidos na barra de contexto. Dentro
das áreas de texto é possível inserir equações formatadas e gráficos.
Exemplo 2. É possível escrever:
β
2
ex dx em Maple, digite:
Para calcular a integral definida simbólica
0
> int(exp(x^2),x = 0 .. beta);
O modo matemático pode ser acionado escolhendo-se Maple input (Crtl+M) no menu
Insert. Temos aqui algumas diferenças importantes nas duas últimas versões de Maple.
Maple V:
Note que a equação é digitada de acordo com a sintaxe do Maple, em um campo dentro da
barra de contexto. A expressão formatada aparecerá depois de enter . Para voltar ao modo
texto escolhe-se Text input (Crtl+T). Caso o usuário preferir, é possível digitar a expressão
desejada numa linha de comando, convertê-la para o modo matemático escolhendo x na
barra de contexto. A expressão pode então ser selecionada e arrastada ou copiada para o
local desejado do texto. É possivel também arrastar a expressão diretamente no formato de
entrada do Maple para um local onde o modo matemático já esteja acionado dentro do texto
(Crt-M).
Maple 6:
Note no menu Insert, que para reproduzir os resultados descritos no parágrafo anterior,
deveríamos selecionar Standard Math ou Crt-R, para criar uma entrada em modo
matemático dentro do texto. No entanto, o procedimento mais simples neste caso para
digitar uma equação é utilizar Maple Input ou Crt-M, que faz com que a equação apareça
no formato de entrada do Maple no próprio texto, em vermelho. Em seguida a expressão
pode ser convertida para o formato matemático clicando em x à esquerda na barra de
contexto. Como no caso do Maple V, os modos de entrada ou saída podem ser alternados
clicando-se no maple verde. Ou seja, os caracteres em vermelho são de entrada, não
importando o formato (Maple input ou Standard Math input), são executáveis clicando-se
em ! na barra de contexto.
Exercício 10. Reproduza o Exemplo 2.
3.2.2 Seções
O que você acabou de expandir agora é uma seção (section). No menu Insert, a escolha de
Section abre outra seção. Subsection abre uma subseção dentro desta. Para transformar
uma seção num parágrafo simples, no menu Format escolha Outdent. Use Indent para
inserir um dado parágrafo dentro da seção
Exercício 11. Reproduza os cabeçalhos desta worksheet. Inclua subseções.
Exercício 12. Expanda e colapse todas as seções desta worksheet através do menu View.
3.2.3 Hyperlinks
Um hyperlink é uma pedaço de texto que faz uma conexão, quando você dá um clic sobre
ele, para uma outra parte da mesma worksheet, de outra worksheet ou de uma página de
ajuda, sendo portanto uma ferramenta de navegação. Por default, Maple mostra os
hyperlinks como um texto sublinhado na cor cyan. Por exemplo, clicando aqui o cursor é
levado para seção 2.1.2 sobre spreadsheets. Selecionando um nome de bookmark leva o
cursor a um ponto especificado da worksheet.
Um pré-requisito para hyperlinks são bookmarks. Um bookmark é um nome que identifica
uma particular localização na worksheet. Podemos acessar uma lista de bookmarks da
worksheet corrente selecionando Bookmarks no menu View. A seleção de um nome de
bookmark move o cursor a uma posição especificada da worksheet. Um hyperlink deve
estar associado a um nome de bookmark. Por exemplo, vamos supor que queremos fazer
um hyperlink para a seção 2.2.1. O primeiro passo é definir o bookmark. Para isso devemos
levar o cursor para a linha da seção 2.2.1 desta worksheet, selecion Bookmarks no menu
View e selecionar Edit Bookmark. Um nome adequado deve então ser digitado. Em
seguida devemos inserir o texto que deve aparecer no hyperlink. No menu Insert
selecionamos Hyperlink, digitamos o texto e escolhemos da lista o nome adequado entre
todos os bookmarks.
Exercício 13. Faça um hyperlink para alguma seção desta worksheet.
Regras de sobrevivência
Esta seção oferece dicas sobre como evitar alguns enganos aos quais inciantes estão sujeitos a
cometer. Mesmo para aqueles que já utilizaram o Maple mais de uma vez, ler este seção será de
alguma utilidade. Ela poderá parecer um pouco redundante mas, por outro lado, vai poupar
esforços na tentativa de encontrar erros de sintaxe futuramente. Os problemas aqui descritos serão
vistos nos capítulos seguintes, porém estarão inseridos em contextos diferentes que vão supor que
o leitor já os conheça.
Os comandos do Maple normalmente terminam com um ponto-e-vírgula (;) seguido da tecla
[Enter]. Com isso o Maple avalia a entrada, faz o cálculo e imprime o resultado na tela. Ao invés
de usar o ponto-e-vírgula, pode ser usado os dois pontos (:) no final do comando. Neste caso, o
cálculo é feito como anteriormente, mas o resultado não é colocado na tela. Seu uso previne que
comandos executados como passos intermediários de um estudo não ocupem muitas páginas com
fórmulas de pouco interesse em relação ao resultado final.
Pode-se colocar alguns comandos na mesma linha. Estes comandos podem ser separados tanto por
ponto-e-vírgula (;) como dois-pontos (:). É possível separar os cálculos com vírgulas (,) sem que
se faça associações à variável. O Maple executa os cálculos um após o outro e coloca os
resultados lado a lado. Para resultados curtos, este método possue a vantagem de economizar
espaço na tela e permite a comparação de resultados numa mesma linha.
Por exemplo:
O 2+3;
O a:=3; b:=5;
O a*b, a+b, a^b;
O a*b; a+b; a^b;
5
(9.3.1)
a := 3
b := 5
(9.3.2)
15, 8, 243
(9.3.3)
15
8
243
(9.3.4)
O resultado de até três cálculos anteriores podem ser acessados pelos comandos %, %% e %%%.
Se após o um cálculo, você mover o cursor para uma posição diferente na worksheet, o símbolo
de percentagem não irá se refrir ao comando exatamente acima e sim ao último cálculo executado.
O (c+d)^3: % = expand (%);
c Cd 3 = c3 C3 c2 d C3 c d2 Cd3
(9.3.5)
A expressão anterior mostra uma expansão do cubo da soma de duas variáveis. O primeiro
comando apenas formula a expressão a ser expandida e não imprime o resultado na tela. No
segundo comando o resultado é acessado duas vezes, primeiro sem expandir e depois expandindo.
É preciso tomar cuidado ao usar os símbolos de percentagem. Para pessoas poucou familiarizadas
com estes operadores é aconselhável associar o resultado obtido à uma variável. Desta forma a
variável pode ser acessada posteriormente quantas vezes quiser e não apenas três.
No exemplo a seguir é mostrado duas formas de ser fazer a associação das soluções de uma
equação do segundo grau a uma variável:
O solve(x^2+x-1,x);
K
1
1
C
2
2
O solucoes1:=%;
5,K
1
1
K
2
2
(9.3.6)
5
1
1
C
2
2
5,K
1
1
K
2
2
5
(9.3.7)
O solucoes2:=solve(x^2+x-1,x);
1
1
solucoes2 := K C
2
2
5,K
1
1
K
2
2
5
(9.3.8)
solucoes1 := K
A manipulação de uma parte do resultado fica mais fácil ao associá-lo a uma variável. Esta
necessidade ocorre frequentemente em comandos como o solve que retorna mais de uma solucao.
Um meio de acessar os elementos do resultado é colocando o índice da solução desejada entre
colchetes ([]).
O x1:=solucoes1[1];
1
1
x1 := K C
5
(9.3.9)
2
2
A princípio esta é uma forma aparentemente boa, porém pode dar problemas depois: a ordem das
soluções retornadas pelo comando solve não é fixa. Portanto executando o comando novamente,
pode ser que a ordem venha trocada. Neste caso se tivermos interesse, por exemplo, na solução de
menor valor, poderíamos usar o comando min. Para isto todas as variáveis da expressão deverão
estar definidas.
O x1:=min(solucoes1);
1
1
x1 := K K
5
(9.3.10)
2
2
O Maple VR5 e 6 distingue as aspas duplas (") das aspas simples (') do plique (`) - ou acento
grave. O primeiro serve para representar strings de caracteres. O segundo é usado para retardar
uma avaliação matemática e o terceiro
também representa strings porém de utilidade diversificada em relação ao primeiro.
O Maple avalia expressões matemáticas automaticamente:
O x:=Pi;
x := π
(9.3.11)
O sin(x/2);
1
(9.3.12)
Neste exemplo, a variável x foi imediatamente substituída pelo seu valor. Algumas vezes não é
desejado que isto aconteça. As aspas simples servem para impedir que esta avaliação se efetue. E
neste caso pode ser feito de duas formas: retardando a avaliação de x ou de toda a expressão sin
(x):
O expr1:=sin('x'/2);expr2:='sin(x/2)';
1
expr1 := sin
x
2
(9.3.13)
expr2 := sin
1
x
2
(9.3.13)
Nos cálculos subsequentes a avaliação será efetuada e o valor da variável será subtituído.
O expr1; expr2;
1
1
(9.3.14)
Pode-se colocar quantos níveis de retardo se desejar porém não é comum utilizar mais de um.
Seria mais simples limpar o conteúdo da variável x em vez de colocar várias aspas simples juntas.
O ''x'';
'x'
(9.3.15)
O %;
x
(9.3.16)
π
(9.3.17)
O %;
À primeira vista, a função do plique pode parecer igual às aspas simples.
O 'x+1';
x C1
O `x+1`;
xC1
Porém só quando forçamos uma avaliação é que percebemos a diferença.
O eval('x+1');
π C1
O eval(`x+1`);
xC1
(9.3.18)
(9.3.19)
(9.3.20)
(9.3.21)
Os caracteres contidos entre pliques não são interpretados como expressões matemáticas, mas
como um conjunto de caracteres. A avaliação não só não é retardada, como se torna impossível.
Os pliques são normalmente usados para criar nomes de variáveis que usem caracteres especiais.
O `x/aux`:=3;
x/aux := 3
(9.3.22)
As aspas duplas, enfim, determinam um conjunto de caracteres associados a um texto tal como o
título de um gráfico, uma mensagem a ser impressa na tela ou o nome de um arquivo no qual se
deseja gravar algum resultado.
O print(`Mensagem na tela!`);
Mensagem na tela!
(9.3.23)
Alguns problemas frequentemente ocorrem por causa de variáveis que foram inicializadas e foram
usadas em expressões posteriormente. Ao tentarmos resolver uma equação em x ocorre o seguinte
problema.
O solve(x^2-2*x,x);
Error, (in solve) a constant is invalid as a variable, Pi
Se olharmos algumas páginas antes vamos perceber que a variável x recebeu o valor π. Em
nenhum momento esta variável teve o seu conteúdo apagado e, consequentemente, ele se mantém.
Uma forma de limpar o conteúdo de uma variável é associar esta variável a ela mesma com um
nível de retardo. Se preferir apagar o conteúdo de todas as variáveis usadas até o momento, o
comanto restart executa esta tarefa.
O x:='x';
x := x
(9.3.24)
Ou equivalentemente:
O unassign('x');
Agora podemos resolver a equação em x.
O solve(x^2-2*x,x);
0, 2
(9.3.25)
O
Cartão de referência de comandos
denom( )
display( )
evalf(expr)
evalf(expr,n)
expand(expr)
factor(expr)
fsolve(eqn)
Selects the denominator of a fraction
Combines graphs of functions and points (require with( plots) )
Numercially evaluates the given expression to the default number of digits (10).
Numercially evaluates the given expression to n digits
Expands the given expression
Factors the given expression
Finds numerical (approximate) solutions to equations.
fsolve(x^2=cos(x)+4,x=0..5)
ifactor(n)
Gives prime integer factorization for a given integer
lhs(eqn )
Selects the left hand side of an equation
implicitplot( )
Plots implicitly defined functions
implicitplot(x^2/25 +y^2/9=1 , x=-5 . . 5,y=-5 . . 5,scaling=constrained);
numer( )
Selects the numerator of a fraction
plot( )
Plots functions defined by an algebraic expression:
plot(3*x^2-8 , x=-5 . . 5 , y = -20 . . 40 );
Plots more than one function at a time:
plot( [ 3*x^2-8 , sin(x) , cos(x) ] ,x=-5 . . 5 , y=-20 .. 40 );
Plots points:
plot 2, 3 , K2, 5 , 1, K4 , x = K7 ..7, y = K7 ..7, style = point
Plots parametric equations :
plot( [cos(t), sin(t), t=0 . . 2*Pi] , x=-2..2, y=-2..2);
rationalize(expr) Rationalizes the denominator of a given expression
restart
Clears Maple's memory of all definitions
rhs(eqn )
Selects the right hand side of an equation
simplify(expr)
Simplifies the given expression
solve(eqn)
Finds exact solutions to equations, including literal equations and linear
systems.
subs(x= v,expr) Substitutes the value v for x in the expression
subs(x=4,3*x^2+8);
with( )
Brings in additional libraries of functions.
The standard constants are:
Pi
π
Caution: Do not use "pi", capital "P" is required
exp(1) e
I
K1
The names of the standard functions are:
sqrt(x) x
abs(x) x
exp(x) ex
ln(x) natural log
log(x) common log (base 10)
sin(x), cos(x), tan(x), cot(x), sec(x), csc(x)
arcsin(x), arccos(x), arctan(x)
sine of x, etc.
the inverse trig functions