Universidade Estadual de Campinas - UNICAMP
Leonardo Loures Lopes
RA 024307
Engenharia de Computação
MA211 – Turma K
Professor Márcio Antônio de Faria Rosa
Tutorial do MuPAD Light 2.5.2
Baixando
Para baixar o software MuPAD, entre no site www.mupad.de
Já na tela de abertura, clique na figura
e logo após clique em
Você será levado para uma tela com diversas opções de download. Escolha aquela que
corresponda ao seu Sistema Operacional. Este tutorial foi feito utilizando a versão MuPAD
Light 2.5.2 for Windows.
Instalando
Após baixar o programa, instala-lo é bastante simples. Siga as instruções. Leia o termo de
compromisso do programa. Se concordar com o termo de compromisso, selecione a opção
“I accept the license agreement” e clique em “Next”. Após isto, vá clicando em “Next” que
em menos de 20 segundos, o MuPAD já estará instalado em seu computador.
Fazendo Cálculos
Para calcular uma expressão algébrica do tipo 3+5, basta digitar a operação seguida de um
<enter>
Ao digitar esta seqüência, o resultado é expresso logo abaixo:
• 3+5 <enter>
8
A potenciação é calculada utilizando-se o símbolo ^. Portanto, 2^5 representa o valor de 2
elevado à quinta potência:
• 2^5
32
Para se calcular a raiz quadrada temos a função sqrt(). Temos também as funções
trigonométricas seno, coseno, tangente, etc... Podemos entrar com várias operações
separadas por vírgula como abaixo:
• sqrt(9), sin(PI), cos(PI/6), arctan(1)
1/2
3
PI
3, 0, ----, -2
4
Como podemos perceber acima, a constante π é representada pela palavra “PI”. O resultado
das expressões também são exibidos separados por vírgula e na ordem que aparecem.
Para se calcular logaritmos empregamos a função log(b, x) onde b representa a base que
estamos trabalhando e x o valor que queremos extrair o logaritmo. O logaritmo natural
requer apenas um parâmetro e tem o escopo ln(x). O número de “euler” é representado pela
letra “E” maiúscula. Portanto log(E, x) é equivalente a ln(x) como podemos perceber
abaixo:
• log(2, 1024), log(E, 1), ln(1), ln(E)
10, 0, 0, 1
Exibindo o valor numérico de expressões
Se tentamos calcular o arco tangente de 3, por exemplo, o MuPAD nos responde da
seguinte maneira:
• arctan(3)
arctan(3)
o que não está errado, pois arctan(3) vale realmente arctan(3). Mas se desejamos saber o
valor numérico de arctan(3), temos que utilizar a função “float” como segue:
• float(arctan(3))
1.249045772
O mesmo pode ser utilizado para obtermos os valores do π e do número de “euler”:
• float(PI), float(E)
3.141592654, 2.718281828
Diferenciais e Integrais
O comando diff(e, v) deriva a expressão “e” em função da variável “v”. Para derivarmos a
expressão 3x^3 + 2x^2y^2 + xy + sen(x) + cos(y), fazemos:
• diff(3*x^3 + 2*x^2*y^2 + x*y + sin(x) + cos(y), x)
2
y + cos(x) + 9 x
2
+ 4 x y
Para integrar, podemos utilizar o comando int(e, v) que significa que iremos integrar a
expressão “e” em função da variável “v”. Para acharmos a integral indefinida da expressão
acima em função de “x”, fazemos:
• int(3*x^3 + 2*x^2*y^2 + x*y + sin(x) + cos(y), x)
4
2
3 2
3 x
x y
2 x y
x cos(y) - cos(x) + ---- + ---- + ------4
2
3
Se estamos fazendo várias operações com uma determinada expressão, como no caso
apresentado acima, o MuPAD nos permite associar uma expressão a uma determinada
palavra através do operador “:=” (dois pontos igual). Por exemplo, podemos associar a
expressão acima à palavra “exp1” e então, só precisaremos digitar diff(exp1, x) para
obtermos a derivada da expressão. Segue um exempl:
• exp1 := 3*x^3 + 2*x^2*y^2 + x*y + sin(x) + cos(y)
3
x y + cos(y) + sin(x) + 3 x
2
+ 2 x
2
y
• diff(exp1, x)
2
y + cos(x) + 9 x
2
+ 4 x y
• int(exp1, x)
4
2
3
2
3 x
x y
2 x y
x cos(y) - cos(x) + ---- + ---- + ------4
2
3
Para calcularmos integrais definidas, basta entrarmos com os extremos:
• int(x^2,x=0..1)
1/3
Limites
Limites são calculados utilizando-se o comando limit que possui dois parâmetros separados
por vírgula, sendo o primeiro uma expressão e o segundo uma variável seguida de um sinal
de igual seguida por um valor. “x=0” por exemplo representa “x tente a 0”. O limite
fundamental da trigonometria, por exemplo, sem(x)/x, com x tendendo a 0 pode ser obtido
da seguinte forma:
• limit(sin(x)/x, x=0)
1
Um símbolo muito importante que precisamos ao calcular limites é o ∞ (infinito). Este
símbolo é representado pela palavra “infinity”. Veja:
• limit(1/x, x=infinity)
0
Declarando Funções
A declaração de funções no MuPAD é bastante simples. Para declarar a função F(x) = x^3
+ x^2 basta fazermos:
• F := x -> (x^3 + x^2)
x -> x^3 + x^2
• F(x)
2
x
3
+ x
• F(2)
12
• F(a+b)
2
(a + b)
3
+ (a + b)
Podemos declarar funções de várias variáveis apenas colocando as variáveis entre
parênteses:
• G := (x,y)->(x+y)
(x, y) -> x + y
Como as expressões, podemos derivar, integrar as funções. É bastante intuitiva a maneira
de fazermos tais operações.
• int(G(a,b),b)
2
b
a b + --
2
Podemos também considerar a função como uma equação e isolar uma variável ou então
encontrar o valor de uma das variáveis tendo o valor da outra. Para isso utilizamos o
comando solve. No próximo item estudaremos este comando mais detalhadamente para a
resolução de Sistemas Lineares.
• solve(G(x,y)=5,y)
{5 - x}
• solve(G(x,7),x)
{-7}
Sistemas Lineares
O comando solve visto anteriormente é utilizado para a resolução de sistemas lineares. Sua
sintaxe é a seguinte:
solve({equação 1,equação 2,...,equação n},{variável 1, variável 2,..., variável m})
Por exemplo, vamos resolver o sistema linear a seguir:
x+y+z=6
x+y–z=0
2x + y + 2z = 10
Podemos utilizar o operador “:=” para simplificar os cálculos:
• equacoes := { x+y+z=6, x+y-z=0, 2*x+y+2*z=10 }
{x + y + z = 6, x + y - z = 0, 2 x + y + 2 z = 10}
• incognitas := { x, y, z }
{x, y, z}
• solve(equacoes, incognitas)
{[x = 1, y = 2, z = 3]}
Gráficos em duas dimensões
O MuPAD possui objetos gráficos (plot::Group) que primeiro são criados e só depois são
mostrados como gráfico. Por exemplo, temos campos escalares (plot::contour), curvas em
duas dimensões (plot::Curve2d), superfícies em três (plot::Surface3d) etc. Primeiro temos
que criar estes objetos, para depois, utilizando o comando plot(), mostrarmos o gráfico
gerado. Podemos colocar mais de um objeto com o comando plot(). Por exemplo,
plot(objeto1, objeto2, ..., objeton) o que lhe faz muito semelhante ao comando Show[] do
Mathematica.
Vamos começar mostrando como traçar curvas de nível e gráficos em duas dimensões
utilizando o terceiro exercício da Primeira Parte do Projeto. Mas antes vamos dar uma visão
geral dos comandos utilizados para tal fim.
c := plot::contour([x, y, f(x,y)], x=[a,b], y=[c,d])
No comando acima, “c” está recebendo o objeto gerado pelo comando plot::contourn(...).
Este comando consiste de três parâmetros. O primeiro [x, y, f(x,y)] significa que a função
f(x,y) que depende das variáveis “x” e “y” é que está sendo traçada. Note que f(x,y) pode
ser substituída por qualquer função, como por exemplo x^2 + y^2. Os dois segundos
parâmetros representam os intervalos de “x” e “y” que devem ser considerados.
Para parametrizar uma superfície em duas dimensões utilizamos o comando:
c := plot::Curve2d([x(t), y(t)], t=[a,b])
No comando acima “c” está recebendo o objeto gerado pelo comando plot::Curve2d(...).
Este comando recebe como entrada as componentes “x” e “y” parametrizadas em função de
“t” da curva que está sendo gerada, e o intervalo em que “t” irá variar.
Vamos dar agora um exemplo de como resolver o terceiro exercício da Primeira Parte do
Projeto. Primeiro geramos a parametrização da elipse de centro (8,6) e semi-eixos 4 e 3
sendo as componentes “y” dos dois focos iguais.
• f := (t)->[4*cos(t)+8, 3*sin(t)+6]
t -> [4*cos(t) + 8, 3*sin(t) + 6]
Agora temos que construir a função do campo escalar da variação de temperatura:
• g := (x,y)->(x+y)
(x, y) -> x + y
Agora que já temos as duas funções podemos gerar seus gráficos:
• graficof := plot::Curve2d(f(t),t=[0,2*PI])
plot::Curve2d([4 cos(t) + 8, 3 sin(t) + 6], t = 0..2 PI)
• graficog := plot::contour([x,y,g(x,y)], x=[-1,13], y=[0,10],
Contours=[-1,1,3,5,7,9,11,13,15,17,19,21,23])
plot::Group()
Veja que foi utilizado a opção “Contours = [v1, v2, ..., vn]” na construção das curvas de
níveis da função g(x,y).
Agora com os dois gráficos, podemos utilizar o comando plot(graficof, graficog) para
mostrar na tela os dois gráficos sobrepostos:
• plot(graficof,graficog)
Também é possível traçar gráfico de funções não parametrizadas. Estes gráficos são
traçados diretamente sem a utilização do comando plot(). Veja:
• plotfunc2d(sin(x)/x,x=-3*PI..3*PI)
Cabe mencionar apenas que este comando requer o intervalo escrito sob a forma x=a..b e
não x=[a,b] como vínhamos utilizando.
Também é possível criar campos vetoriais com o MuPAD. O comando é o seguinte:
c := plot::vectorfield([x, y], x=a..b, y=c..d)
Veja um exemplo:
• plot(plot::vectorfield([y,-x],x=-2..2,y=-2..2))
Gráficos em três dimensões
Os comandos para gráfico em três dimensões são muito semelhantes aos de duas
dimensões. Portanto, darei apenas a sintaxe dos comandos e já entrarei com os exemplos.
Para plotar curvas parametrizadas em três dimensões utilizamos o comando plot::Curve3d
como segue:
c := plot::Curve3d([x, y, z], t=ª.b)
Para superfícies parametizadas utilizamos:
c := plot::Surface3d([x, y, z], u=a..b, v=c..d)
Para exemplificar o uso destes comandos iremos utilizar a quarta questão da prova que era
pra achar a intersecção de uma esfera de raio R centrada na origem com um cilindro que
possui somente z negativo e de circunferência geratriz de raio R/2 centrada no ponto
(0,R/2,0). Iremos considerar aqui R=1 para simplificar os cálculos.
A circunferência é parametrizada da seguinte forma:
x = sen(f)cos(t)
y = sen(f)sen(t)
z = cos(f)
Substituindo estes valores na equação cartesiana do cone encontramos t em função de teta.
Substituindo os novos valores de t nas componentes da esfera obtemos a parametrização da
intersecção do cone com a esfera.
Primeiro geramos a esfera:
• esf:=plot::Surface3d([sin(f)*cos(t),sin(f)*sin(t),cos(f)],f=[0,P
I],t=[0,2*PI])
plot::Surface3d([sin(f) cos(t), sin(f) sin(t), cos(f)], f = 0..PI,
t = 0..2 PI)
Neste caso, diferentemente da parametrização em 2d, a função que queremos parametrizar
foi digitada diretamente dentro do comando plot::Surface3d. No caso da parametrização em
duas dimensões, criamos uma função funcaof e só depois geramos o gráfico. Repare
também que são utilizadas aqui 2 intervalos de valores. Um para f (f=[0,PI]) e outro para t
(t=[0,2*PI]).
O cone também pode ser parametrizado da seguinte forma:
• cone:=plot::Surface3d([cos(a)/2,sin(a)/2+1/2,b],a=[0,2*PI],b=[1,0])
/ -- cos(a) sin(a)
-plot::Surface3d| | ------, ------ + 1/2, b |, a = 0..2 PI, b =
\ -2
2
-\
-1..0 |
/
Como encontramos dois valores para t, t=f e t=PI-f, teremos que parametrizar duas curvas
que chamaremos de int1 e int2. Segue:
• int1:=plot::Curve3d([sin(f)*cos(f),sin(f)*sin(f),cos(f)],f=[PI/2
,PI],Color=RGB::Blue,LineWidth=50)
/
2
PI
\
plot::Curve3d| [cos(f) sin(f), sin(f) , cos(f)], f = --..PI |
\
2
/
• int2:=plot::Curve3d([sin(f)*cos(PI-f),sin(f)*sin(PIf),cos(f)],f=[PI/2,PI],Color=RGB::Blue,LineWidth=50)
/
2
PI
\
plot::Curve3d| [-cos(f) sin(f), sin(f) , cos(f)], f = --..PI |
\
2
/
Repare que foram utilizadas duas opções novas nesses comandos. A opção
Color=RGB::Blue que diz para traçar a curva na cor azul e LineWidth=50 que diz para a
grossura da linha da curva ser 50. Essas duas opções facilitaram a visualização da curva
sobre a superfície.
Agora que temos os quatro gráficos podemos mostra-los na tela utilizando o comando plot.
Utilizamos a opção Scaling=Constrained para termos a mesma escala nos eixos x, y e z.
• plot(esf,int1,int2,cone,Scaling=Constrained)
Outro comando semelhante ao plot::Function2d é o plot::Function3d. Segue um exemplo:
• plot(plot::Function3d(sin(x)*cos(y), x=[0,2*PI], y=[0,2*PI]))