MA311, turmas C e D, 2020

Ricardo Antonio Mosna

Gráficos

Talvez a primeira coisa que venha à mente ao usar um software de matemática seja fazer gráficos. Vamos começar por isso então.

Plot[Sin[x],{x,0,4π}]

Vários gráficos em um só plot

Plot[{Cos[x],Sin[x],Sin[x]+Sin[2x]-Sin[3x]+Sin[4x]},{x,0,4π},PlotLegends->"Expressions"]

Gráficos em 3D...

Plot3D[Sin[x]+Sin[y],{x,-2π,2π},{y,-2π,2π}]

Plot3D[(1/(1+(x^2)+(y^2))),{x,-2π,2π},{y,-2π,2π}]

Mostrando um range maior:

Plot3D[(1/(1+(x^2)+(y^2))),{x,-2π,2π},{y,-2π,2π},PlotRange->{0,1}]

Plot3D[((Sin[x]+Sin[y])/(1+(x^2)+(y^2))),{x,-2π,2π},{y,-2π,2π},PlotRange->All]

As mesmas funções acima, mas agora visualizadas via curvas de nível

ContourPlot[Sin[x]+Sin[y],{x,-2π,2π},{y,-2π,2π}]

Agora só com curvas, sem shading:

ContourPlot[(1/(1+(x^2)+(y^2))),{x,-2π,2π},{y,-2π,2π},ContourShading->None]

Mostrando contornos específicos agora, colocados em uma tabela:

tabela=Table[i,{i,-0.7,0.7,0.05}]

ContourPlot[((Sin[x]+Sin[y])/(1+(x^2)+(y^2))),{x,-2π,2π},{y,-2π,2π},Contours->tabela,ContourShading->None,PlotRange->All]

E melhorando a precisão das curvas:

ContourPlot[((Sin[x]+Sin[y])/(1+(x^2)+(y^2))),{x,-2π,2π},{y,-2π,2π},Contours->tabela,ContourShading->None,PlotRange->All,PlotPoints->70]

Vamos agora plotar campos de vetores. Considere o campo vetorial F(x,y)={1,0}.

VectorPlot[{1,0},{x,-2π,2π},{y,-2π,2π}]

Dois outros um pouco mais interessantes: F(x,y)={x,y} e F(x,y)={-y,x}

VectorPlot[{x,y},{x,-2π,2π},{y,-2π,2π}]

VectorPlot[{-y,x},{x,-2π,2π},{y,-2π,2π}]

Definindo constantes e funções

Definir uma constante é fácil, basta igualá-la a algo:

c=23

c

c+2

Clear[c]

c

Funções são definidas da maneira seguinte, onde definimos
                                                                                f:R->R    e    V:(R^2)->(R^2)
(isto é, V é um campo vetorial)

Clear[f,V]
f[x_]=Sin[(1/x)]
V[x_,y_]={x+y,y-x}

Plot[f[x],{x,0,1}]

VectorPlot[V[x,y],{x,-1,1},{y,-1,1}]

Podemos usar o VectorPlot para plotar campos de direções. Considere a EDO
                                                                                         (dy/dx)=f(x,y)
Seu campo de direções é dado pelo campo vetorial V(x,y)=(1,f(x,y)), pois no ponto (x,y) a curva solução deve ter taxa de variação (dy/dx)=f(x,y), ou seja, é tangente ao vetor 
                                                                            V(x,y)=(1,(dy/dx))=(1,f(x,y))

Exemplo: (dy/dx)=-x y

V[x_,y_]={1,-x y}

VectorPlot[V[x,y],{x,-3,3},{y,-3,3}]

StreamPlot[V[x,y],{x,-3,3},{y,-3,3},VectorStyle->Arrowheads[0]]

Derivada e Integral

Derivada da expressão (x^2)+Sin[y] em relação a suas variáveis:

D[(x^2)+Sin[y],x]
D[(x^2)+Sin[y],y]

Se temos uma função f[x] (ou f[x,y] ou f[x,y,z] ou ...), podemos fazer, por exemplo”

f[x_]=(x^4)+Cos[x]+a x

D[f[x],x]

D[f[x],x,x]
D[f[x],x,x,x]
D[f[x],{x,4}]

Isso é equivalente a

