Tutorial
MuPAD Light 2.5.2
para Windows
Campinas, 2003
1
Índice
1. Introdução ............................................................... 1
2. O que é MuPAD...................................................... 2
3. Download e instalação do MuPAD...................... 3
4. Iniciando o uso do MuPAD................................... 4
5. Funções, derivadas e integrais ............................ 12
6. Gráficos em duas dimensões............................... 15
7. Gráficos em três dimensões................................. 25
8. Tabela de comandos úteis ................................... 30
Tutorial do MuPAD Light v2.5.2 para Windows
Por André Oliveira Maroneze
RA 023146
MA211 — Turma K
Setembro de 2003
1
1. Introdução
Este tutorial tem por objetivo ensinar usuários iniciantes a
desfrutar dos principais recursos do pacote de software MuPAD, que
dispõe de poderosas ferramentas matemáticas para diversos níveis, de
alunos a profissionais.
O tutorial não visa expandir conceitos aprofundados ou
ferramentas de uso específico; tampouco cobrirá todas as inúmeras
possibilidades do software. O enfoque principal será dado à
manipulação de ferramentas de um curso de Cálculo, tais como
derivadas, integrais, manipulação de funções e uso de gráficos.
O tutorial explicará o que é MuPAD e como surgiu; onde encontrálo e quais os requerimentos para seu uso; porque preferi-lo a outros
softwares matemáticos; como realizar as operações básicas e, depois, as
necessárias a um curso de Cálculo. Ao fim, há uma tabela com os
principais comandos, para servir de referência rápida.
Espera-se que, com a difusão do conhecimento e das possibilidades
de softwares de uso gratuito, possam as pessoas usufruir de produtos
melhores e mais acessíveis no futuro. A ciência não deve servir ao
capital, mas às mentes humanas.
2
2. O que é MuPAD
MuPAD é um sistema algébrico computacional originalmente
desenvolvido pelo MuPAD Research Group na Universidade de
Paderborn (Alemanha), sob a direção do Professor B. Fuchssteiner.
O projeto teve início em setembro de 1989, com a tese de mestrado
de Karsten Morisse e Oliver Kluge. Andreas Kemper, em sua tese de
mestrado, desenvolve a linguagem de programação MuPAD, semelhante
em diversos aspectos ao Pascal — linguagem de programação de
aprendizado relativamente fácil.
O nome original — mupas — foi substituído em 1990 por MuPAD
(Multi Processing Algebra Data Tool, ferramenta de multiprocessamento de
dados algébricos). Além da sigla, o sufixo incorpora o local de origem do
projeto (Universidade de Paderborn).
Com os anos, o software vai sendo difundido e aprimorado.
Surgem versões para Macintosh e, mais tarde, para Unix. Pesquisadores
desenvolvem teses e pacotes, expandindo as possibilidades de uso. Em
1995, surge a versão para Windows.
Atualmente (agosto de 2003), existem duas versões para Windows:
MuPAD Pro (v 2.5.3) e Light (v 2.5.2). Além destas, há versões para
Linux, Macintosh e Solaris, todas distribuídas pela SciFace (SciFace
Software GmbH & Co. KG, fundada em 1997). A versão Pro do Windows
dispõe de uma interface mais amigável e pode ser utilizada para fins
comerciais, mas não é gratuita: usuários comerciais devem pagar US$
500,00 por uma licença individual; usuários governamentais ou
acadêmicos pagam US$ 300,00, e alunos, US$ 100,00. Pode-se
experimentar essa versão por 30 dias com recursos limitados.
Felizmente, existe a versão Light, cujas ferramentas são mais que o
suficiente para os propósitos anteriormente mencionados. Essa versão é
gratuita para estudantes, professores, funcionários de empresas
filantrópicas e grupos de pesquisa sem fins lucrativos. O presente
tutorial refere-se a essa versão.
3
3. Download e instalação do MuPAD
Através do site www.mupad.com é possível realizar o download
do programa. A versão atual (2.5.2) encontra-se no link
ftp://ftp.mupad.de/MuPAD/distrib/windows/mupad_light_252.exe e tem
14.3 Mb (o programa ocupa aproximadamente 30 Mb depois de
instalado). Ela funciona em Windows 95, 98, ME (Millennium), NT 4.0,
2000 e XP (só não existem versões para Windows 3.1). Aconselha-se
visitar o site, e não diretamente o link para o arquivo, para se obterem
informações sobre o programa e sobre possíveis novas versões.
Em seguida, é necessário realizar o registro do programa (para
usuários que se encaixam nas especificações de uso gratuito, descritas no
final do capítulo anterior). Do contrário, ele funciona por apenas 30 dias,
com
algumas
limitações
de
uso
de
memória.
Em
http://www.sciface.com/mupad_download/ há um formulário para ser
preenchido e enviado. Dependendo de quando se realiza o registro, ele
pode demorar alguns dias. Uma senha de desbloqueamento é enviada
para o e-mail do usuário após esse período, mas já é possível executar o
programa logo após a instalação.
4
4. Iniciando o uso do MuPAD
Após instalado, o MuPAD cria um atalho no menu Programas.
Ele cria atalhos para o programa em si (MuPAD Light), para um
documento de referência à versão Pro e para um tutorial da versão 2.0 e
posteriores (em inglês). Há também os acessórios, como o visualizador
dos arquivos de ajuda do MuPAD (que podem conter links que levam de
uma página à outra da ajuda, uma ferramenta extremamente útil) e a
ferramenta VCam Light (para visualização de gráficos 3D), que será
explicada mais tarde.
Uma vez aberto o programa, surge uma janela informando quantos
dias restam do período de avaliação gratuita. Essa janela não surgirá
depois que as informações do registro (nome e senha) forem atualizadas.
Para isso, basta clicar no menu Help > Register….
A tela do programa contém os menus, alguns botões e o prompt de
comando.
5
Cada linha do prompt começa com um símbolo ’Ÿ’. Os comandos a
serem executados (input) aparecem em vermelho, enquanto as respostas
do programa (output) surgem em azul. Isso é o padrão, mas pode ser
modificado no menu View > Options: botões Input Regions e Output
Regions.
Infelizmente, um comando avaliado não pode ser modificado e reutilizado na mesma linha; é preciso copiá-lo para a linha corrente do
prompt e modificá-lo, então avaliá-lo novamente.
Cada vez que se quer avaliar uma linha, basta teclar <Enter>. Podese também dividir um comando em diversas linhas, teclando
<Shift>+<Enter>, como no exemplo abaixo:
Ÿ sin
(Shift+Enter)
Ÿ (PI/2)
(Enter)
1
Esse conjunto de linhas é equivalente a:
Ÿ sin(PI/2)
(Enter)
1
Preste atenção às letras; comandos costumam ser escritos todos em
minúsculas, opções costumam ter a inicial em maiúscula e algumas
variáveis são inteiras em maiúsculas. O tutorial descreve os comandos
da forma exata que devem ser escritos. Os sinais de espaço entre alguns
comandos e opções servem para facilitar a legibilidade, mas nem sempre
são necessários.
As operações usuais são escritas como em quase todos os sistemas
computacionais:
Adição: +
Subtração: Multiplicação: *
Divisão: /
Exponenciação: ^
Podem-se inserir parênteses dentro de outros; colchetes e chaves
têm outras funções. Funções trigonométricas básicas, constantes p, ä e ã,
raízes, logaritmos e função módulo são definidos como a seguir:
sin(x)(sen x), cos(x)(cos x), tan(x)(tg x)
6
PI (3.14... - note-se que deve ser escrito com ambas as letras
maiúsculas)
I (i, a unidade imaginária (i2=-1))
E (o número e, também representado por exp(1))
sqrt(x)(raiz quadrada de x, ou x1/2)
log(b,x)(log b x), ln(x)(ln x, ou log e x)
abs(x)(|x|)
Exemplo de uma equação, na forma tradicional1 e como poderia ser
escrita no MuPAD:
2 x 5 − y − [k + 2(log 5 x − sin x)]
π
tan e z
PI*((2*x^5-sqrt(y)-(k+2-(log(5,x)-sin(x))))/tan(E)^z)
Dois comandos muito úteis são o info e o help. O comando
info mostra brevemente o que faz determinado comando ou, no caso de
uma variável, mostra suas propriedades. Veja o exemplo a seguir:
• info(ln)
ln -- the natural logarithm
• info(x)
x -- an unprotected identifier without properties
• x:=2
2
• info(x)
2 -- of domain type 'DOM_INT'
O comando info requer um parâmetro entre parênteses.
Note que atribuímos o valor 2 à variável ‘x’ usando ‘:=’, que é o
comando utilizado para atribuição de valores às variáveis. Um sinal de
igual (‘=’) apenas representa a igualdade em equações.
O MuPAD diferencia letras maiúsculas de minúsculas, e permite
definir palavras como variáveis. x, X, x1, X1 e valor_de_x são todos
nomes válidos e diferentes de variáveis.
1
As palavras ‘sin’ e ‘tan’ referem-se a seno e tangente, respectivamente, que costumam ser denotadas por ‘sen’ e
‘tg’.
7
O comando help chama o MuPAD Help Browser, uma janela que
permite explorar os tópicos de ajuda e encontrar mais informações sobre
os comandos.
O comando help requer um parâmetro entre parênteses e entre
aspas, conforme é visível na imagem. Um modo mais fácil de usá-lo é
digitar um ponto de interrogação (‘?’) antes da palavra a ser pesquisada.
help(“info”)e ?info são equivalentes.
O MuPAD tem por padrão utilizar manipulações algébricas
sempre que possível. Por exemplo, se desejarmos saber quanto vale ln 2,
e digitarmos:
• ln(2^3)
Por ser um número inexato, e para melhorar a precisão dos
cálculos em diversas situações, o MuPAD retorna simplesmente:
ln(8)
Se quisermos um valor numérico para a expressão, precisaremos
usar a função float, como a seguir:
• float(ln(8))
2.079441542
8
Outra solução é denotar os números como sendo variáveis de
ponto flutuante, isto é, valores numéricos e não algébricos. No exemplo
acima, bastaria digitar ln(8.0)para se obter a mesma saída. Nos casos
em que isso não for possível, no entanto, é necessário usar a função.
Existe uma variável definida pelo programa chamada DIGITS, que
representa a quantidade de casas decimais a serem impressas toda vez
que um valor numérico é desejado. Seu valor padrão é 10, mas basta
atribuí-la outro valor (Ex: DIGITS:=100) para que os valores sejam
expressos nessa precisão. Por exemplo:
• DIGITS:=100; ln(8.0)
100
2.079441541679835928251696364374529704226500403080765
762362040028480180865\
909084146817589980989256063
A barra invertida (‘\’) surge no prompt do MuPAD quando a saída
de algum comando é grande demais para caber em apenas uma linha.
Como o tamanho da linha deste arquivo é diferente, a barra aparece
depois da primeira linha. Para ajustar o valor de caracteres a serem
mostrados em uma única linha, basta ir no menu Session > Text Width…
e mudar o valor. Isso facilita quando a linha é grande demais para caber
na tela, ou quando se quer que uma expressão extrapole a tela sem
quebrar (para, por exemplo, copiá-la em outro lugar sem necessidade de
remover as barras).
Para remover o valor atribuído a uma ou mais variáveis, o
comando delete é usado. Veja o exemplo:
• x; y
x
y
• x:= PI; y:= 3
PI
3
• cos(x); y+2
-1
5
• delete x, y
• cos(x); y-2
9
cos(x)
y - 2
Há a função last(n), cujo valor é igual ao do n-ésimo output na
ordem inversa, isto é, 1 é o último, 2 o penúltimo, e assim por diante. No
caso de last(1), existe uma simplificação, que é ‘%’. Veja o exemplo:
• 3+4+5
12
• 2*last(1)
24
• last(2)/3
4
• %*3
12
• last(2)/3
4/3
Note que o valor de last(n) é atualizado a cada saída. Por essa
razão, ele pode ser usado para simular iterações simples ou calcular
progressões termo a termo.
Para a resolução de equações e sistemas, existe o comando solve. Se
inserida apenas uma equação, basta digitar solve(equação) que ele
definirá automaticamente a variável e o seu valor. Caso haja mais de
uma variável, ele expressará as demais em função da primeira (em
ordem lexicográfica, isto é, de ‘A’ (maiúsculo) até ‘Z’ (maiúsculo), então
d ‘a’ (minúsculo) até ‘z’ (minúsculo). Variáveis com nomes mais curtos
costumam vir antes das demais.). Com solve(equação, variável),
obtém-se o resultado expresso na variável desejada. Veja exemplos:
•
solve(x^2-6*x+5=0)
{[x = 1], [x = 5]}
• solve(x^2-6*x+5=0, x)
{1, 5}
• solve(x+3*y-z=2)
{[x = z - 3*y + 2]}
• solve(x+3*y-z=2, z)
{x + 3*y - 2}
• solve(x^2+4=0)
{[x = -2*I], [x = 2*I]}
10
•
solve(receita - custo = lucro + impostos)
{[lucro = receita - custo - impostos]}
Para inserir conjuntos de equações ou variáveis, basta envolvê-los
por chaves. Uma alternativa por vezes mais prática de resolver sistemas
é dividir as equações em um conjunto, separadas por vírgulas, e as
incógnitas em outro, e então usar solve(equações, incógnitas),
conforme o exemplo:
• equacoes := {x + 2*y - 3*z = 2, 3*x - 2*y + z/2 = 4,
x/2 + y = 2}
{x + 2*y - 3*z = 2, 1/2*x + y = 2, 3*x - 2*y + 1/2*z
= 4}
• incognitas := {x, y, z}
{x, y, z}
• solve(equacoes, incognitas)
{[x = 23/12, y = 25/24, z = 2/3]}
Há duas funções muito úteis nas manipulações algébricas: expand
e simplify. A primeira serve para desenvolve expressões, enquanto a
segunda procura simplificar ao máximo expressões dadas. É sempre
conveniente adicionar um simplify(%) ao fim de extensas
manipulações de expressões algébricas. Segue abaixo um exemplo de
ambas.
• expand(cos(x-y)*sin(x+y))
cos(x)*cos(y)^2*sin(x) + cos(x)^2*cos(y)*sin(y) + \
cos(x)*sin(x)*sin(y)^2 + cos(y)*sin(x)^2*sin(y)
• simplify(%)
1/2*sin(2*x) + 1/2*sin(2*y)
• expand(%)
cos(x)*sin(x) + cos(y)*sin(y)
Como se pode perceber, o segundo expand não retornou à
expressão original, mas a outra equivalente.
Quando alguma expressão é digitada de forma incorreta, aparece
uma mensagem de erro especificando a linha (no caso de uma entrada
dividida em várias linhas) e a coluna (às vezes, vale a pena contar os
caracteres para encontrar o erro, quando a expressão é muito longa ou
complexa). Abaixo seguem dois exemplos de erros comuns: no primeiro,
11
faltou o sinal de multiplicação entre o 2 e o PI; no segundo, esqueceu-se
de colocar um ‘)’ à direita do último:
• f := x + y - 3*z^2 / 2PI
Error: Unexpected 'identifier' [line 1, col 25]
• sin(x)+4(cos(x)/3+(2-(1/x))
Error: ')' expected [line 1, col 28]
Com isso, concluímos as funções e manipulações básicas do
MuPAD. Com os conhecimentos adquiridos até então, já podemos
realizar manipulações algébricas e cálculos numéricos não muito
complexos. Prosseguiremos com ferramentas de Cálculo e funções.
12
5. Funções, derivadas e integrais
Funções no MuPAD podem ser definidas facilmente usando-se os
símbolos ‘->’. Em seguida, basta digitar o nome da função e o valor da
variável para se obter o resultado. Veja o exemplo:
• f := x -> 2*x^3
x -> 2*x^3
• f(2)
16
• f(3.5)
85.75
Funções de várias variáveis são definidas com as variáveis entre
parênteses, como no exemplo:
• f := (x,y,z) -> 2*x + y^3 - 1/z
(x, y, z) -> (2*x + y^3) - 1/z
• f(2,3,4)
123/4
Funções compostas são definidas através da definição de uma
função sobre a outra, como a seguir:
• g := f + 2
(x -> 2*x^3) + 2
• g(2)
18
A derivada dessas funções é rapidamente calculada usando o
operador D ou o apóstrofo (’) — ambos são equivalentes. Veja os
exemplos a seguir:
• f'
6*id^2
•
D(f)
6*id^2
Note que o id presente nas respostas refere-se à variável da
função, isto é, id pode ser qualquer variável, já que a função não está
definida em termos de apenas um “x”. Podemos pensar em f como
sendo f(x); nesse caso, id seria x, portanto f’(x) = 6x2.
13
Existe também o comando diff(função,
realiza derivadas de funções explícitas:
• diff(sin(x),x)
cos(x)
variável), que
D e diff ambos realizam diferenciação, mas funcionam em
situações diferentes. Usar D(sin(x)), por exemplo, não funcionaria do
modo desejado, enquanto que a linha diff(f(x),x) não teria
problemas. No primeiro caso, o operador interpreta x como um valor
desconhecido, e portanto permanece com ele, diferenciando apenas o
resto da função. Veja um exemplo:
• D(sin(2*x)^2)
2*sin(2*x)*D(sin(2*x))
Repare que ainda há um D na função — o operador não
compreende que x é uma variável. Se tivesse sido usado diff, a função
seria diferenciada sem problemas. Esse mesmo comando também
calcula derivadas parciais em funções de diversas variáveis, enquanto
que o operador D não o faz.
Há, ainda, a possibilidade de se calcularem derivadas de ordem
superior facilmente. No caso de haver uma função definida, basta inserir
diversos apóstrofos; no caso do comando diff, é necessário adicionar
um novo parâmetro: diff(função, variável $ n), onde n é a
ordem da derivada. Veja os exemplos a seguir:
• f := x->x^7; f'''''
x -> x^7
2520*id^2
• diff(x^7, x $ 5)
2520*x^2
Para a integração, existe o comando int.
int(função, variável) retorna a integral indefinida da
função, enquanto int(função, variável = mínimo..máximo)
(repare nos dois pontos (‘..’), que indicam intervalo) retorna o valor da
integral definida naquele trecho, conforme os exemplos:
• int(3*x^2, x)
x^3
• int(3*x^2, x = -1..2)
9
14
Caso a função seja descontínua no intervalo, ocorrerá um erro:
• int(1/x,x=-1..0)
Warning: Antiderivative is unbounded at upper limit
[intlib::antiderivative]
- I*PI - infinity
O cálculo dos limites ajuda a encontrar tais descontinuidades.
Existem três formas de usar a função limit:
limit(f, x = x0): calcula o limite bidirecional de f em x(se
existir);
limit(f, x = x0, Left): calcula o limite de f em x pela
esquerda (se existir);
limit(f, x = x0, Right): calcula o limite de f em x pela
direita (se existir).
Exemplos:
• limit(1/x, x=0, Left)
-infinity
• limit(1/x, x=0, Right)
infinity
• limit(1/x, x=0)
undefined
De posse desses conhecimentos de Cálculo, podemos realizar
diversas operações com funções. Seria interessante fazer gráficos delas, e
isso será ensinado no próximo capítulo.
15
6. Gráficos em duas dimensões
Os gráficos no MuPAD são todos realizados através da biblioteca
plot e exibidos na VCam Light. Há basicamente dois modos de
operação da câmera, um para gráficos 2D e outro para gráficos 3D. O
primeiro tem apenas controle de zoom, enquanto que o segundo permite
rotacionar a imagem.
Clicando no atalho Tools > VCam Light Demo, o programa será
aberto com um exemplo: a garrafa de Klein. Quando se está usando o
MuPAD, qualquer comando plot também abrirá o VCam, a menos que
o comando esteja incorreto. A janela principal do programa está
mostrada abaixo.
Qualquer gráfico pode ser salvo como uma imagem no formato VC
e aberto sem a necessidade de se executar o MuPAD. A barra de
ferramentas contém os principais botões para a manipulação de gráficos
3D:
16
Os dois primeiros (que são os únicos que funcionam em gráficos
2D) permitem ampliar ou reduzir a imagem. Os quatro seguintes
permitem girar gráficos 3D para se conseguir um ângulo melhor. Os
dois últimos mudam a perspectiva, como se o observador estivesse mais
perto ou mais longe da imagem.
Existem diversas opções de construção de gráficos que permitem
mudar o aspecto e as cores. O MuPAD pode plotar curvas 2D e 3D,
superfícies, curvas de nível e campos vetoriais.
Existem outros comandos além do plot. Eles permitem plotar
funções mais rapidamente, sem a necessidade de especificação de
muitos parâmetros, mas são mais limitados.
Por exemplo: para plotar a parábola f(x) = x2:
• f := x -> x^2
x -> x^2
• plotfunc2d(f)
E temos o gráfico da parábola:
17
Há várias opções para alterar o gráfico. Por exemplo, poderíamos
determinar os intervalos de x e de y:
• plotfunc2d(f, x = -2..2, y = 0..0.5)
As escalas usadas são escolhidas pelo computador, mas podemos
forçá-las a serem idênticas (isso é muito útil para plotar funções como
circunferências, quando o ajuste automático tende a achatá-las em
elipses):
• f := x -> sqrt(1 - x^2)
x -> sqrt(1 - x^2)
• plotfunc2d(f, x = -2..2, y = -2..2,
Scaling = Constrained)
Note que determinar o intervalo de
plotagem é opcional. plotfunc2d(f, Scaling
= Constrained)funcionaria também, mas o
intervalo adotado pelo programa seria x = [-1,1] e
y = [0,1].
Às vezes, é útil exigir maior precisão do computador; ou pode ser
melhor remover pontos excessivos para fazer gráficos mais rápido.
Nesses casos, a opção Grid = n é utilizada. Compare dois gráficos da
mesma função, um usando 100 pontos e outro usando 1000:
• plotfunc2d(x*sin(1/x), x=-0.1..0.1, y=-0.1..0.1,
Grid=100) ↓
↑
• plotfunc2d(x*sin(1/x), x=-0.1..0.1, y=-0.1..0.1,
Grid=1000)
18
Os erros de aproximação numérica são bem mais visíveis na
função à esquerda que na da direita. Mas o excesso de pontos pode
atrapalhar em alguns casos.
Existem diversas opções, mas muitas delas referem-se à aparência
e não são tão importantes. Apenas como exemplo, podemos mudar as
linhas, adicionar marcas, sentido dos eixos, entre outras opções:
• plotfunc2d(x*sin(1/x), x=-0.1..0.1, y=-0.1..0.1,
Grid = 200, GridLines = Automatic, LineStyle =
DashedLines, Ticks = 10, Arrows = TRUE)
Geralmente, as opções podem ser adicionadas todas no início ou
todas no fim. O comando ?plotOptions2d informa mais sobre opções de
plotagem.
Podemos usar o comando plot2d para curvas parametrizadas.
Podemos tanto definir uma função parametrizada anteriormente e plotála depois, quanto defini-la na mesma hora da plotagem. Por exemplo:
• x := w -> cos(w); y := u -> sin(2*u);
f := [Mode = Curve, [x(t), y(t)], t=[-PI, PI]];
• plot2d(f)
As três linhas de comando acima produzirão o mesmo que:
• plot2d([Mode=Curve,[cos(t),sin(2*t)], t=[-PI,PI]])
19
Preste atenção para não esquecer de fechar nenhum colchete.
Repare também que o intervalo, agora, é definido na forma x = [a,b],
enquanto que antes era x = a..b.
É possível definir pontos e formas geométricas para compor
diversas funções em um único gráfico, na forma de uma lista (Mode =
List). Veja o exemplo abaixo:
• P := point(1.1,0); Q := point(0.8,0.502); R :=
point(0.5,1.04);
• S := point(0,1.56); T := point(-0.5,2.03); U :=
point(-0.8, 2.5);
• V := point(-1, 3.1)
• lista := [Mode = List, [P, Q, R, S, T, U, V]];
• curva := [Mode = Curve, [cos(x), x], x=[0,PI]]
• plot2d(PointStyle = Circles, PointWidth = 100,
lista, curva)
Se quisermos mudar a curva, basta re-atribuir a variável curva
com as novas opções e re-enviar o comando plot2d:
• curva := [Mode = Curve, [cos(x), x], x=[0,PI],
Color=[Height, [0.8,0.8,0.8], [0.2,0.2,0.2]],
LineWidth=50];
plot2d(PointStyle = Circles, PointWidth = 100, lista,
curva)
20
Uma breve explicação sobre a opção Color, que é meio trabalhosa
de usar mas melhora bastante a aparência de alguns gráficos:
Color = [R, G, B] define a cor dos pontos/curvas. São
necessários três números, que variam de 0 a 1, e especificam a
quantidade de cada cor (vermelho, verde e azul) que comporão os
pontos. [0,0,0] corresponde a preto e [1,1,1] é branco. O MuPAD
conta com algumas variáveis pré-definidas para as cores, que podem ser
acessadas usando-se RGB::Cor (RGB::White, por exemplo). Existem
três modos de coloração: Flat (cor única), Height (gradiente, que varia
conforme a altura) e function (função definida pelo usuário). Em geral,
a Height é a mais utilizada, por dar a alguns gráficos uma aparência
melhor.
Do mesmo modo que plotamos pontos, podemos plotar polígonos,
que nada mais são que conjuntos de pontos. O comando é quase igual,
exceto que devemos adicionar um polygon(a, b, c, <opções>) à
lista, como no exemplo:
• a := point(0,3); b :=
point(2,-3); c := point(3,1);
d := point(3,1); e := point(-2,
-3)
• estrela := [Mode = List,
[polygon(a, b, c, d, e,
Filled = TRUE, Closed = TRUE,
Color = RGB::Gray)]]
• plot2d(Scaling = Constrained,
estrela)
A função polygon tem as opções filled (preenchido) e closed
(fechado).
Se a ordem dos pontos fosse mudada, o polígono resultante seria
bem diferente. Observe também que, no caso do plot2d, é necessário
colocar as opções antes dos objetos a serem plotados.
21
Finalmente chegamos ao comando plot. Ele possui diversas
opções e modos de plotagem, de forma que praticamente qualquer
objeto pode ser plotado com ele. Começaremos com a função implícita
x3+y3, usando para isso a função plot e a opção plot::implicit:
• plot(Scaling = Constrained, plot::implicit(x^3+y^33*x*y, x=-2..3, y=-2..3))
Podemos criar um conjunto de isotermas dessa mesma função
adicionando a opção Contours = [$ a..b]. Contours aceita um
conjunto de valores separados por vírgulas, mas se usarmos o operador
$ e um intervalo separado por ‘..’, o MuPAD gerará um conjunto de
números inteiros no intervalo especificado. Ou seja, $ 1..3 é a mesma
coisa que digitar 1, 2, 3. Assim, aplicando isso à função, temos:
• plot(Scaling = Constrained, plot::implicit(x^3+y^33*x*y, x=-2..3, y=-2..3, Contours = [$ -3..3]))
22
O MuPAD escolhe automaticamente um conjunto de cores. Mas
existe a opção plot::contour, que é mais adequada para esse tipo de
imagem. Reciprocamente, ela também imprime funções implícitas, mas o
gráfico pode sair um pouco distorcido, mesmo que adicionemos várias
linhas de contorno (o padrão são 8 linhas):
• plot(Scaling = Constrained, plot::contour([x, y,
x^3+y^3-3*x*y],
x=-2..3, y=-2..3, Contours=40))
Observe a sintaxe do comando: plot::contour([x,
y,
função], x = a..b, y = c..d).
Gráficos gerados por plot::contour costumam ficar melhores
quando as cores são ajustadas de acordo com a altura (nível das curvas).
Além disso, existe a opção Style = Attached, que gera uma imagem
tridimensional das curvas:
• plot(Scaling = Constrained, plot::contour([x, y, (x^2+y^2)], x=-1..1, y=-1..1, Contours=20, Style =
Attached, Colors = [Height]))
23
Em breve, veremos mais detalhes de gráficos tridimensionais.
Antes, vamos concluir a plotagem de gráficos bidimensionais com o
plot::vectorfield. Ele cria campos vetoriais bidimensionais. Veja
um exemplo:
• plot(plot::vectorfield([x*sin(1/x),cos(x)], x=-5..5,
y=-5..5, Grid = [20,20]))
A quantidade de vetores é definida por Grid = [x,y]. Uma
utilidade dos campos vetoriais é servirem como campos direcionais.
Podemos associar a eles outras funções e plotá-los junto de outros
gráficos, como complemento. Além disso, as componentes dos vetores
podem depender tanto de x quanto de y como no exemplo abaixo:
24
• V := plot::vectorfield([y,-x], x=-2..2, y=-2..2,
Grid=[15,15])
• C := plot::contour([x, y, x^2+y^2], x = -2..2, y = 2..2, Contours = 12)
• plot(Scaling = Constrained, V, C)
Caso se queira plotar uma função junto com outros objetos através
do comando plot (sem usar o plot2d ou o plotfunc2d), é necessário
usar a opção plot::Function2d, conforme o exemplo ilustra:
• plot(plot::Function2d(cos(x), x = -2*PI..2*PI,
Color = [0,0,1]), plot::contour([x, y,
y-cos(x)],
x = -6..6, y = -2..2))
25
7. Gráficos em três dimensões
Os únicos gráficos tridimensionais vistos até agora foram a garrafa
de Klein e a função das curvas de nível. Agora veremos como plotar
curvas, superfícies e funções parametrizadas.
A maioria dos comandos de gráficos 3D é análoga ao dos gráficos
2D, com uma variável extra e algumas opções diferentes. Veja um
exemplo com plotfunc3d (foram plotadas duas funções
simultaneamente, e uma independe de y):
Uma das maiores vantagens dos gráficos tridimensionais no
MuPAD é que é possível ajustar em tempo real o ângulo de visão.
Existem opções que indicam o ângulo de visão a ser plotado, mas elas
não serão comentadas por serem praticamente desnecessárias.
As opções de estilo dos gráficos podem ser adicionadas na linha de
comando ou modificadas nas janelas de opção (através do menu View >
Options...), mas no último caso é necessário reiniciar o MuPAD para que
as opções sejam atualizadas2. Cada gráfico de exemplo mostrará um
aspecto diferente, para que se tenha noção das possibilidades do
programa.
2
Não há referência clara a isso nos arquivos de ajuda do MuPAD, o que me leva a crer que possa ser algum erro
que ocorreu em minha instalação. Mesmo assim, é possível que o botão Apply seja funcional apenas na versão
Pro ou em outros sistemas.
26
A primeira janela de opções permite mudar o estilo dos eixos
(nenhum, origem, canto, caixa), a quantidade de marcas em cada eixo
(Ticks), se o sentido dos eixos deve ser indicado por setas, as cores de
frente e fundo, os rótulos dos eixos e se a escala deve ser igual em todos
os eixos ou não.
27
A segunda janela é a mais importante: nela estão os estilos das
curvas, superfícies e pontos. Todas podem ser modificadas nos próprios
comandos, mas caso se queira ajustar o padrão, é melhor modificar na
janela.
É fácil criar curvas ou superfícies parametrizadas com o comando
plot3d. Análogo ao plot2d, ele aceita tanto objetos do tipo Curve (com 1
parâmetro) como Surface (com 2 parâmetros). Veja o exemplo:
• espiral := [Mode = Curve, [1.1*cos(12*t)*sin(t),
1.1*sin(12*t)*sin(t), 1.1*cos(t)],
• t=[0,PI], Grid = [100], Smoothness = [10]]
• esfera := [Mode = Surface, [sin(u)*cos(t),
cos(u)*cos(t), sin(t)],
• t = [0, 2*PI], u = [0, 2*PI], Style = [HiddenLine,
Mesh]]
• plot3d(Scaling = Constrained, esfera, espiral)
Repare que a opção Grid contém o número entre colchetes Para
superfícies, Grid pode conter dois números, um para cada eixo (x e y). A
opção Smoothness (também funcional em duas dimensões) define
quantos pontos de intercalação devem ser plotados entre cada ponto da
grade, para melhorar o ajuste de curvas. Um número excessivo de
pontos pode aumentar enormemente o tempo de plotagem.
28
A opção em negrito (Style) foi realçada para que se note a
diferença dela para a superfície anterior. Há diversos modos de estilo
para superfícies tridimensionais.
Do mesmo modo que existe a plot::Funcion2d, existe a
plot::Function3d,
e
a
plot::Curve3d
(para
curvas
parametrizadas), similar à plot::Curve2d (todas usadas com o
comando plot). Veja um exemplo de cada uma das formas
tridimensionais:
• mola := plot::Curve3d([cos(6*t), sin(6*t), t], t = 8..8, LineWidth=30, Color=[Flat, [0.5,0.5,0.5]]);
• onda := plot::Function3d(sin(x)*cos(y) +
sin(y)*cos(x), x = 0..PI, y = 0..PI);
• onda::Style := [WireFrame, ULine];
• plot(onda, mola)
Não há muita novidade nos comandos apresentados, exceto a
atribuição do estilo após a declaração do objeto. onda foi atribuído com o
gráfico de uma função tridimensional no estilo padrão. Depois de criada,
pudemos atribuir à sua propriedade Style (através de onda::style) novas
propriedades (note o símbolo de atribuição em oposição ao de igual
usado na mola). Com isso, torna-se mais fácil mudar algumas
propriedades caso o gráfico não tenha saído do modo desejado.
29
Infelizmente, o MuPAD não plota curvas de nível tridimensionais.
Uma alternativa seria plotar diversos gráficos tridimensionais de
tamanhos variados, simulando curvas de nível tridimensionais, mas a
opção de estilo Transparent não foi ainda implementada na versão
Windows. Em todo caso, com os conhecimentos adquiridos, podem-se
tentar diversas alternativas, como plotagem de superfícies eqüidistantes
com cores diferentes. Sem dúvida, seria trabalhoso.
O MuPAD ainda é capaz de plotar histogramas, matrizes, funções
em coordenadas polares, cilíndricas e esféricas; mas todas essas funções
são sub-opções do comando plot, e como não são tão importantes para
este tutorial (além de que basta pesquisar na ajuda para descobrir como
funcionam, visto que os principais termos do programa já são
conhecidos), não serão tratadas especificamente. Há, inclusive, funções
que mostram aproximações de Riemann e Simpson para integrais.
Aqui terminam as lições do tutorial. Com o que foi explicado, é
possível realizar a maior parte das operações necessárias a um curso de
Cálculo I-II, e é possível visualizar diversas das funções e equações
comumente vistas. Há muito mais de que o MuPAD é capaz, mas para
algumas soluções é necessária muita criatividade e capacidade de
abstração (paciência ajuda muito).
telhado := plot::Function3d
• (2-abs(x)^(0.3)+2-abs(y)^(0.3),
• x = -2..2, y = -2..2);
• telhado::Style := [ColorPatches,
• AndVLine];
• torre := plot::Surface3d(
• [1.7*cos(t), 1.7*sin(t), s],
• t=[0,2*PI], s = [-3,1.9],
• Color = [Height, [0.5, 0.165,
• 0.165], [0.7,0.9,0.7]]);
• torre::Style := [ColorPatches,
• Only];
plot(Scaling = Constrained, telhado, torre)
30
8. Tabela de comandos úteis
Nota: Itens em azul são opcionais. Barras “\” indicam que se deve
optar por algum dos itens.
Funções/Constantes
Módulo: abs(x)
Raiz quadrada: sqrt(x)
Logaritmo (x na base b): log(b, x)
Exponencial: exp(x)
Funções trigonométricas: sin(x), cos(x), tan(x), sec(x), csc(x), cot(x)
Funções hiperbólicas: sinh(x), cosh(x), tanh(x), sech(x), ...
Funções trigonométricas inversas: arcsin(x), arccos(x), arctan(x), ...
Unidade imaginária (i): I
Número de Euler (e): E
Número pi: PI
Precisão decimal exibida: DIGITS := n
Comandos úteis e regras de sintaxe
Atribuição: :=
Declaração de função: f := x -> ???x (Ex: f := x -> 2*x)
Declaração de seqüência: $ a..b
Informação sobre variáveis/comandos: info(expressão)
Ajuda detalhada: help(“expressão”) ou ?expressão
Resolução de equações/sistemas:
solve({x+y+z...=a, x+y+z...=b, ...}, {x, y, z})
Re-utilização de última saída: last(1) ou %
Simplificação de expressões: simplify(expressão)
Desenvolvimento de expressões: expand(expressão)
Remoção de valor de variáveis: delete x, y, z...
Cálculo
Limites: limit(f, x = a, Left\Right)
Derivação: diff(f, x)
Integração: int(f, x = a..b)
31
Funções de gráficos
Plotagem geral: plot(objeto)
Plotagem de funções de 2 dimensões: plotfunc2d(f, x = a..b)
Plotagem de funções de 3 dimensões: plotfunc3d(f, x = a..b, y = c..d)
Plotagem de gráficos de 2 dimensões: plot2d([Mode = tipo, [...])
Plotagem de gráficos de 3 dimensões: plot3d([Mode = tipo, [...])
Objetos para a função plot:
Funções implícitas:
plot::implicit([expr1, expr2, ...], x = a..b, y = c..d)
Curvas de nível:
plot::contour([x, y, z], s = a..b, t = c..d, Contours = [e..f])
Campos vetoriais: plot::vectorfield([vx, vy], x = a..b, y = c..d)
Funções 2D: plot::Function2d(f, x = a..b)
Funções 3D: plot::Function3d(f, x = a..b, y = c..d)
Curvas 2D parametrizadas: plot::Curve2d([x, y], t = a..b)
Curvas 3D parametrizadas: plot::Curve3d([x, y, z], t = a..b)
Superfícies parametrizadas:
plot::Surface3d([x, y, z], s = a..b, t = c..d)
Opções de gráficos3
GridLines = [None\Automatic] (apenas para gráficos 2D)
LineStyle = [SolidLines\DashedLines]
LineWidth = n
PointStyle = [Circles\Squares\FilledCircles\FilledSquares]
PointWidth = n
Scaling = [Constrained\Unconstrained]
Ticks = [Automatic\None]
Outras opções
Estas opções estão disponíveis em algumas funções de plotagem e são
extremamente úteis.
Color = [R, G, B]
Grid = n
Grid = [x, y]
Smoothness = [n]
3
Foram listadas apenas as opções mais usadas. Algumas podem ter outros valores a elas atribuídos, porém
apenas os mais usados estão listados.