>> Tecnologia eletrônica >  >> Lar inteligente >> Vida Inteligente

Como escrever uma série de Taylor em Python


Uma série de Taylor é uma representação de uma função usando uma soma infinita. Os computadores geralmente fazem aproximações dos valores de uma função trigonométrica, exponencial ou outra função transcendental somando um número finito de termos de sua série de Taylor, e você pode recriar esse processo em Python. Os termos da soma são baseados em derivadas sucessivas da função, portanto, você precisará identificar um padrão nos valores dessas derivadas para escrever uma fórmula para cada termo da série. Em seguida, use um loop para acumular a soma, controlando a precisão de sua aproximação com o número de iterações do loop.

Etapa 1


Consulte a definição da série de Taylor para entender como cada termo pode ser calculado. Cada termo da série é indexado, normalmente por "n", e seu valor está relacionado à n-ésima derivada da função que está sendo representada. Para simplificar, use 0 para o valor de "a" em sua primeira tentativa. Esta versão especial da série de Taylor é chamada de série de Maclaurin. Experimente a função seno, pois suas derivadas sucessivas são fáceis de determinar.

Etapa 2


Escreva vários valores da n-ésima derivada da função seno avaliada em 0. Se n for 0, o valor será 0. Se n for 1, o valor será 1. Se n for 2, o valor será 0. Se n for 3 , o valor é -1. A partir daqui, o padrão se repete, então desconsidere todos os termos da série de Taylor com índice par, pois é multiplicado por 0. Uma fórmula para cada termo da série resultante é:

(-1)^n/(2n+1)!*x^(2n+1)

"2n+1" é usado no lugar de "n" para reindexar a série, efetivamente descartando os termos indexados pares sem alterar o próprio índice. O fator (-1)^n é responsável pela alternância entre positivo e negativo de termos sucessivos. Esse trabalho preliminar de matemática pode parecer estranho, mas o código Python será muito mais fácil de escrever e reutilizar em outras séries de Taylor se o índice sempre começar em 0 e contar para cima em incrementos de 1.

Etapa 3


Abra o interpretador Python. Comece digitando os seguintes comandos para definir várias variáveis:

soma =0 x =0,5236

A variável "sum" será utilizada para acumular a soma da série de Taylor à medida que cada termo é computado. A variável "x" é o ângulo (em radianos) para o qual você deseja aproximar a função seno. Defina-o para o que quiser.

Etapa 4


Importe o módulo "math" com o seguinte comando para ter acesso às funções "pow" e "factorial":

importar matemática

Etapa 5


Inicie um loop "for", definindo o número de iterações com a função "range":

para n no intervalo(4):

Isso fará com que a variável de índice, n, comece em zero e conte até 4. Mesmo esse pequeno número de iterações produzirá um resultado surpreendentemente preciso. O loop não é executado imediatamente e não começará até que você tenha especificado todo o bloco de código para iterar.

Etapa 6


Digite o seguinte comando para adicionar o valor de cada termo sucessivo a "sum":
sum += math.pow(-1,n)/math.factorial(2*n+1)*math.pow(x,2*n+1)

Observe que o comando é recuado com uma guia, que indica ao Python que ele faz parte do loop "for". Observe também como "pow" e "factorial" são usados ​​no lugar de "^" e "!" notação. A fórmula à direita do operador de atribuição "+=" é idêntica à do Passo 2, mas escrita em sintaxe Python.

Etapa 7


Pressione “Enter” para adicionar uma linha em branco. Para Python, isso indica o término do loop "for", então o cálculo é executado. Digite o comando "sum" para revelar o resultado. Se você usou o valor de x dado na Etapa 3, o resultado é muito próximo de 0,5, o seno de pi/6. Tente o processo novamente para diferentes valores de x e para diferentes números de iterações do loop, verificando seus resultados com a função "math.sin(x)". Você implementou em Python o mesmo processo que muitos computadores usam para calcular valores para seno e outras funções transcendentais.

Dica


Recue e digite o comando "sum" na segunda linha do loop "for" para obter um total em execução da soma à medida que o código é executado. Isso revela como cada termo sucessivo da série aproxima a soma cada vez mais do valor real da função.