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 re-utilizado 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>. Pode-se 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: 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’.

zexxkyx

tan)]sin(log2[2 5

5 −+−−π

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.079441541679835928251696364374529704226500403080765762362040028480180865\ 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, variável), que realiza derivadas de funções explícitas: • diff(sin(x),x) cos(x) 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^3-3*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^3-3*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.