f[x]
f'[x]
f''[x]
f'''[x]
Derivative[4][f][x]

Integral indefinida: ∫g[x]dx
(cuidado, o Mathematica não acrescenta uma constante arbitrária):

Integrate[(x^12),x]

Integrate[f[x],x]

Integral definida: (∫_a^b)g[x]dx

Integrate[Sin[s],{s,a,b}]

Integrate[f[x],{x,0,2π}]

Simplificando expressões

Os comandos Simplify e FullSimplify simplificam expressões:

((Sin[x])^2)+((Cos[x])^2)

Simplify[((Sin[x])^2)+((Cos[x])^2)]

D[(Cos[x]+Sin[x]) Cos[x],x]
FullSimplify[%]

Outra maneira:

(E^(I x))+(E^(-I x))
%//FullSimplify

Listas

Uma tabela com valores de (n^2) com n variando de dois em dois de 0 a 10 pode ser feita assim:

Table[(n^2),{n,0,10,2}]

Ou, se quisermos que contenha n e (n^2) e que seja exibida de maneira mais chique :

tabela=Table[{n,(n^2)},{n,0,10,2}]

MatrixForm[tabela]

tabela//MatrixForm

Extraindo o i-ésimo elemento da lista:

tabela[[3]]

Neste caso, isso também é uma lista. Extraindo o j-ésimo elemente do  i-ésimo elemento da lista:

tabela[[3,2]]

Equações algébricas

Aqui é um bom lugar para mencionar que i comando N[algo] dá o valor numérico (aproximado) de algo.

N[π]
N[E]

Equações simples (em um certo sentido) podem ser resolvidas com o comando Solve (note que a igualdade aqui deve ser denotda por dois iguais, isto é, por ==).

Solve[(x^2)-2 x-8==0,x]

Solve[{y==(x^2)-(1/4),(x^2)+(y^2)==1},{x,y}]

Podemos recuperar o último resultado através de %, o penúltimo atraves de %% e assim por diante. Por exemplo:

N[%]

O sistema de equações acima pode ser pensado geométricamente  como a intersecção das duas curvas abaixo. Note que o que um ponto e virgula no final de uma linha faz com que a saída seja omitida. O comando Show combina os gráficos.

g1=Plot[(x^2)-(1/4),{x,-2,2}];
g2=ContourPlot[(x^2)+(y^2)==1,{x,-2,2},{y,-2,2}];
g3=ListPlot[{{((Sqrt[3])/2),(1/2)},{-((Sqrt[3])/2),(1/2)}},PlotStyle->{Red}];
Show[g1,g2,g3,PlotRange->{{-1.5,1.5},{-1.5,1.5}},AspectRatio->Automatic]

Equações diferenciais

Uso básico:

DSolve[y'[x]+x y[x]==0,y[x],x]

Ou, para um PVI:

DSolve[{y'[x]+x y[x]==0,y[0]==2},y[x],x]

Outra forma (note a diferença na saída):

DSolveValue[{y'[x]+x y[x]==0,y[0]==2},y[x],x]

Plot[%,{x,-5,5}]

Table[DSolveValue[{y'[x]+x y[x]==0,y[0]==i},y[x],x],{i,-4,4,1}]
g1=Plot[%,{x,-5,5},PlotRange->All]

f[x_,y_]=-x y

g2=VectorPlot[{1,-x y},{x,-4,4},{y,-4,4},VectorColorFunction->None,VectorStyle->LightGray]

Show[g2,g1]

Ordens superiores:

DSolveValue[y''[t]+(ω^2) y[t]==0,y[t],t]

DSolveValue[{y''[t]+(1/t) y[t]==0,y[0]==0,y'[0]==1},y[t],t]

ysol[t_]=%

Plot[ysol[t],{t,0,100}]

Se sortermos uma EDO ao acaso essa não terá solução fechada em uma forma “representável analiticamente”. Para essa (esmagadora) maioria, temos que fazer uma análise qualitativa ou numérica.

DSolveValue[y''[t]+(1/t) ((y[t])^3)==0,y[t],t]

Comecemos com uma equação que pode ser resolvida tanto analítica quanto numericamente, y’’+y=0

DSolveValue[{y''[t]+ y[t]==0,y[0]==1,y'[0]==0},y[t],t]

NDSolveValue[{y''[t]+ y[t]==0,y[0]==1,y'[0]==0},y,{t,0,30}]

O objeto InterpolatingFunction é para o Mathematica uma função como outra qualquer. Se vc olhar dentro dele, verá que na verdade é dado por uma interpolação dos valores discretos de y(x) obtidos pelo método numérico escolhido pelo NDSolve. Essa interpolação é feita no domínio considerado, que no caso acima é com t entre 0 e 30.

ynum=NDSolveValue[{y''[t]+ y[t]==0,y[0]==1,y'[0]==0},y,{t,0,30}]

Plot[ynum[t],{t,0,30}]

Note que esta solução está numericamente próxima da solução analítica que é, neste caso, cos(t):

ynum[0]
ynum[(π/3)]
ynum[(π/2)]

Se você tentar plotar esse objeto fora do seu domínio de validade ele retornará valores espúrios. Comparando com a solução analítica, que sabemos neste caso:

DSolveValue[{y''[t]+ y[t]==0,y[0]==1,y'[0]==0},y[t],t]
ysol[t_]=%

Plot[{ysol[t],ynum[t]},{t,0,35},PlotLegends->"Expressions"]

Outra EDO:     y''+(1/t) (y^3)=0

DSolveValue[y''[t]+(1/t) ((y[t])^3)==0,y[t],t]

A conta acima mostra que o Mathematica não encontrou forma fechada para a solução dessa EDO. Vamos então tentar a abordagem numérica.

NDSolveValue[{y''[t]+(1/t) ((y[t])^3)==0,y[1]==1,y'[1]==0},y,{t,0.01,200}]
ynum=%

Plot[ynum[t],{t,0.01,200}]

Se tentarmos resolver essa equação até t=0 o Mathematica vai esbarrar na singularidade dada pelo fator que multiplica (y^3) na EDO:

NDSolveValue[{y''[t]+(1/t) ((y[t])^3)==0,y[1]==1,y'[1]==0},y,{t,0,200}]
ynum=%

Ainda assim, essa solução parece ser bem comportada para t->0:

Plot[ynum[t],{t,1.65 (10^(-15)),200}]