Primeira vez aqui? Seja bem vindo e cheque o FAQ!
x

Como utilizar uma classe para implementar o método da interpolação de Lagrange?

0 votos
24 visitas

1 Resposta

0 votos
respondida Ago 31 por Henrique Alves (6 pontos)  

Olá a todos! :)

Vamos falar sobre um tópico muito interessante: Como utilizar as classes como uma interface para implementar o método da interpolação de Lagrange.

A questão a ser respondida é a de número 7.8, do livro ''A Primer on Scientific Programming''.

Antes de tudo, para que serve a interpolação? Em resumo, vamos supor que exista um conjunto de pontos ordenados da forma x, y, por exemplo:

X = [0, 1, 2, 3, 4]

Y = [ 3,11,15,28,57]

A princípio, pode ser complicado achar uma função que descreve perfeitamente esses pontos ordenados, então, utilizamos a interpolação de Lagrange para descrever qualquer valor entre esses pontos! Esse é o resumo mais breve possível, mas acho que é o suficiente para nós por enquanto :)

Então vamos lá!

Primeiro, vamos definir uma classe chamada LagrangeInterpolation. Essa classe terá atributos e métodos. Seus atributos serão os vetores dos pontos ordenados X e Y, e seus métodos serão calcular a Interpolação para qualquer ponto x, e também fazer o plot() da interpolação.

A primeira etapa:

import matplotlib.pyplot as plt
import numpy as np

class LagrangeInterpolation:

    def __init__(self, xp, yp):

        self.xp = xp

        self.yp = yp

O primeiro método:

def func(self, x):
    ################################
    #Aqui calculamos a interpolação#
    yinit = 0

    for i in range(len(self.xp)):
        p = 1

        for j in range(len(self.xp)):
            if j != i:
                p *= (x - self.xp[j])/(self.xp[i]-self.xp[j])

        yinit += self.yp[i]*p


    return yinit

    ###############################

Não vamos explicar detalhes da função de interpolação, pois essa é a função de outro exercício. Mas entenda que essa parte do algoritmo surge das seguintes expressões:

A imagem será apresentada aqui.

O segundo método é bastante simples, fazer o plot para os conjuntos de entrada:

def plot(self):
    plt.plot(self.xp, self.yp)

Não se preocupe, vamos fazer alguns plots mais bonitos depois :)

Bem, está construída nossa classe. Vamos agora fazer as manipulações pedidas no exercício:

xp = np.linspace(0,np.pi,5)

yp = np.sin(xp)

p_L = LagrangeInterpolation(xp, yp)

x = 1.2

print('p_L(%f) =%f' % (x, p_L.func(x)))

print('sin(%f)=%f' % (x, np.sin(x)))

p_L.plot()

seno = np.linspace(0,np.pi,100)
plt.plot(seno, np.sin(seno))

Criamos 5 pontos igualmente distribuidos entre 0 e pi, e calculamos os valores para o seno nesses pontos. Os dois conjuntos serão nossos X e Y.

Atribuimos à variável p_L o tipo LagrangeInterpolation e fazemos a entrada dos conjuntos X e Y respectivamente nomeados como xp e yp.

Vamos agora escolher um ponto arbitrário, no caso, x=1.2; Qual seria o valor da interpolação nesse ponto?

O resultado deste último bloco é:

p_L(1.200000) =0.932240
sin(1.200000)=0.932039

Percebam que o valor da interpolação no ponto não é igual ao valor da própria função no ponto, mas é uma aproximação muito boa!

Para deixar mais claro o que foi feito, vamos comparar os plots da interpolação e da função no pontos:

A imagem será apresentada aqui.

Esta imagem deixa muito claro qual é o papel da interpolação. Em laranja temos o seno da função plotado, e em azul a interpolação nos pontos que usamos de entrada. Podemos dizer que a interpolação funcionou relativamente bem para esses pontos.

Cheers :)

comentou 4 dias atrás por Caio Oliveira Dantas (16 pontos)  
Caso o enunciado não exigisse a implementação de uma classe, poderia ter sido usada a função scipy.interpolate.lagrange(x, w):

from scipy.interpolate import lagrange
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0,np.pi,5)
y = np.sin(x)
poly = lagrange(x, y)
plt.plot(poly)
...