MUPAD LIGHT
TUTORIAL
Ricardo Miranda Martins
[email protected]
MuPAD Tutorial
ÍNDICE
INTRODUÇÃO
3
INTERFACE, ENTRADA E SAÍDA DE COMANDOS
4
ARITMÉTICA
6
NÚMEROS COMPLEXOS
8
ÁLGEBRA BÁSICA
8
CONJUNTOS
12
FUNÇÕES
12
GRÁFICOS DE FUNÇÕES
13
CÁLCULO DIFERENCIAL E INTEGRAL
17
ÁLGEBRA LINEAR
19
SISTEMAS LINEARES E OTIMIZAÇÃO
22
O COMANDO PLOT
24
ANIMAÇÕES
28
BIBLIOGRAFIA
36
2
MuPAD Tutorial
INTRODUÇÃO
Dentre as ferramentas computacionais que podem ser utilizadas para se resolver um
determinado problema, existem aquelas puramente numéricas, que utilizam algoritmos bem
conhecidos para encontrar as soluções, e existem aquelas algébricas. A principal diferença entre elas
é a exatidão da resposta: na computação numérica os dados (números) são armazenados como
números reais, e como a capacidade de memória dos computadores é limitada, os arredondamentos
acabam afetando a precisão da resposta. Já na computação simbólica, como os dados são
armazenados como frações e manipulados algebricamente, a precisão da resposta é total. Outra
vantagem da computação simbólica é a possibilidade de resolução de problemas literais, ou seja,
manipulando as letras ao invés dos números.
O MuPAD (Multi-Processing Algebra Data Tool) é um sistema de computação algébrica
(C.A.S. – Computer Algebra System) interativo, desenvolvido à partir de 1990 na Universidade de
Paderborn (Alemanha) com todos os recursos dos principais softwares comerciais nesta área, como o
Mathematica e o Maple. No MUPAD é possível solucionar praticamente todos os tipos de problemas
de matemática, fazer gráficos de funções em 2D e 3D, resolver equações e inequações (sejam lineares
ou nao), derivar, integrar, operar matrizes e até fazer animações.
O MuPAD pode ser copiado no site http://www.mupad.de, que é o site do fabricante. Existem
versões para Windows, Linux e MAC. Para Linux, a versão completa é livre, e para Windows e MAC
existem versões de demonstração (MuPAD Light) com uso restrito de memória, restrição esta que
pode ser removida com o registro (gratuito) do programa. Outra restrição da versão Light é a
impossibilidade de editar uma linha de comando já interpretada. Assim, é necessário copiar-colar os
comandos para alterá-los. Ainda, só é possível salvar o arquivo de trabalho em formato texto. A
versão em que este tutorial se baseia é a Light 2.5.2.
Este trabalho é parte de um projeto de Iniciação Científica do Programa Institucional de
Bolsas de Iniciação Cietífica – PIBIC/UFV, financiado pelo CNPq.
Ricardo Miranda Martins
Viçosa, 2004
3
MuPAD Tutorial
INTERFACE, ENTRADA E SAÍDA DE COMANDOS
Ao ser iniciado, o MuPAD fica pronto para receber instruções. Sua janela é bem simples, com
um espaço para digitação de comandos e apresentação de resultados e alguns poucos botões e menus.
Abaixo segue uma descrição dos menus e botões na interface do MuPAD.
File
Save as Salva o conteúdo
atual da planilha
Print
Imprime a
planilha atual
Print
Visualiza a
Preview impressão
Edit
Undo
Print
Setup
Configura a
impressão
Paste
Exit
Fecha o MuPAD
Delete
All
Session
Evaluate
Pretty Print
Text width
Stop Kernel
Recortar
Copiar
Colar
Cut
Copy
Desfaz o último
comando
Recorta a seleção
atual
Copia a seleção
atual
Status
bar
Options
Cola o conteúdo
da área de
transferência
Apaga toda a
planilha atual
Executa linha
de comando
atual
Alterna o modo
de apresentar
os resultados
Configura o
tamanho do
texto
Força a parada
do comando
atual
Imprimir
View
Toolbar
Help
Browse Manual
Open tutorial
Mostra/Oculta os
ícones
Mostra/Oculta a
barra de status
Opções de fonte e
caminho de
bibliotecas
Procura algo o
sistema de
ajuda
Abre o tutorial
interno
Help topics
Mostra os
tópicos da ajuda
Register
Registra o
MuPAD Light
About ...
Informações
sobre o MuPAD
Executar linha
Parar computação
Iniciar Tutorial interno
Procurar na ajuda
A entrada de comandos é bem intuitiva, e as operações aritméticas são realizadas do modo
usual. O modo de se usar uma função é bem parecido com o que é feito manualmente. Cuidado! O
MuPAD diferencia maiúsculas de minúsculas, e a maioria de suas funções são em letras minúsculas.
Assim, cos(x) é diferente de Cos(x) ou de cos(X).
4
MuPAD Tutorial
Veja um exemplo:
Na figura acima, o primeiro comando é um comando aritmético normal. O símbolo * é usado
para a multiplicação. Para divisão, usamos / e para potência, ^, por exemplo, para calcularmos 23
devemos digitar no MuPAD: 2^3 [ENTER]. Na interface do MuPAD, os textos em vermelho
denotam entrada de comandos, e em azul, a resposta.
Na segunda linha da figura, o MuPAD é instruído a calcular o valor da função cosseno no
ponto 1,5 (os valores devem ser em radianos e o separador de decimais é o ponto, e não a vírgula).
A maioria dos comandos no MuPAD segue a sintaxe (sintaxe é o “modo” de usar o comando)
da função cosseno, ou seja para calcularmos o valor da função f no ponto x, devemos digitar f(x).
Veja um exemplo: se quisermos que o MuPAD faça o gráfico da função cos(x), devemos usar
a função plotfunc2d, que, como o nome já diz, “plota” (desenha) funções em duas dimensões. A
sintaxe da função plotfunc2d é a seguinte: plotfunc2d( f(x), x=a..b), onde f e g são funções e a..b é
o intervalo que queremos do gráfico. No MuPAD, ficaria assim:
O resultado aparecerá numa nova janela:
5
MuPAD Tutorial
O sistema de ajuda do MuPAD é bem completo, assim, se tivermos qualquer dúvida, podemos
usar os seguintes comandos:
F2: Ativa o sistema de ajuda
>> info(comando): Mostra informações sobre “comando”
>> ?comando: Mostra ajuda sobre “comando”
Um importante comando é o reset(). Ele reinicia todo o sistema do MuPAD, e deve ser usado
sempre que se desejar liberar memória ou apagar as variáveis setadas.
ARITMÉTICA
O MuPAD tem vários recursos para se trabalhar somente com números.
Os comandos abaixo estarão todos comentados. Os comentários começam e terminam com
um sinal #. No MuPAD, todo o texto escrito entre #’s não é executado. É possível entrar vários
comandos numa única linha, bastante separa-los com um ponto-e-vírgula (;), e a ordem da resposta
será a mesma ordem da entrada dos comandos. Os comandos podem ainda ser separados por dois
pontos (:), porém, seu resultado não será mostrado. Neste tutorial, o prompt do MuPAD (a bolinha
vermelha) será substituída pelo sinal “>>” para simplificar a notação. Então, a linha:
>> log(2,8); #Calcula o log de 8 na base 2#
3
ficaria no MuPAD:
Agora, as operações aritméticas básicas:
>> 2+3; #Soma#
5
>> 2*3; #Multiplicação#
6
>> 6/2; #Divisão#
3
>> sqrt(9); #Raiz quadrada de 9#
3
6
MuPAD Tutorial
Algumas vezes, quando uma divisão não for exata, a resposta será dada na forma de fração. O
mesmo acontece para extração de raiz não exata e em alguns outros casos. Para forçá- lo a exprimir a
resposta como um número real, o comando é float. Por exemplo:
>> 3/2
3/2
>> float(3/2)
1.5
>> sqrt(6)
1/2
6
>> float(sqrt(6))
2.449489743
Para evitar o uso do comando float, basta digitar o número com casas decimais. Por exemplo:
>> 2.0^(1/3)
1.25992105
O valor das famosas constantes matemáticas Pi e “e” (Número de Euler) aparece no MuPAD
com uma precisão tão grande quanto se queira (ou quanto a memória do computador permitir). O uso
destas constantes é como usual, ou seja:
>> float(PI)
3.141592654
>> float(E)
2.718281828
Caso seja necessário usar o resultado do último cálculo, é possível usar o símbolo %. Seu uso
é simples, como no exemplo abaixo:
>> PI*E^2; # O MuPAD não irá retornar o valor desta expressão.
2
PI exp(1)
>> float(%);# Usando float sem reescrever toda a expressão anterior#
23.21340436
Outra “constante” existente no MuPAD é a infinity. Ela representa “o infinito”, ou seja, um
número muito grande. É possível operar com infinity:
>> 1-infinity
-infinity
>> infinity/infinity; # Cuidado! Isso não vale 1!#
undefined
Em alguns cálculos envolvendo o infinito o MuPAD calcula o limite para exibir o resultado:
>> 1/infinity
0
7
MuPAD Tutorial
Existem funções específicas para lidar com aritmética. Abaixo seguem algumas delas:
>> abs(-2); # Retorna o módulo de um número#
2
>> round(1.51); #Arredondamento padrão, para o inteiro mais próximo#
2
>> ifactor(338272); # Fatora em primos um dado inteiro#
5
2
2 11 31
>> isprime(1001); isprime(3847); #Verifica se um número é primo#
false
>> 23 mod 5; #Retorna o resto da divisão do primeiro parâmetro pelo
segundo#
3
>> 23 div 5; #Retorna o quociente na divisão do primeiro parâmetro pelo
segundo#
4
NÚMEROS COMPLEXOS
A unidade imaginária i, no MuPAD, é representada como I (i maiú sculo). Um número
complexo, ou seja, um número do tipo a+bi, onde i= -1. No MuPAD eles são definidos da mesma
forma, e é possível operá- los e explorar suas propriedades.da mesma forma que os números reais.
>> x:=2*I+1: #Define o número complexo x#
>> y:=3*I-5: #Define o número complexo y#
>> x+y; x*y; #Algumas operações#
- 4 + 5 I
- 11 - 7 I
>> x^3; #Potenciação de um número complexo#
- 11 - 2 I
>> x/y; #Divisão entre complexos#
1/34 - 13/34 I
>> abs(x); #Retorna a norma de x#
1/2
5
>> Re(x); #Parte real de x#; Im(x); #Parte imaginária de x#
1
2
>> 1/x; #Inverso de x#
1/5 - 2/5 I
ÁLGEBRA BÁSICA
Como um Sistema de Computação Algébrica, o MuPAD mostra sua força quando tratamos de
problemas onde é necessária a manipulação algébrica de expressões. Ao contrário de calculadoras
não-programáveis (como as HP 48 / 49), o MuPAD pode reconhecer e operar objetos tais como
polinômios, funções, matrizes, entre outros. Inicialmente lidaremos com polinômios em uma variável.
8
MuPAD Tutorial
Os polinômios são digitados da forma natural, ou seja, com x denotando a indeterminada
(variável) e os coeficientes numéricos. Ao trabalhar com polinômios, é sempre bom armazenar os
polinômios em variáveis, ou seja:
>> p:=x^2+4*x+2
2
4 x + x + 2
O comando solve é o comando universal para se obter “soluções”. O MuPAD analisa o objeto
que se deseja “resolver” e decide qual método utilizar. Assim, ele é usado para resolver quase tudo no
MuPAD. Abaixo, alguns exemplos do uso do solve para as mais variadas aplicações.
O comando solve em polinômios:
>> solve(18*x^2-27*x+26*x^3+9*x^4+x^5-27 , x); # Resolve o polinômio em
relação à variável x, ou seja, encontra as raízes do polinômio#
{-3, -1, 1}
Para alguns polinômios de grau maior que 5, é impossível exprimir suas raízes em termos de
radicais, então o MuPAD mostrará uma resposta parecida com o caso abaixo:
>> solve(x^6+x^2+x^3+x,x)
2
{-1, 0} union RootOf(X2
3
4
- X2 + X2 + 1, X2)
O que a resposta acima diz é o seguinte: as raízes de x^6+2^x+x^3+x são –1, 0, além da s
raízes do polinômio x^2-x^3+x^4+1. Mas quais são estas raízes? Elas podem ser obtidas
(numericamente) usando o comando float.
>> float(%)
{-1.0, 0.0} union {- 0.3518079518 + 0.7203417364 I,
- 0.3518079518 - 0.7203417364 I, 0.8518079518 - 0.911292162
0.8518079518 + 0.911292162 I}
I,
>> q:=x^3-9*x
3
x
- 9 x
>> solve(q); #Encontra as raízes do polinômio q#
{[x = 0], [x = -3], [x = 3]}
O comando solve em sistemas de equações polinomiais:
>> equacoes:={ x+y=3, 2*x-y=7}; #Equações lineares#
{x + y = 3, 2 x - y = 7}
>> solve(equacoes)
{[x = 10/3, y = -1/3]}
>> eq:={x^2-y=7, x+y^2=1}; #Agora com equações não-lineares#
2
2
{x + y = 1, x - y = 7}
>> solve(eq)
{[x = -3, y = 2]}
9
MuPAD Tutorial
O comando solve para equações transcendentes:
>> solve(sin(x)=1/2)
x in { 1/6*PI + 2*PI*X41 |
in Z_ }
X41 in Z_ } union
{ 5/6*PI + 2*PI*X42 |
X42
A resposta do comando acima (união de dois conjuntos), é esperada, pois sendo a função seno
periódica, existem infinitos valores de x para os quais sen(x) = 1/2.
O comando solve para inequações:
>> solve(x^2-2*x+4<0)
{}
>> solve(x^2-2*x+4>0)
x in R_
2
2
(Note que x - 2x + 4 = (x - 2) , que nunca é menor que zero.)
>> solve(x^2-5*x+6>0)
x in ]-infinity, 2[ union ]3, infinity[
A resposta, na forma de intervalo, quer dizer x pertence a ( , 2) U (3,
).
Abaixo seguem alguns comandos úteis para trabalhar com polinômios.
>> p:=x^2+4*x+2: q:=x^3+4:
>> factor(p+2); #Fatora polinômios#
2
(x+2)
>> factor(q-5)
2
(x - 1) (x + x + 1)
>> expand(p*q); # Expande um polinômio#
2
3
4
5
16 x + 4 x + 2 x + 4 x + x + 8
Para dividir dois polinômios, o comando é divide(f,g), e ele retorna o quociente e o resto da
divisão do polinômio f pelo g.
>> divide(p,q)
2
0, 4 x + x + 2
O que deu errado? Nada. Veja que o grau de p é maior que o grau de q. Assim, o quociente da
divisão é 0 e o resto é o próprio p. Se invertermos:
>> divide(q,p)
x – 4, 14x + 12
Para obter somente o quociente e/ou o resto de uma divisão, podemos fazer como abaixo:
>> divide(q,p, Quo); #Retorna o quociente da divisão#
x - 4
>> divide(q,p, Rem); #Retorna o resto (Remainder) da divisão#
14 x + 12
10
MuPAD Tutorial
Para resolvermos uma equação polinomial, o comando é novamente o solve:
>> solve(p = 30)
1/2
1/2
{[x = - 4 2
- 2], [x = 4 2
- 2]}
Cuidado! A resposta acima deve ser lida como “x = -4√2 –2 ou x = 4√2 –2”.
Algumas expressões são simplificadas de uma forma bem inteligente pelo MuPAD:
>> a:=cos(x)^2+sin(x)^2: # “sin” (sine) é a função seno#
>> simplify(a)
1
>> b:=(x^2-1)/(x+1)-(x-1):
>>simplify(b);
0
Cálculos envolvendo somatórios e produtórios também são possível no MuPAD, com o uso
dos comandos sum e product. Veja abaixo:
>> sum(x, x=1..10); #Soma x, com x indo de 1 até 10, ou seja:
1+2+3+4+...+9+10#
55
Ainda é possível usar expressões mais complicadas nos somatórios e produtórios:
>> p:=x->x^2+2*x+3; #Define uma função polinomial#
x -> x^2 + 2*x + 3
>> sum(p(x),x=1..5); #Faz a soma p(1)+p(2)+...+p(5)#
100
>> sum(1/n^2, n=1..infinity); #Um resultado interessante: qual será a soma
dos inversos dos quadrados dos naturais?#
2
PI
--6
>> soma:=sum(x^y, y=1..10); #Cria uma soma#
2
3
4
5
6
7
8
9
10
x + x + x + x + x + x + x + x + x + x
Outro exemplo importante, usando a função binomial, usada para calcular binomiais:
binomial(n, i) = n!/[(n - i)!*i!].
>> sum( binomial(15,n), n=0..15)
32768
>> 2^15;
32768
n
n
Coincidência? Não, já que ( p)=2 !
11
MuPAD Tutorial
CONJUNTOS
Estruturas são formas de se agrupar dados que tem uma certa estrutura e ordem. Para
manipular estes dados, existem operações especiais e regras especiais. As principais estrutura de
dados são as sequências, que no MuPAD podem ser criadas muito facilmente. A partir delas,
podemos criar listas e conjuntos. Somente os conjuntos serão abordados aqui.
Conjuntos, que são sequências não-ordenadas de objetos, podem ser criados da mesma forma
que listas e sequências. As operações mais comuns com conjuntos (união, interseção e subtração) são
realizadas da forma usual.
Cuidado! A ordem apresentada na tela quando se define um conjunto é uma ordem aleatória,
criada a partir de regras internas do MuPAD.
>> A:={1,2,3}: B:={4,5,6}: C:={1,4}: # criando os conjuntos A, B e C#
>> A union B; #União do conjunto A com o B#
{1,2,3,4,5,6}
>> A minus B; #Conjunto A menos o conjunto B#
{1,2,3}
>> A minus C; #Conjunto A menos o conjunto C#
{2,3}
>> (A intersect C) union B; A intersect (C union B);
{1,4,5,6}
{1}
FUNÇÕES
No MuPAD, para definirmos uma função, é preciso usar o “operador de seta” -> . O que este
operador faz é associar um nome a uma sequência de operações. Por exemplo:
>> f := x -> x^2
x -> x^2
Para efetuar cálculos com a função f, procede-se da maneira usual:
>> f(2)
4
>> f(a+b)
2
(a + b)
Uma outra função:
>> g:=x->1+x^2
x -> 1 + x^2
12
MuPAD Tutorial
As operação com duas funções, inclusive a composição, são feitas como abaixo.
>> f(a)*g(b)
2
a
2
(b
+ 1)
>> f(3)*g(1)
18
>> f(g(a))
2
2
(a + 1)
As funções trigonométricas, exponenciais e logarítmicas também podem ser usadas, inclusive
em conjunto com funções definidas pelo usuário. Por exemplo:
>> sin(PI/2)*f(PI)
2
PI
>> g( tg(x) )
2
tg(x)
+ 1
No MuPAD, para definir uma função por partes, deve -se usar o comando piecewise:
>> p:=x->piecewise( [x<0, x^2], [x=0, 0], [x>0, x+1])
x -> piecewise([x<0, x^2 + 4*x], [x =0, 0], [0 < x, 2*x + 1])
>> p(-3);p(5);
9
6
Agora, compondo a função p (definida por partes), com a função f:
>> f(p(x))
4
2
piecewise(x if x < 0, 0 if x = 0, (x + 1) if 0 < x)
>> f(p(4))
25
>>p(f(4))
17
Note que p(f(4)) é diferente de f(p(4)), já que a composição de funções nem sempre é comutativa.
GRÁFICOS DE FUNÇÕES
O MuPAD possui ferramentas variadas para renderizar (desenhar) objetos matemáticos em
duas ou três dimensões. Existe uma biblioteca para lidar com os casos mais complexos, porém
existem comandos padrão para gráficos de funções, talvez os mais desenhados.
Os comandos para traçar gráficos de funções (ou equações) são basicamente 4: plotfunc2d,
plotfunc3d, plot2d e plot3d. Os gráficos geralmente aparecem em uma janela separada, para facilitar a
visualização.
13
MuPAD Tutorial
Gráficos 2D
Para gráficos de funções de uma variável, será usado o comando plotfunc2d. Seu uso é bem simples:
>> plotfunc2d( x^3, x=-3..3); #Gráfico da função y=x^3, no intervalo de
x=–3 até x=3.#
>> plotfunc2d( sin(x), cos(x), x=-PI..PI); #Gráficos de seno e cosseno
juntos#
sin(x), cos(x)
x^3
y
y
0.5
12.5
0
0
-2.5
1
25
-1.25
0
1.25
-2.5
2.5
-1.25
0
1.25
2.5
x
x
-12.5
-0.5
-25
-1
>> plotfunc2d(sqrt(1 - x^2), sqrt(x-1), x = -2..2):
(1 - x^2)^(1/2), (x - 1)^(1/2)
y
1
0.75
0.5
0.25
0
-1
-0.5
0
0.5
1
1.5
2
x
Um exemplo de função com singularidade:
>> plotfunc2d(1/((x-2)*(x-3)), x=0..4)
1/(x - 2)/(x - 3)
y
10
0
0
1
2
3
4
x
-10
-20
Note que o gráfico está bem desproporcional. Para contornar este problema, existe a opção
Constrained. Veja o mesmo gráfico, usando esta opção. O eixo y ficará restrito ao intervalo [-5, 5].
14
MuPAD Tutorial
>> plotfunc2d(1/((x-2)*(x-3)), x=0..4, y=-5..5, Scaling=Constrained)
1/(x - 2)/(x - 3)
y
5
2.5
0
0
1
2
3
4
x
-2.5
-5
Usando as restrições dos valores de x e de y, é possível ver o comportamento da função em qualquer
região do plano:
>> plotfunc2d(sin(x)+cos(x)+x^5-4*x^3, x=-3..3)
>> plotfunc2d(sin(x)+cos(x)+x^5-4*x^3, x=1..2,y=-5..-1)
x
- 4*x^3 + x^5
1.25cos(x) + sin(x)1.5
1
cos(x) + sin(x) - 4*x^3 + x^5
1.75
2
-1
y
100
-2
50
0
-2.5
-1.25
-3
0
1.25
2.5
x
-50
-4
-100
y
-5
Outra opção do plotfunc2d é a opção GridLines. Ela permite que o plano fique todo
pontilhado, para facilitar a visualização de certos pontos.
>> plotfunc2d(x^2+3*x+1, x=-4..1, y=-5..5, GridLines=20)
3*x + x^2 + 1
5
y
2.5
0
-3.75
-2.5
-1.25
0
x
-2.5
-5
É possível alterar as cores da figura com algumas opções auxiliares. Por exemplo:
>> plotfunc2d(x^2+3*x+1, x=-4..1, y=-5..5, GridLines=20,
ForeGround=RGB::Red, BackGround=RGB::Yellow)
Desta maneira, o fundo da figura acima passará de branco para amarelo, e os eixos serão
vermelhos ao invés de pretos.
15
MuPAD Tutorial
Para alterar a cor do pontilhado, a opção é GridLinesColor. Para usar linhas ao invés de pontilhados,
a opção é GridLinesStyle. Veja:
>> plotfunc2d(x^2+3*x+1, x=-4..1, y=-5..5, GridLines=20,
ForeGround=RGB::Red, BackGround=RGB::Yellow, GridLinesColor=RGB::Black,
GridLinesStyle=SolidLines)
3*x + x^2 + 1
5
y
2.5
0
-3.75
-2.5
-1.25
0
x
-2.5
-5
Gráficos 3D
Para gráficos tridimensionais, existe o comando plotfunc3d, que é o equivalente ao plotfunc2d
para este ambiente. Como precisaremos estabelecer valores para as duas variáveis, o intervalo do y
agora deixa de ser opcional e passa a ser obrigatório.
>> plotfunc3d( x+y-6,x+y^2, x=-5..5, y=-5..5)
Normalmente, o MuPAD plota o gráfico como que numa “caixa”, isto é, os eixos formam um
paralelepípedo. Isto pode ser alterado com a opção Axes. Por padrão, Axes=Boxed. Para mostrar os
eixos somente nos cantos, a opção é Axes=Corner.
Outro recurso é a definição de Grid. As figuras em 3D são plotadas como resultado de vários
planos unidos. O número de planos que dará origem a uma figura é o Grid. Assim, quando maior o
valor de Grid, melhor resolução terá a figura.
>> plotfunc3d( x+y-6,x+y^2, x=-5..5, y=-5..5, Axes=Corner, Grid=[50,50])
x + y - 6, x + y^2
30
x + y - 6, x + y^2
30
20
20
z
z
10
10
0
0
-10
-10
y5
2.5
0
-2.5
-5
-5
-2.5
0
2.5
x
5
y
5
2.5
0
-2.5
-5
-5
-2.5
0
2.5
5
x
16
MuPAD Tutorial
>> g:=piecewise( [x<y, x+y], [x>=y, cos(x)*y]);
>> plotfunc3d( g(x,y), x=-5..5, y=-5..5, Grid=[40,40])
piecewise([x < y, x + y], [y <= x, y*cos(x)])
7.5
z
5
2.5
0
-2.5
-5
5
y
2.5
0
-2.5
-5
-5
0
-2.5
-7.5
5
2.5
x
Pode-se definir o ponto (x, y, z) de onde será “olhado” o gráfico, com a opção CameraPoint = [x,y,z].
Cálculo Diferencial e Integral
O MuPAD calcula limites, derivadas e integrais, podendo ser uma ferramenta útil para
trabalhar conceitos de Cálculo.
Para calcular um limite no MuPAD, a sintaxe é limit(funcao, x=ponto, direcao), onde
“direção” é Left para limite a esquerda, Right para limite a direita, e se omitida, supõe-se o limite
bidirecional. Por exemplo:
>> f:=x->1/(x-1): #Uma função descontínua em x=1#
>> limit( f(x), x=1, Left); #O limite tendendo à esquerda de x=1#
-infinity
>> limit( f(x), x=1, Right); #O limite tendendo à direita de x=1#
infinity
>> limit( f(x), x=1); #Como os dois limites acima são diferentes, o limite
bilateral não existe!#
undefined
Para
conferir
as
respostas
graficamente, é possível plotar o gráfico da
função acima definida:
>> plotfunc2d( f(x), x=0..2 );
1/(x - 1)
y
10
5
0
0
0.5
1
1.5
2
x
-5
-10
17
MuPAD Tutorial
A derivada de uma função pode ser calculada algebricamente no MuPAD, com o uso do
comando diff, como na maioria dos outros softwares matemáticos:
>> f:=x->x^2*sin(x):
>> diff( f(x) , x ); # Deriva a função f em relação à variável x#
2
2 x sin(x) + x cos(x)
Ou então de uma maneira idêntica à notação de Newton para derivadas:
>> f’(x)
2
2 x sin(x) + x
cos(x)
>> f’’(x)
2
2 sin(x) + 4 x cos(x) - x sin(x)
Com a derivada é possível determinar retas tangentes a gráficos de funções, já que o valor da
derivada de uma função em um ponto x0 determina a inclinação da reta tangente à curva naquele
ponto. Veja abaixo:
2*x + x^2 - 4, 4*x - 5
y
>> g:=x->x^2+2*x-4:
25
>> a:=1:
12.5
>> m :=g'(a):
0
-5
>> rtg:= x->m*(x-a)+g(a);
-2.5
0
2.5
5
x
4 x – 5
-12.5
>> plotfunc2d(g(x), rtg(x), x=-5..5);
-25
A integração é bem semelhante à derivação. A função f é a mesma de antes, f(x) = x 2 sin(x).
>> int( f’(x), x)
2
2 sin(x) + sin(x) (x - 2)
A resposta está correta, apesar de diferente da esperada. Uma simplificação resolve o problema:
>> factor(%)
2
sin(x) x
A integração numérica é feita adicionando um intervalo de integração ao lado da variável de
integração:
>> int(ln(x), x=1..4)
4 ln(4) - 3
18
MuPAD Tutorial
Assim, fica sendo possível calcular áreas sob gráficos, como segue:
>> h:=x->ln(x): #Define uma função h(x)=ln(x)#
>> inferior:=1: #Limite inferior#
>> superior:=4.0: #Limite superior#
>> grafico:=[Mode=Curve, [u, h(u)], u=[inferior,superior],
Style=[Impulses], Grid=[200]]: #O gráfico da função, rachurado#
>> linha:=[Mode=Curve, [u, h(u)], u=[inferior,2*superior], Grid=[200]]: #O
traço do gráfico#
>> plot2d(grafico,linha,RealValuesOnly = TRUE );
y
2
1.5
1
0.5
0
1.25
2.5
3.75
5
6.25
7.5
x
>> int( h(x), x=inferior..superior); #A área da parte rachurada acima#
2.545177444
ÁLGEBRA LINEAR
Uma matriz é uma tabela de números (ou objetos). Apesar de matrizes e vetores poderem ser
criados como arrays, desta forma é preciso definir as operações de adição e multiplicação destes. Para
evitar isto, o MuPAD existe um comando especial para criar matrizes. Funções mais avançadas para
tratar matrizes podem ser acionados com na biblioteca linalg, específica para Álgebra Linear.
Para criar uma matriz, o comando é matrix(m,n), onde m é o número de linhas da matriz e n é
o número de colunas. Se as entradas da matriz não forem especificadas, o MuPAD cria uma matriz de
zeros.
>> A:=matrix(2,2)
+-+
| 0, 0 |
|
|
| 0, 0 |
+-+
>> B:=matrix(2,2,[ [1,2], [3,4]]); #Criando uma matriz especificando as
entradas#
+-+
| 1, 2 |
|
|
| 3, 4 |
+-+
19
MuPAD Tutorial
>> B:=matrix(3,3,8,Diagonal); #Cria uma matriz diagonal, com os elementos
da diagonal iguais a 8, ou seja, 8*Id#
+-+
| 8, 0, 0 |
|
|
| 0, 8, 0 |
|
|
| 0, 0, 8 |
+-+
Para operar com matrizes, os comandos são os mesmo usados para se trabalhar com números.
>> C:=matrix(2,2, [[6,7], [9,9]])
+-+
| 6, 7 |
|
|
| 9, 9 |
+-+
>> B+C, B*C, B*C+B^2; #Algumas operações com
+-+ +-+
|
7, 9 | | 24, 25 |
|
|, |
|,
| 12, 13 | | 54, 57 |
+-+ +-+
matrizes#
+-+
| 31, 35 |
|
|
| 69, 79 |
+-+
A inversa de uma matriz pode ser obtida do modo mais natural possível:
>> inversa:=1/B
+-+
|
-2,
1
|
|
|
| 3/2, -1/2 |
+-+
>> inversa*B; #A multiplicação de uma matriz pela sua inversa resulta numa
matriz identidade#
+-+
| 1, 0 |
|
|
| 0, 1 |
+-+
Se a matriz não possuir inversa, uma mensagem de erro (FAIL) aparece. Para concatenar duas
matrizes, o comando é o mesmo para listas, A.B.
Para usar outras funções (mais ligadas às propr iedades das matrizes e menos às suas características
numéricas) é necessário usar o pacote linalg. Para usá-lo, a sintaxe é linalg::comando(Matriz), como
no exemplo abaixo:
>> linalg::tr(B); #Retorna
principal) da matriz B#
o
traço
(soma
dos
elementos
da
diagonal
5
20
MuPAD Tutorial
Abaixo, mais alguns comandos no pacote linalg.
>> linalg::det(B); linalg::det(2*B);
-2
-8
>> linalg::det(a*B)
2
-2 a
Acima é possível perceber uma propriedade do determinante de uma matriz: ao
multiplicarmos uma matriz 2x2 por uma constante a, o determinante desta fica multiplicado pela
constante elevada ao quadrado.
Seguem mais alguns comandos para trabalhar com matrizes:
>> linalg::transpose(C)
+-+
| 6, 9 |
|
|
| 7, 9 |
+-+
>> linalg::randomMatrix(2,2,Dom::Integer); #Gera uma matriz 2x2 aleatória
com entradas Inteiras; outros tipos de entradas: Real, Rational, Complex#
+-+
| 4, -7 |
|
|
| 6, 16 |
+-+
>> linalg::randomMatrix(3,3,Dom::Integer, -20..20); #Uma matriz aleatória
com entradas inteiras entre –20 e 20#
+-+
| -10, 9 |
|
|
| -14, 11 |
+-+
A seguir, um importante teorema da Álgebra Linear será exemplificado com o uso do
MuPAD. É o Teorema de Cayley-Hamilton, que nos diz que uma matriz é raiz de seu polinômio
característico.
>> M:=matrix(2,2,[ [5,7], [4,1] ]): #Cria uma matrix 2x2#
>> Id:=matrix(2,2,[ [1,0], [0,1] ]): #Cria a identidade 2x2#
>> p:=linalg::charpoly(M,x); #Calcula o polinômio caracte-rístico da
matrix M#
2
x - 6 x - 23
21
MuPAD Tutorial
Agora use uma expressão para ver o que acontece quando “substituímos” a matriz M no
polinômio p (considere “23” como 23*Id):
>> M^2 - 6*M – 23*Id
+-+
| 0, 0 |
|
|
| 0, 0 |
+-+
O resultado é uma matriz nula, como previsto pelo teorema.
SISTEMAS LINEARES E OTIMIZAÇÃO
Uma das mais importantes aplicações da Álgebra Linear aparece na resolução de sistemas de
equações lineares e problemas de otimização (programação matemática). O MuPAD tem recursos
para lidar com estes dois problemas de uma forma muito prática e rápida.
Por exemplo, imagine que queremos resolver o seguinte sistema:
x
2x
x
+
+
-
y +
y +
2y +
z = 10
z = 3
4z = 11
No MuPAD, o procedimento seria o seguinte:
>> equacoes:={2*x+y+z=3, x+y+z=10, x-2*y+4*z=11}; #Faz a variável
equacoes receber o sistema#
{x + y + z = 10, 2 x + y + z = 3, x - 2 y + 4 z = 11}
>> solucao:=solve(equacoes); #A variável solucao recebe a solução do
sistema#
{[x = -7, y = 25/3, z = 26/3]}
Para resolução de problemas que procuram o valor máximo assumido por uma função cujas
variáveis devem satisfazer um sistema de inequações lineares, o MuPAD possui implementado o
algoritmo Simplex, que é o método mais rápido e eficaz para resolver este tipo de problema. Por
exemplo, considere o seguinte problema:
Maximizar Z = 4x + 3y
Sujeito a:
3x + 2y
2x + 2y
x - y
x, y 0
6
4
-1
No problema acima, deve-se obter o valor máximo da função Z(x, y) = 4x + 3y, dado que as
variáveis x e y devem ser positivas e obedecer às restrições dadas.
22
MuPAD Tutorial
Este problema ficaria assim no MuPAD:
>> rest:=[ {3*x+2*y<=6, 2*x+2*y>=4, y-x<=1, x>=0, y>=0}, 4*x+3*y ]; #
Armazenando as equações na variável rest#
[{0 <=x, 0<=y, y - x <=1, 4<=2x + 2y, 3x + 2y<=6}, 4x + 3y]
>> linopt::maximize(rest); # Agora o MuPAD resolve o problema, analisando
o conteúdo da variável rest#
[OPTIMAL, {x = 4/5, y = 9/5}, 43/5]
Isto é, existe uma solução ótima no ponto (4/5, 9/5), e este ponto, quando substituído na
função objetivo, resulta num valor máximo de 43/5 para o problema.
Se traçarmos os gráficos das equações acima, teremos a figura abaixo, onde está rachurado de
verde a região dos pontos viáveis, ou seja, pontos que são satisfazem o sistema de inequações. Pa ra
isso foram usados os comandos abaixo:
>> eqs:= implicit( [3*x+2*y-6,2*x+2*y-4, y-x-1], x=-1..4, y=-1..4): #Cria
uma imagem com as equações#
>> regiao:=Polygon(Point(1/2,3/2), Point(2,0), Point(4/5, 9/5),
Closed=TRUE, Filled=TRUE, Color=[0.254, 0.874, 0.5]): #Cria a região
rachurada#
>> plot(regiao, eqs); #Plota tudo#
y
3.75
2.5
1.25
0
-1
0
1
2
3
x
A biblioteca linopt, específica para lidar com Otimização Linear (inclusive Programação
Linear Inteira, usando o Algoritmo de Lang-Doing), possui vários recursos interessantes. Para
maiores detalhes, digite ?linopt.
23
MuPAD Tutorial
O COMANDO PLOT
Quando as funções plotfunc2d/plotfunc3d são usadas, o MuPAD tenta gerar os melhores
parâmetros para cada gráfico, de acordo com as características da função. Assim, como esta
verificação é um processo heurístico, nem sempre ela funciona.
Uma maneira de contornar isso é usar a função plot, que é bem mais geral. A função plot faz
parte de uma biblioteca de comandos. Uma biblioteca é composta de vários comandos que para serem
usados necessitam de uma chamada especial, ou seja, para usar o comando com da biblioteca bib,
deve-se digitar bib::com(argumentos). Para evitar a digitação repetitiva de plot::comando() para
acessar algum comando da biblioteca plot, deve-se antes carregar o pacote plot , que pode ser feito
com o comando export plot. Então, nosso primeiro comando antes de usar as funções abaixo deve ser:
>> export(plot):
Para usar a função plot, é necessário antes criar o objeto que se quer plotar. Isso pode ser feito
com um dos comandos da biblioteca plot. Depois dos objetos criados, resta usar o comando
plot(objeto1, objeto2, ..) para que todos sejam mostrados.
Os objetos mais comuns, os quais serão tratados aqui, são: Curvas em 2D e 3D, Pontos,
Polígonos e Gráficos de Funções implícitas. Existem comandos para plotagem de funções na
biblioteca plot (Function2d e Function3d), que funcionam analogamente aos comandos plotfunc2d e
plotfunc3d, já tratados neste tutorial.
As funções para criação de curvas são Curve2d e Curve3d, para curvas bidimensionais e
tridimensionais, respectivamente. Nelas, a curva deve ser dada de forma paramétrica.
Parametrizar uma curva consiste em descrevê- la considerando
y(t)
as coordenadas x e y de seu ponto genérico P = (x,y)
P
como funções de uma única variável independente t.
Por exemplo:
>> circulo:=Curve2d( [cos(t), sin(t)], t=0..2*PI):
>> curva:= Curve2d( [t,ln(t)], t = 1..2*PI):
x(t)
>> plot(circulo,curva)
y
1.5
1
0.5
0
0
-0.5
-1
1.25
2.5
3.75
5
6.25
x
24
MuPAD Tutorial
No caso de curvas em 3D:
>> grafico:=Curve3d([t, cos(t), (t+1)], t=0..10, Color=RGB::Blue):
>> plot(grafico)
O mesmo gráfico pode ser plotado em outro estilo. Um estilo que dá bem a idéia de perspectiva em
3d é o Impulses:
>> grafico:= Curve3d([t, cos(t), (t+1)], t=0..10, Style=[Impulses]):
>> plot(grafico)
Para aumentar a resolução do gráfico, usaremos a opção adicional Grid:
>> grafico:= Curve3d([t, cos(t), (t+1)], t=0..10, Style=[Impulses],
Grid=[250]):
>> plot(grafico)
10
10
z
10
z
z
7.5
7.5
7.5
5
5
5
2.5
2.5
2.5
0
0
0
2.5
2.5
2.5
5
1
0.5
0
-0.5
-1
7.5
x
10
5
5
y
7.5
10
x
1
0.5
0
-0.5
-1
7.5
y
x
10
1
0.5
0
-0.5
-1
y
Funções implícitas e equações
A plotagem de gráficos de equações pode ser feita com o comando implicit, da biblioteca plot,
que é voltado para trabalhar com funções implícitas. Se for usada uma expressão ao invés uma
equação, o MuPAD transforma esta expressão em uma equação, igualando-a a zero. Os pontos
pertencentes à estes gráficos são resolvidos usando métodos numéricos, portanto, o valor da variável
DIGITS pode incluenciar a qualidade dos desenhos.
>> plot(implicit( x^2+y^2=9, x=-4..4, y=-4..4))
>> plot(implicit( 5*x^2+2*y^2-12, x=-4..4, y=-4..4))
>> plot(implicit( 5*x^2-12*y^2-7, x=-4..4, y=-4..4))
y 2.5
2.5 y
y
2.5
1.25
1.25
1.25
0
0
-2.5
-1.25
0
1.25
2.5
-1.5 -1
-0.5 0
x
0
0.5
1
1.5
-4
-2
0
x
-1.25
-1.25
2
4
x
-1.25
-2.5
25
MuPAD Tutorial
Os recursos do implicit podem ser usados para plotar uma família de equações (funções),
usando a opção Contours. Seu uso é simples: implicit( f, x=a..b, y=c..d, Contours=[c1 , c2, ..., cn])
plota as equações f=c1, f=c2 , ..., f=cn juntas. Por exemplo, a seguir estão plotados os gráficos de
x2 +y2 =1, x2 +y2 =4 e x2 +y2 =9 e de uma família de equações elípticas.
>> plot(implicit( x^2+y^2, x=-10..10, y=-10..10, Contours=[1,4,9]))
>> plot(implicit( x^3+2*x+2-y^2, x=-10..10, y=-10..10,
Contours=[0,1,2,3]))
y 3.75
y
2.5
2.5
1.25
1.25
0
-2.5
-1.25
0
0
1.25
2.5
-0.5
x
0
0.5
1
1.5
2
x
-1.25
-1.25
-2.5
-2.5
-3.75
Polígonos
Para criar polígonos, é necessário definir os vértices. Isso é feito com o comando Point(x,y) ou
Point(x,y,z). Assim:
>> a:=Point(1,3): b:=Point(5,6): c:=Point(5,2): d:=Point(0,0):
>> plot(a,b,c,d)
>> plot(
>> Point(0,0,0, PointWidth=100, Color=RGB::Blue) ,
>> Point(1,2,2, PointWidth=100, Color=RGB::Red) ,
>> Point(4,5,6, PointWidth=100, Color=RGB::Black)
>> )
y
5
z
3.75
5
3.75
2.5
2.5
5
1.25
1.25
3.75
1
2
1.25
3
4
0
0
1.25
2.5
3.75
5
y
2.5
0
0
x
x
26
MuPAD Tutorial
Agora os polígonos correspondentes:
>> plot(Polygon(a,b,c,d))
>> plot(Polygon(a,b,c,d, Closed=TRUE))
y
y
5
5
3.75
3.75
2.5
2.5
1.25
1.25
0
0
0
1.25
2.5
3.75
5
0
1.25
2.5
3.75
5
x
x
Seguem dois polígonos no espaço. O segundo deles, cujo comando foi omitido, tem uma opção
adicional, Filled=TRUE, que pode ser inserida logo após a opção Closed=TRUE.
>> plot(
>> Polygon(
>>
Point(0,0,0, PointWidth=100, Color=RGB::Blue) ,
>>
Point(8,6,2, PointWidth=100, Color=RGB::Red) ,
>>
Point(4,5,6, PointWidth=100, Color=RGB::Black),
>>
Closed=TRUE), Axes=Corner)
z
5
z
5
3.75
3.75
2.5
2.5
1.25
1.25
5
3.75
00
2
y
4
5
3.75
00
2
2.5
4
1.25
6
8
x
y
2.5
1.25
6
0
8
x
0
Outro comando para lidar com plotagem de pontos é o Pointlist . Com ele fica possível plotar
gráficos discretos ou polígonos.
>> plot( Pointlist( Point(i, sin(i)) $i=1..8) )
Com a opção DrawMode=Connected, os pontos ficam conectados.
>> plot(Pointlist(Point(i, sin(i)) $i=1..8, DrawMode=Connected))
y
y
0.75
0.75
0.5
0.5
0.25
0.25
0
1.25
-0.25
2.5
3.75
5
6.25
0
7.5
1.25
x
-0.25
-0.5
-0.5
-0.75
-0.75
2.5
3.75
5
6.25
7.5
x
27
MuPAD Tutorial
ANIMAÇÕES
Primeiras Idéias
O MuPAD vem configurado para exibir todos os gráficos numa mesma janela (fora da planilha de
comandos). Assim, a primeira idéia que tivemos para criar uma animação foi preparar uma linha de
comando usando vários comandos plot juntos, simulando uma animação:
>> plotfunc2d(sin(x),x=0..2*PI);
>> plotfunc2d(sin(x+PI/8),x=0..2*PI);
>> plotfunc2d(sin(x+PI/4),x=0..2*PI);
Com isso, teremos a sequência de gráficos abaixo, que, quando apresentados numa mesma janela
num pequeno intervalo de tempo, produz uma animação:
sin(x)
y
sin(x + 1/8*PI)
1
y
0.5
0
sin(x + 1/4*PI)
y
1
0.5
0
1.25
2.5
3.75
5
6.25
1
0.5
0
0
0
1.25
2.5
3.75
5
6.25
0
1.25
2.5
3.75
5
6.25
x
x
x
-0.5
-0.5
-0.5
-1
-1
-1
Esta técnica funciona bem, mas tem um problema: a velocidade com a qual ocorre a troca de gráficos
na tela depende da velocidade do computador. Assim, em alguns computadores esta troca era quase
imperceptível. Desta forma, precisávamos de algo que fizesse o computador parar o processamento
por um tempo, e não há comando de espera (como o sleep, ou wait) no MuPAD.
Usando laços
Para evitar a digitação de todos os gráficos na linha de comando, podemos recorrer a um laço. Um
laço é uma função que permite que se crie vários comandos, usando uma variável pré-determinada.
No nosso caso, usaremos o for. Por exemplo:
>> soma:=0
>> for i from 1 to 10 do soma:=soma+i; end_for;
55
Na primeira linha do comando acima, foi dado o valor de 0 à variável soma. Na segunda linha, o que
o comando for faz é: “para i de 1 até 10, faça a variável soma receber o seu valor atual somado ao
valor de i”. Teremos a seguinte tabela, conhecida como tabela de rastreio:
I
soma
I
Soma
i
soma
-1
2
3
0
0+1=1
1+2=3
3+3=6
4
5
6
7
6+4=10
10+5=15
15+6=21
21+7=28
8
9
10
28+8=36
36+9=45
45+10=55
28
MuPAD Tutorial
Logo, quando i chegar a 10, teremos a variável soma igual a 55. Os valores de i são incrementados
por uma unidade a cada passagem. É possível alterar o valor de incremento, e é o que faremos agora:
>> for i from 1 to 10 step 0.5 do
>> plotfunc2d(sin(x+i), x=-i..i); end_for
A opção .. step 0.5 .. determina que os incrementos sejam de 0.5, ou seja, i vai assumir os valores 1,
1.5, 2, 2.5, ... . Repare que os extremos do intervalo também estão variando com o valor de i, o que dá
a impressão do gráfico estar sendo realmente construído.
Agora vamos a uma animação bem interessante. Sabemos que dois pontos determinam uma reta. Por
exemplo, a reta y =3x+1 passa pelos pontos (0, 1) e (10, 31). Faremos um ponto caminhar sobre o
segmento de reta (0, 1)_(10, 31). Precisamos plotar os dois extremos e o ponto. Assim, teremos três
objetos dentro do plot . O incremento será de 0.05, para o movimento ser mais lento.
>> for i from 1 to 10 step 0.05 do plot( Point(0,1), Point(10,31),
Point(i,3*i+1)); end_for
Outros dois comandos que precisaremos são o indexador $, e os comandos max e min, e,
principalmente, o uso em conjunto deles. O comando max determina o maior dentre uma lista de
números e o min determina o menor.
>> max(1,2,3,4,5,6,7)
7
>> min(5,6,7,8,3)
3
O indexador serve para criar sequências. Ele deve ser lido como “tal que”.
>> i $ i=1..10
1, 2, 3, 4, 5, 6, 7, 8, 9, 10
>> x+i $ i=1..5
x + 1, x + 2, x + 3, x + 4, x + 5
>> f:=x->ln(x)
x -> ln(x)
>> max(f(x) $ x=1..20)
ln(20)
O último comando acima determina o valor máximo entre ln(1), ln(2), ..., ln(20).
Criando procedimentos
Um procedimento nada mais é que uma função. Usamos procedimentos quando precisamos definir
uma função mais complexa. Um procedimento é definido com o comando proc.
No exemplo seguinte, dada uma função f e um ponto a, será plotado o grá fico de f e a reta tangente à f
no ponto (a,f(a)). O gráfico será plotado no intervalo (a-5,a+5).
29
MuPAD Tutorial
>>
>>
>>
>>
plota:=proc(f,a) begin
y:=x->f(a)+f'(a)*(x-a);
plotfunc2d(f(x), y(x), x=a-5..a+5)
end_proc;
x^2 - 5*x + 2, x - 7
y
25
20
15
>> f:=x->x^2-5*x+2
x -> x^2 – 5*x + 2
>> plota(f,3)
10
5
0
0
2.5
5
7.5
-5
x
Animações
Agora começaremos a animar os gráficos. De início, vamos a um exemplo de uma curva famosa, cuja
animação exigirá o conceito de coordenadas polares: a espiral de Arquimedes. Vale lembrar que o
pacote plot deve estar exportado para que os comandos que seguem funcionem (isto pode ser feito
com o comando export(plot)). Introduziremos o conceito de coordenadas polares, para simplificar a
equação da espiral.
uuur
As coordenadas polares de um ponto P = (x, y) do plano são a distância r =|| OP || e o ângulo θ que o
uuur
vetor OP faz com o eixo X.
Assim, dado um ponto (x, y), suas coodenadas polares são ( θ , r) = ( arc tg
y
, x2 + y2 ). Portanto, a
x
equação de uma circunferência em coordenadas polares fica r = r0 , onde r0 é o raio da
cincunferência.
A equação da espiral desejada é r = θ , ou seja, a distância da curva à origem varia com o ângulo. No
MuPAD, para plotar curvas usando coordenadas polares, existe o comando polar.
A sintaxe é polar( [r( θ ), θ ], θ =a..b).
Para plotar a espiral, o comando é:
>> plot( polar( [t,t],t=0..2*PI))
Nossa animação consistirá em plotar várias espirais em sequência, aumentando, em cada uma delas,
intervalo de plotagem, gerando uma animação. Os dois pontos que estão sendo plotados terão sua
y
5
importância justificada logo a frente.
>>
>>
>>
>>
for i from 1 to float(3*PI) step 0.5 do
plot( Point(-5,-5), Point(5,5),
polar( [t,t],t=0..i), Scaling=Constrained);
end_for;
2.5
0
-5
-2.5
0
2.5
5
x
-2.5
-5
30
MuPAD Tutorial
Extenderemos agora a animação do ponto que percorre uma reta, produzida anteriormente,
para uma mais geral, de um ponto percorrendo o gráfico de uma função qualquer.
O que queremos então é, dada uma função f(x), plotar o ponto (x,f(x)), depois o ponto
(x+i,f(x+i)), depois (x+i+i,f(x+i+i)), prosseguindo até um certo limite.
Nossa função será armazenada na variável curva, e o ponto, cujas coordenadas dependerão de
um parâmetro i, será p(i). A cada valor de i, será plotada a curva e um ponto.
>>
>>
>>
>>
>>
curva:=Curve2d( [t,sin(t)],t=0..2*PI);
p:=x->Point( [x,sin(x)],Color=RGB::Blue);
for i from 1 to float(2*PI) step 0.5 do
plot(p(i),curva);
end_for;
Se formos plotar somente o ponto, sem a curva por baixo, precisaremos definir os valores de
máximo e de mínimo da função no intervalo de animação para travar a região de plotagem, o que será
feito plotando os extremos da região retangular na qual a função se encontra, ou seja, se [a,b] é o
intervalo de plotagem, e max e min são os valores de máximo e mínimo em [a,b], respectivamente,
teremos a seguinte região:
(a,max)
a
b
(b,min )
Assim, o procedimento conterá os seguintes comandos, que determinam dois vértices da região
retangular e mais a origem, se for necessário:
>>
>>
>>
>>
>>
zero:=Point(0,0);
maximo:=max(f(x)$x=a..b);
minimo:=min(f(x)$x=a..b);
pmaximo:=Point(b,maximo, Color=RGB::White);
pminimo:=Point(a,minimo, Color=RGB::White);
Um ponto P = (x, f(x)) no gráfico pode ser determinado com a função abaixo:
>> p:=x->Point([x,f(x)]);
Assim, nosso procedimento pode ser como o abaixo:
>> pontinho:=proc(f,a,b) begin
>> zero:=Point(0,0);
>> maximo:=max(f(x)$x=a..b);
>> minimo:=min(f(x)$x=a..b);
>> pmaximo:=Point(b,maximo, Color=RGB::White);
>> pminimo:=Point(a,minimo, Color=RGB::White);
31
MuPAD Tutorial
>> p:=x->Point( [x,f(x)]);
>> for i from a to b step 0.1 do plot(pmaximo,pminimo,p(i));
>> end;
>> end_proc;
O laço for, dentro do procedimento, faz o seguinte: para i indo de a até b (de 0.1 em 0.1), mostre
pmaximo, pminimo e p(i). O resultado será uma animação. A velocidade pode ser controlada com o
tamanho do passo do for.
Para usar o procedimento pontinho, precisamos definir uma função e dar o extremo do intervalo que
queremos plotar, por exemplo:
>> f:=x->sin(x)+cos(x);
>> pontinho(f,-5,5)
Podemos plotar, junto com a animação, o gráfico da função que o ponto percorre, adicionando uma
única linha no procedimento. Daremos um novo nome a este procedimento. Note que mudamos a cor,
estilo e tamanho do ponto animado. Os novos comandos estão em negrito.
>> fpontinho:=proc(f,a,b) begin
>> zero:=Point(0,0);
>> maximo:=max(f(x)$x=a..b); minimo:=min(f(x)$x=a..b);
>> pmaximo:=Point(b,maximo, Color=RGB::White);
>> pminimo:=Point(a,minimo, Color=RGB::White);
>> p:=x->Point( [x,f(x)], Color=RGB::Blue, PointWidth=50,
PointStyle=FilledCircles);
>> curva:=Curve2d([t,f(t)],t=a..b);
>> for i from a to b step 0.2 do
>> plot(pmaximo, pminimo, p(i), curva);
>> end;
>> end_proc;
>> f:=x->sin(x)+cos(x);
>> fpontinho(f,-5,5)
A animação acima pode ser facilmente alterada para que a curva seja desenhada de acordo com o
movimento do ponto, modificando as seguintes linhas (em negrito):
-- corte ->> p:=x->Point( [x,f(x)], Color=RGB::Blue, PointWidth=50,
PointStyle=FilledCircles);
>> for i from a to b step 0.2 do
>> plot(pmaximo, pminimo,
>>
p(i), Curve2d( [t,f(t)], t=a-1..i) );
>> end;
-- corte -Agora que já temos um processo para um ponto percorrer um gráfico, o próximo passo é fazer com
que uma reta tangente percorra o gráfico. A idéia aqui é plotar, em cada ponto do gráfico, uma reta
tangente, ou seja, plotar a reta y=f(k)+f´(k)*(x-k), com intervalo de plotagem numa vizinhança de k.
Precisaremos definir, novamente, a região retangular de plotagem, com um procedimento análogo ao
citado acima. Depois, é só fazer k variar de a até b, que será o intervalo da animação.
32
MuPAD Tutorial
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
rt:=proc(f,x0,x1) begin
curva:=Curve2d([t,f(t)],t=x0..x1);
maximo:=max(f(x)$x=x0..x1);
minimo:=min(f(x)$x=x0..x1);
pmaximo:=Point(x1,maximo+1, Color=RGB::White);
pminimo:=Point(x0,minimo-1, Color=RGB::White);
caixa:=pmaximo,pminimo;
for k from x0 to x1 step 0.05 do
-5
y:=x->f(k)+f'(k)*(x-k);
reta:=Curve2d([t,y(t)], t=(k-0.7)..(k+0.7),
Color=RGB::Blue );
plot( reta,caixa,curva);
end_for;
end_proc;
f:=x->sin(x)+cos(4*x)+2*x+1;
rt(f,-5,5)
y
10
5
0
-2.5
0
2.5
5
x
-5
Construção de cônicas
Circunferência
A idéia aqui é simular a construção de uma circunferência, enfatizando sua principal característica:
ser o lugar geométrico dos pontos que equidistam de um dado ponto. A maneira prática de se
construir uma circunferência é fixar a ponta de um fio num ponto e uma caneta na outra ponta e fazer
o fio girar, marcando com a caneta todo o trajeto – uma circunferência. Assim, dados o centro e o
raio, precisamos fazer com que uma circunferência seja “construída” ponto a ponto, e uma linha siga
esta construção.
O movimento da linha pode ser visto como o segmento de reta (a,b)_(a+r*cos(k,b+r*sin(k)), k varia
de 0 até 2*Pi. A circunferência “em construção” pode ser dada pela curva parametrizada por
(r*cos(t)+a,r*sin(t)+b), plotada com t no intervalo [0,i], onde i varia de 0 até 2*Pi. Assim, teremos
desde um único ponto à uma circunferência completa.
A definição da região retangular neste caso é diferente: como nossa circunferência terá centro em
(a,b) e raio r, deveremos marcar os pontos (a-r,b-r) e (a+r,b+r) como limitantes do retângulo, e de
preferência que estes pontos sejam brancos, para não aparecerem na animação. O resultado será:
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
circ:=proc(a,b,r) begin
for i from 0.05 to float(2*PI) step 0.2 do
pontos:=Point(0,0,Color=RGB::White),
Point(a+r,b+r,Color=RGB::White),
Point(a-r,b-r,Color=RGB::White),
Point(a,b);
plot(pontos,
Curve2d([r*cos(t)+a,r*sin(t)+b],t=0..i),
line([a,b],[r*cos(i)+a,r*sin(i)+b],Color=RGB::Blue),
Scaling=Constrained, Labeling=FALSE, Ticks=None)
end_for;
end_proc;
33
MuPAD Tutorial
A sintaxe para a animação é circ(a,b,r), onde (a,b) é o centro da circunferência e r é seu raio.
>> circ(2,4,5);
Parábola
A parábola é o lugar geométrico dos pontos que equidistam de uma reta (diretriz) e de um ponto
(foco). Assim, dado o foco (a,b) e a reta diretriz y=-p, os pontos que pertencerão à serão os pontos
(x,y) que tornarem verdadeira a equação (x - a)2 + (y - b)2 = (y + p)2 . Por uma mudança de
coordenadas, podemos considerar o po nto (a,b) sobre o eixo Y e, mais ainda, fazer a coincidir com p.
Assim, teremos a equação y=x 2 /(4p), que é bem conhecida. Logo, dado o valor de p, a equação da
parábola ficará determinada.
Nossa animação consistirá de uma parábola sendo gerada, um segmento de reta ligando o ponto da
parábola ao foco e um outro segmento ligando este mesmo ponto à reta geratriz. Como os pontos da
parábola podem ser parametrizados na forma (t, t2 /(4p)), o procedimento é imediato. Usaremos um
segundo argumento, m, somente para controlar o intervalo de plotagem (que será simétrico, [-m,m]).
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
para:=proc(p,m) begin
for i from -m to m step 0.5 do
curva:=t->Curve2d( [k,k^2/(4*p)],k=-m-1..i );
diretriz:=Curve2d( [k,-p],k=-m-1..m,Color=RGB::Orange);
foco:=Point(0,p);
s1:=line( [i,i^2/(4*p)], [0,p], Color=RGB::Blue);
s2:=line( [i,i^2/(4*p)], [i,-p],Color=RGB::Black);
plot(curva(t),diretriz,foco,s1,s2, Labeling=FALSE, Ticks=None);
end_for;
end_proc;
para(2,10)
34
MuPAD Tutorial
Elipse
Dando continuidade ao nosso processo de construção das cônicas, agora é a vez da elipse. A elipse é
definida como o lugar geométrico dos pontos cujas soma das distâncias a dois pontos dados é uma
constante. A equação geral da elipse de centro ( x0 , y0 ) e semi-eixos a e b é
( x − x0 ) 2 ( y − x0 ) 2
+
=1.
a2
b2
Novamente teremos de recorrer às coordenadas polares para animar a elipse. A equação polar da
elipse é r =
m
, onde n ∈ (0,1) e m > 0 . Após algum algebrismo, pode-se mostrar que esta
1 − n cos θ
equação é equivalente a
( x − c) 2 y2
m
m
1
, b=
e c = an . Tomaremos n =
+ 2 = 1 , onde a =
2
2
a
b
1− n
2
1 − n2
e m = 10. Assim, nossa equação fica
( x − 20/3) 2
y2
+
= 1 , que é uma elipse de centro em
(40/3) 2
(20/ 3)2
(20/3, 0) e semi-eixos 40/3 e 20/ 3 . Seus focos estão em (0,0) e (2c,0) = (40/3,0) .
O que teremos de fazer é o seguinte: fazer um ponto percorrer a elipse, estando este ligado aos pontos
(0, 0) e (40/3, 0) por segmentos de retas. Note que não estamos definindo um procedimento desta vez.
>> m:=10: n:=0.5:
>> elipse:=k->polar( [m/(1-n*cos(t)),t], t=0..k );
>> ponto:=t->Point(
>> [m*cos(t)/(1-n*cos(t)), m*sin(t)/(1-n*cos(t))],
>> Color=RGB::Blue, PointWidth=40);
>> segmento1:=t->line([0,0],
>> [m*cos(t)/(1-n*cos(t)), m*sin(t)/(1-n*cos(t))],
>> Color=RGB::Orange);
>> segmento2:=t->line([40/3,0],
>> [m*cos(t)/(1-n*cos(t)), m*sin(t)/(1-n*cos(t))],
>> Color=RGB::Orange );
>> regiao:=Point(-15,-15, Color=RGB::White), Point(15,15,
Color=RGB::White);
>> for i from 0.1 to float(2*PI) step 0.1 do
>> plot( elipse(i), ponto(i), segmento1(i), segmento2(i), regiao,
>> Scaling=Constrained, Labeling=FALSE, Ticks=None); end_for;
35
MuPAD Tutorial
Hipérbole
A hipérbole é o lugar geométrico dos pontos cuja diferença das distâncias a dois pontos fixos é
constante.
Um ramo da hipérbole pode ser parametrizado como r (t ) = x0 +
a 2
b + (t − y 0 )2 , onde (x 0 , y0 ) é seu
b
centro e a, b os semi-eixo ao longo dos eixos X e Y, respectivamente. Assim, plotando [t , r( t )]
teremos um ramo da hipérbole ao longo do eixo X e plotando [ r( t ), t ] teremos um ramo ao longo do
eixo Y. Pela simetria, para plotarmos os dois ramos, basta usar r(t) e –r(t). Consideraremos
(x 0, y0 ) = (1, 2), a = 4, b = 3.
y
5
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
x:=t->x0+a/b*sqrt( b^2+(t-y0)^2 );
2.5
x0:=0;
0
y0:=0;
-7.5 -5
-2.5 0
2.5 5
a:=4;
-2.5
b:=3;
foco:=sqrt(a^2+b^2);
-5
f1:=Point(foco,y0);
f2:=Point(-foco,y0);
referencia:=Curve2d( [x(t),t], t=-7..7, Color=RGB::White);
esquerdo:=i->Curve2d( [x(t),t], t=-6..i);
direito:=i->Curve2d( [-x(t),t], t=-6..i);
l1:=i->line( [foco,y0], [x(i),i], Color=RGB::Orange );
l2:=i->line( [-foco,y0], [x(i),i], Color=RGB::Orange );
L1:=i->line( [foco,y0], [-x(i),i], Color=RGB::Blue );
L2:=i->line( [-foco,y0], [-x(i),i], Color=RGB::Blue );
for i from -5 to 5 do;
pe:=Point( [x(i), i], Color=RGB::Blue );
pd:=Point( [-x(i), i], Color=RGB::Blue );
plot( L1(i), L2(i), l1(i), l2(i), referencia,
esquerdo(i), direito(i), pe(i), pd(i));
end_for
7.5
10
x
BIBLIOGRAFIA
[1]
OEVEL, W., WEHMEIER, GERHARD, J., The MuPAD Tutorial, Paderborn, 2002.
[2]
MOURA, A. O., SANTOS, L. M. R., Introdução ao Maple, Viçosa, 2001.
[3]
BRANDÃO, L. O., WATANABE, C. J., Uma Introdução ao MuPAD, São Paulo, 1997.
[4]
VAZ, C. L. D., Aprendendo MuPAD, Labmac, UFPA, 2001.
[5]
ÁVILA, G., Cálculo 2: funções de uma variável, LTC, Rio de Janeiro, 1989.
36