Pesquisa de site

Interpolação direta de Gauss

A interpolação direta de Gauss é um método numérico que nos permite determinar o valor de uma função em um determinado ponto dentro de um intervalo específico usando uma sequência de pontos de dados igualmente espaçados. Este método de interpolação polinomial usa a fórmula da diferença dividida de Newton para calcular os coeficientes do polinômio. Este método é particularmente útil para estimar valores para vários locais igualmente espaçados dentro de um determinado intervalo. Examinaremos o método de implementação do Python neste artigo.

Instalação

Para usar o método Forward Interpolation de Gauss, a biblioteca numpy pode ser instalada através deste comando, pois realizaremos cálculos matemáticos complexos.

pip install numpy

Algoritmo

  • Vamos começar inserindo a função f(x), o intervalo de valores de x [a,b], o número de pontos de dados igualmente espaçados n e o ponto em que queremos aproximar o valor da função x0. Precisamos primeiro determinar o espaçamento h entre os pontos de dados, o que podemos fazer usando a fórmula h=(b-a)/(n-1).

  • A seguir, precisamos criar um array D que armazenará as diferenças divididas de f(x) em pontos igualmente espaçados. Para fazer isso, podemos atribuir D[i,0] com f(a + (i-1)h) para I variando de 1 a n, o que nos ajudará a calcular a seção principal de D . Para as seções excedentes de D, podemos usar a fórmula D[i,j]=(D[i,j-1] - D[i-1,j-1])/(jh), onde i vai de j+1 a n e j varia de 1 a n-1.

  • Os coeficientes do polinômio interpolador podem ser determinados uma vez que as diferenças divididas de f(x) em pontos igualmente espaçados preenchem nosso array D.

  • Finalmente, podemos usar a fórmula P(x0)=c[1] + (x0 - a)c[2] + (x0 - a)(x0 - a - h)c[3]/2 +... para avaliar o polinômio interpolador em x0 (x0). Isso pode ser feito definindo c[j] igual a D[j,j] para j variando de 1 a n.

Exemplo

Aproximando a função sin(x) em x=0,2 usando 5 pontos de dados igualmente espaçados no intervalo [0,1] -

import numpy as np

# Define the function
def f(x):
   return np.sin(x)

# Set up the inputs
a = 0
b = 1
n = 5
x0 = 0.2

# Calculate the spacing
h = (b - a)/(n - 1)

# Calculate the divided differences
D = np.zeros((n,n))
for i in range(n):
   D[i,0] = f(a + i*h)
for j in range(1,n):
   for i in range(j,n):
      D[i,j] = (D[i,j-1] - D[i-1,j-1])/(j*h)

# Calculate the coefficients
c = np.zeros(n)
for j in range(n):
   c[j] = D[j,j]

# Evaluate the interpolating polynomial
P = c[0]
for j in range(1,n):
   prod = 1
   for k in range(j):
      prod = (x0 - a - k*h)
   P += prod*c[j]/np.math.factorial(j)

print("Approximation of sin(0.2): ", P)

Saída

Approximation of sin(0.2):  0.20824045983077355

  • A função f(x) é definida para calcular sin(x).

  • a, b, n e x0 são inicializados como valores de entrada.

  • O espaçamento h é calculado como (b - a)/(n - 1).

  • As diferenças divididas D são calculadas preenchendo a primeira coluna com os valores da função em pontos igualmente espaçados e, em seguida, o restante das colunas usando a fórmula (D[i,j-1] - D[i-1,j -1])/(j*h).

  • Os coeficientes c são calculados tomando a diagonal da matriz de diferenças dividida.

  • O polinômio interpolador é avaliado usando os coeficientes c e o valor de entrada x0. A variável prod é usada para calcular o produto de (x0 - a - k*h) para os valores necessários de k. Por fim, a variável P é atualizada utilizando este produto e os coeficientes.

  • A saída deste código é a aproximação de sin(0.2). A implementação pode ser modificada para diferentes valores de entrada e funções.

2. Aproximando a função e^(x/2) em x=1,5 usando 4 pontos de dados igualmente espaçados no intervalo [1,2] -

import numpy as np

# Define the function
def f(x):
   return np.exp(x/2)

# Set up the inputs
a = 1   # Lower limit
b = 2   # Upper limit
n = 4   # data pts count
x0 = 1.5   # Interpolation point

# Calculate the spacing
h = (b - a)/(n - 1)

# Calculate the divided differences
D = np.zeros((n,n))   # Initialize divided differences matrix
for i in range(n):
   D[i,0] = f(a + i*h)
for j in range(1,n):
   for i in range(j,n):
      D[i,j] = (D[i,j-1] - D[i-1,j-1])/(j*h)

# Calculate the coefficients
c = np.zeros(n)
for j in range(n):
   c[j] = D[j,j]

# Evaluate the interpolating polynomial
P = c[0]
for j in range(1,n):
   prod = 1
   for k in range(j):
      prod = prod * (x0 - a - k*h)
   P += prod*c[j]/np.math.factorial(j)

# Print the result
print("Approximation of e^(1.5/2): ", P)

Saída

Approximation of e^(1.5/2):  2.1073059306325783

Formulários

A técnica de adição direta de Gauss pode ser utilizada em vários campos, como dinheiro, ciência de materiais, design e ilustrações de PC. Por exemplo, pode muito bem ser utilizado para introduzir informações monetárias, como custos de ações, para avaliar qualidades futuras. Ele pode ser usado para estimar o valor de uma quantidade física em um momento ou local específico da física. Pode ser usado em engenharia para estimar o comportamento de um sistema complicado, como uma aeronave, com base em uma pequena quantidade de dados. Em visualizações, pode ser usado para adicionar o número ou a potência dos pixels em uma imagem para fazer um movimento suave entre os pixels vizinhos.

Conclusão

O método numérico de interpolação direta de Gauss, que interpola uma função usando uma série de pontos de dados espaçados uniformemente, foi abordado neste artigo. Discutimos exaustivamente a técnica e incluímos vários exemplos de implementação do Python. O uso da técnica de interpolação direta de Gauss em muitos domínios também foi abordado. No geral, a abordagem de interpolação direta de Gauss pode ser aplicada em vários cenários do mundo real e é uma ferramenta valiosa para aproximar funções.

Artigos relacionados: