Embedded Files
f(x)=x²
f(x)=x²
#Isso é um comentário.
"""Isso também
é um
comentário."""
import matplotlib.pyplot as plt# Importando biblioteca.
import numpy as np# Importando biblioteca.
def f(x):# Definindo a função.
return x**2# Usamos ** para potências.
pi=3.14159# Aproximação para pi.
x_inicial=-2*pi# Usamos * para fazer multiplicação.
x_final=2*pi
espacamento_entre_pontos=0.1# Espaçamento entre os valores de x.
#Criando os valores de x:
x = np.arange(x_inicial, x_final, espacamento_entre_pontos)
plt.plot(x, f(x))# Gerando o gráfico.
plt.show()# Mostrando o gráfico.
Uma função trigonométrica
Uma função trigonométrica
#Isso é um comentário.
"""Isso também
é um
comentário."""
import matplotlib.pyplot as plt# Importando biblioteca.
import numpy as np# Importando biblioteca.
def f(x):# Definindo uma função.
return np.cos(x)# Neste caso cos(x).
pi=3.14159# Aproximação para pi.
x_inicial=-2*pi# Usamos * para fazer multiplicação.
x_final=2*pi
espacamento_entre_pontos=0.1# Espaçamento entre os valores de x.
#Criando os valores de x:
x = np.arange(x_inicial, x_final, espacamento_entre_pontos)
plt.plot(x, f(x))# Gerando o gráfico.
plt.show()# Mostrando o gráfico.
Resultado do Exemplo01.py:
Resultado do Exemplo01.py:
Gráfico de funções definidas por séries de potências
Gráfico de funções definidas por séries de potências
import numpy as np
import matplotlib.pyplot as plt
import array as arr
# Definindo um laço particular:
def meuLoopParticular(start, end, step):
while start <= end:
yield start
start += step
"""Ponto em torno do qual a solução em série é calculada:"""
x0=0.
"""Número de parcelas a serem utilizadas na aproximação para a solução em série:"""
numParcelas = 100
"""A fórmula de recorrência usa os valores de a(n-1) e a(n) para determinar a(n+2). Para construir y1 e y2 precisamos separar os termos proporcionais a a0 e a1 dos coeficientes an (ver página 140 do Boyce e DiPrima). O cálculo dos coeficientes an (fórmula de recorrência) nos leva a uma combinação linear de a0 e a1. O desenvolvimento é idêntico ao processo de combinação linear de dois vetores em R^2. Por isso consideraremos cada coeficiente an como um vetor de duas componentes:
a=[1, 0] -> a0=1i+0j
[0, 1] -> a1=0i+1j
[x0/2, 0] -> a2=(x0/2)i + 0j
[b, c] -> a3=bi+cj (=b a0 + c a1)
[d, e] -> a4=di+ej (=d a0 + e a1)
...
[w, z] -> an=wi+zj (=w a0 + z a1)
A componente a0 de an é obtida com a[n][0] (linha n, coluna 0): a[n][0]=w.
A componente a1 de an é obtida com a[n][1] (linha n, coluna 1): a[n][1]=z.
a[0][0]=1 a[0][1]=0 -> a0 em "forma vetorial":
Linha 0, componentes de a0 (criando a primeira linha da matriz a):"""
a=np.array([[1., 0.]])
"""a[1][0]=0 a[1][1]=1, a1 em "forma vetorial":
Linha 1, componentes de a1 (adicionando linha à matriz a):"""
a=np.r_[a, [[0., 1.]]]
"""a[2][0]=x0/2 a[2][1]=0, a2 em "forma vetorial":
Linha 2, componentes de a2 (adicionando linha à matriz a):"""
a=np.r_[a, [[x0/2., 0.]]]
"""Cada vez que usamos np.r_ incluímos uma linha em a.
Usamos a fómula de recorrência e o np.r_ para determinar os demais an em termos das componentes a0 e a1.
a[3][0]=* a[3][1]=*: Componentes a0 e a1 de a3.
a[n][0]=* a[n][1]=*: Componentes a0 e a1 de an.
w=(a[n-2][0]+x0*a[n-1][0])/((n+1)*n): Componente a0 de an (fórmula de recorrência).
z=(a[n-2][1]+x0*a[n-1][1])/((n+1)*n): Componente a1 de an (fórmula de recorrência).
a=np.r_[a, [[w, z]]]: Linha n+2, componentes de a(n+2) (adicionando demais linhas à matriz a):"""
for n in meuLoopParticular(1, numParcelas-3, 1):
"""Componente a0 de a(n+2) (fórmula de recorrência):"""
w=(a[n-1][0]+x0*a[n][0])/((n+2)*(n+1))
"""Componente a1 de a(n+2) (fórmula de recorrência):"""
z=(a[n-1][1]+x0*a[n][1])/((n+2)*(n+1))
"""Linha n+2, componentes de a(n+2), adicionando demais linhas à matriz a:"""
a=np.r_[a, [[w, z]]]
#print(a[n])
#print(a[1][0])
"""Função que define as parcelas da solução em série y1 (contém a0):"""
def b(x, n):
return a[n][0]*((x-x0))**n
"""Função que define as parcelas da solução em série y2 (contém a1):"""
def c(x, n):
return a[n][1]*((x-x0))**n
xmin=-10.; xmax=2.; delta_x=0.01
"""Criando um array vazio com precisão double flutuante para armazenar os valores de x:"""
xValores=arr.array('d')
"""Criando arrays vazios para ir acrescentando os termos das séries de y1 e y2:"""
y1=arr.array('d'); y2=arr.array('d')
i=-1
for x in meuLoopParticular(xmin, xmax, delta_x):
"""Acrescentando elementos ao array xValores:"""
xValores.append(x)
"""Para cada valor de x precisamos calcular as séries de y1 e y2:"""
"""Para cada valor de x vamos acumular um somatório para y1 e um somatório para y2:"""
y1.append(0.); y2.append(0.)
i=i+1
for n in meuLoopParticular(0, numParcelas-1, 1):
parcelay1=b(x, n)
y1[i]=y1[i]+parcelay1
parcelay2=c(x, n)
y2[i]=y2[i]+parcelay2
plot1 = plt.subplot()
"""Margem padrão é 0.05. O valor 0 deixa ajustado:"""
plot1.margins(0.00)
"""Plotando os dados calculados acima:"""
plot1.plot(xValores, y1, label = '$y_1$')
plot1.plot(xValores, y2, label = '$y_2$')
"""Colocando nomes nos eixos:"""
plt.xlabel('$x$')
plt.ylabel('$y$')
"""Colocando a legenda:"""
plt.legend()
"""Mostrando o resultado:"""
plt.show()
Resultado do Exemplo02.py:
Resultado do Exemplo02.py:
Obs.:
Obs.:
As soluções fundamentais y1 e y2 acima são uma espécie de funções especiais.
Curvas parametrizadas
Curvas parametrizadas
from sympy import symbols, cos, sin, atan, sqrt
from sympy.plotting import plot_parametric
pi=4.*atan(1.)# Aproximação para pi.
phi=(1.+sqrt(5.))/2.# Razão áurea.
t=symbols('t')
def r(t):# Espiral áurea.
return phi**(2.*t/pi)
def x(t):# Componente x da função vetorial.
return r(t)*cos(t)
def y(t):# Componente y da função vetorial.
return r(t)*sin(t)
plot_parametric((x(t), y(t)), (t, 0, 7*pi))
Resultado: espiralAurea.py
Resultado: espiralAurea.py
Google Sites
Report abuse