Phenquestions
Como SciPy é um código aberto, tem uma comunidade de desenvolvedores muito ativa e vibrante devido à qual há um enorme número de módulos presentes para uma vasta quantidade de aplicações científicas e cálculos disponíveis com SciPy. Algumas das operações matemáticas complexas que podem ser realizadas com SciPy são:
- Interpolação
- Integração
- Otimização
- Processamento de imagem
- Estatisticas
- Cálculos de funções especiais, etc.
O SciPy pode ser comparado à maioria das bibliotecas de comando e padrão, como a biblioteca GSL para C ++ e Matlab. Como o SciPy é construído sobre o pacote NumPy, esses dois pacotes também podem ser integrados completamente. Se você conseguir pensar em uma operação matemática que precisa ser feita, certifique-se de verificar a biblioteca SciPy antes de implementar esse módulo por conta própria, porque na maioria dos casos, SciPy já tem todas as operações totalmente implementadas para você.
Instale a biblioteca SciPy
Vamos instalar a biblioteca SciPy antes de passar para os exemplos e conceitos reais. Existem duas maneiras de instalar este pacote. O primeiro inclui o uso do gerenciador de pacotes Python, pip:
pip install scipyA segunda forma está relacionada ao Anaconda, podemos instalar o pacote como:
conda install -c anaconda scipyAssim que a biblioteca estiver instalada, podemos importá-la como:
importar scipyFinalmente, como também usaremos o NumPy (é recomendado que, para todas as operações do NumPy, usemos o NumPy diretamente em vez de passar pelo pacote SciPy):
importar numpyÉ possível que, em alguns casos, também queiramos traçar nossos resultados para os quais usaremos a biblioteca Matplotlib. Execute a seguinte importação para essa biblioteca:
importar matplotlibUsarei o gerenciador Anaconda para todos os exemplos nesta lição. Vou lançar um Notebook Jupyter para o mesmo:
Agora que estamos prontos com todas as instruções de importação para escrever algum código, vamos começar a mergulhar no pacote SciPy com alguns exemplos práticos.
Trabalho com equações polinomiais
Começaremos examinando equações polinomiais simples. Existem duas maneiras pelas quais podemos integrar funções polinomiais em nosso programa. Podemos fazer uso de poly1d classe que faz uso de coeficientes ou as raízes de um polinômio para inicializar um polinômio. Vejamos um exemplo:
from numpy import poly1dprimeiro_polinômio = poly1d ([3, 4, 7])
imprimir (primeiro_polinômio)
Quando executarmos este exemplo, veremos a seguinte saída:
Claramente, a representação polinomial da equação é impressa como a saída para que o resultado seja muito fácil de entender. Podemos realizar várias operações neste polinômio também, como elevá-lo ao quadrado, encontrar sua derivada ou até mesmo resolvê-lo para um valor de x. Vamos tentar fazer tudo isso no próximo exemplo:
imprimir ("Quadrado polinomial: \ n")imprimir (primeiro_polinômio * primeiro_polinômio)
print ("Derivada de Polinômio: \ n")
imprimir (primeiro_polinômio.deriv ())
print ("Resolvendo o polinômio: \ n")
imprimir (primeiro_polinômio (3))
Quando executarmos este exemplo, veremos a seguinte saída:
Bem quando eu estava pensando que isso é tudo que poderíamos fazer com SciPy, lembrei que podemos integrar um polinômio também. Vamos executar um exemplo final com polinômios:
print ("Integrando o Polinômio: \ n")imprimir (primeiro_polinômio.inteiro (1))
O número inteiro que passamos diz ao pacote quantas vezes integrar o polinômio:
Podemos simplesmente passar outro inteiro que diz ao pacote quantas vezes integrar este polinômio.
Resolvendo Equações Lineares
É ainda possível resolver equações lineares com SciPy e encontrar suas raízes, se existirem. Para resolver equações lineares, representamos o conjunto de equações como matrizes NumPy e sua solução como matrizes NumPy separadas. Vamos visualizá-lo com um exemplo em que fazemos o mesmo e usamos linalg pacote para encontrar as raízes das equações, aqui estão as equações que iremos resolver:
1x + 5y = 63x + 7y = 9
Vamos resolver as equações acima:
de importação scipy linalgequação = np.matriz ([[1, 5], [3, 7]])
solução = np.matriz ([[6], [9]])
raízes = linalg.resolver (equação, solução)
print ("Encontrou as raízes:")
imprimir (raízes)
imprimir ("\ n Produto escalar deve ser zero se as soluções estiverem corretas:")
imprimir (equação.ponto (raízes) - solução)
Quando executamos o programa acima, veremos que a equação de produto escalar dá resultado zero, o que significa que as raízes que o programa encontrou estavam corretas:
Transformações de Fourier com SciPy
As transformações de Fourier nos ajudam a expressar uma função como componentes separados que a constituem e nos orienta sobre a maneira pela qual podemos recombinar esses componentes para obter a função original de volta.
Vejamos um exemplo simples de Transformações de Fourier, onde plotamos a soma de dois cossenos usando a biblioteca Matplotlib:
de scipy.fftpack import fft# Número de pontos de amostra
N = 500
# espaçamento de amostra
T = 1.0/800.0
x = np.linspace (0.0, N * T, N)
y = np.cos (50.0 * 2.0 * np.pi * x) + 0.5 * np.cos (80.0 * 2.0 * np.pi * x)
yf = fft (y)
xf = np.linspace (0.0, 1.0 / (2.0 * T), N // 2)
# matplotlib para fins de plotagem
importar matplotlib.pyplot como plt
plt.plot (xf, 2.0 / N * np.abs (yf [0: N // 2]))
plt.título ('Informações')
plt.ylabel ('eixo Y')
plt.xlabel ('eixo X')
plt.rede()
plt.mostrar()
Aqui, começamos construindo um espaço de amostra e uma equação de cosseno, que então transformamos e plotamos. Aqui está o resultado do programa acima:
Este é um dos bons exemplos em que vemos o SciPy sendo usado em uma equação matemática complexa para visualizar as coisas facilmente.
Vetores e Matriz com SciPy
Agora que sabemos muitas coisas das quais o SciPy é capaz, podemos ter certeza de que o SciPy também pode trabalhar com vetores e matrizes. As matrizes são uma parte importante da álgebra linear, pois as matrizes também são usadas para representar os mapeamentos de vetores.
Assim como olhamos para resolver equações lineares com SciPy, podemos representar vetores com np.variedade() funções. Vamos começar construindo uma matriz:
minha_matriz = np.matriz (np.aleatória.aleatório ((3, 3)))imprimir (minha_matriz)
Aqui está a saída do snippet acima:
Sempre que falamos sobre matrizes, sempre falamos sobre valores próprios e vetores próprios. Para simplificar, os vetores próprios são os vetores que, quando multiplicados por uma matriz, não mudam de direção, ao contrário da maioria dos vetores. Isso significa que mesmo quando você multiplica um autovetores por uma matriz, existe um valor (ou autovalor) que é um dos fatores da multiplicação. Isso significa:
Ax = λx.Na equação acima, A é a matriz, λ é o autovalor e x é o vetor. Vamos escrever um snippet de código simples para encontrar os autovalores de um determinado vetor:
la, vetor = linalg.eig (minha_matriz)imprimir (vetor [:, 0])
imprimir (vetor [:, 1])
imprimir (linalg.eigvals (my_matrix))
Quando executarmos este exemplo, veremos a seguinte saída:
Calculando o Determinante da Matriz
A próxima operação que realizaremos com SciPy é calcular o determinante de uma matriz bidimensional. Vamos reutilizar a matriz que usamos no último trecho de código aqui:
linalg.det (minha_matriz)Quando executarmos este exemplo, veremos a seguinte saída:
Conclusão
Nesta lição, vimos muitos bons exemplos em que o SciPy pode nos ajudar realizando cálculos matemáticos complexos para nós com uma API e pacotes fáceis de usar.
