introduction

** Effectuer une interpolation en utilisant la méthode lagrange d'interpolation de scipy. ** **

** Interpoler un jeu de données N + 1 donné ($ x_i $, $ y_i $) (i = 0,2, 3, ..., N) par polynôme d'ordre N ([Interpolation de Lagrange](https :: //ja.wikipedia.org/wiki/%E3%83%A9%E3%82%B0%E3%83%A9%E3%83%B3%E3%82%B8%E3%83%A5%E8%A3 % 9C% E9% 96% 93)) Implémentez le programme en Python3. ** **

Considérez $ y = 1 / (1 + x ^ 2) $ comme exemple. Échantillonnez un ensemble de données à 11 points ($ x_i $, $ y_i $) et interpolez-le avec un polynôme d'ordre 10. Cette fonction ne fonctionne pas avec l'interpolation de Lagrange [phénomène Runge](https://ja.wikipedia.org/wiki/%E3%83%AB%E3%83%B3%E3%82%B2%E7%8F%BE%E8 Il est connu comme un exemple de cause de% B1% A1).

Contenu

Code 1: utilisez scipy / numpy. Code minimal (** Cliquez ici si vous êtes pressé **) Code 2: Calculez les coefficients d'interpolation dans le code. Cliquez ici pour étudier la méthode.

Code de calcul (1): utilisez scipy / numpy

`code(1)scipyを利用してラクをするcode。`


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

##Principale
x =np.linspace(-5,5,num=11) #[-5,5]Divisez la plage de en 11 parties égales et stockez-la en x
y = 1.0/(1.0+x**2)          #La fonction considérée dans cet exemple, y= 1/(1+x^2)Définir
f_Lag=lagrange(x,y) #scipy.interpolate.Exécution d'interpolation de Lagrange par lagrange
##

#for plot
xnew =np.linspace(-5,5,num=51) # [-5,5]Divisez la gamme de en 51 parties égales et stockez-la dans xnew
plt.plot(x, y, 'o',  xnew, f_Lag(xnew), '-')   #Données brutes"o"Donc, la ligne qui est interpolée par Lagrange('-')Dessinez avec.
plt.legend(['Raw data','Lagrange'], loc='best')  #spécification de la légende
plt.xlim([-6, 6])  #plage de tracé de l'axe des x
plt.ylim([0, 1.4]) #plage de tracé de l'axe y
plt.show()

Résultat (1)

11 points de données échantillonnés en bleu. La ligne orange est interpolée de Lagrange.

Code de calcul (2) Calculer le coefficient d'interpolation avec python

`code(2)code中に直接数値計算を実行する`



"""
interpolation: ラグランジュinterpolation
exemple: y = 1/(1+x**2):Section-11 points de 5 à 5 sont échantillonnés et Lagrange interpolés.
"""
from math import pi,e, log, factorial
import matplotlib.pyplot as plt


### 
def g(i, x): #Calcul du coefficient d'interpolation de Lagrange. Principale.
    dum=1.0
    for j in range(len(x_lis)):
        if j != i :
            dum *= (x-x_lis[j])/(x_lis[i]-x_lis[j])
    return dum

#
def fLag(x,m): #Interpolation de Lagrange
    dum=0.0
    for j in range(m):
        dum += y_lis[j]*g(j, x)
    
    return dum
###
    
##Construction du jeu de données pour l'exemple
m = 11  #  x= -Échantillonnage en 11 points à intervalles réguliers de 5 à 5
x_lis = []
y_lis = []
def yy(x):
    return 1/(1+x**2) #Exemple de fonction y= 1/(1+x**2)

for k in range(m):
    xm = -5.0 + 10.0*k / m
    x_lis.append(xm)
    y_lis.append(yy(xm))
    
plt.plot(x_lis,y_lis, 'o',label='Row data')
##

###Exécution d'interpolation de Lagrange
mm = 5000
y_Laglis = []
xx_lis = []
for k  in range(mm):
    xm = -5.0 + 10.0*k / mm
    xx_lis.append(xm)

y_lis_exact=[]
for j in range(mm):
    y_Laglis.append(fLag(xx_lis[j],m))
    y_lis_exact.append(yy(xx_lis[j]))

    
#plot
plt.grid(True)
plt.xlabel('x',fontsize=24)
plt.ylabel('f(x)',fontsize=24)
plt.xticks(fontsize=18)
plt.yticks(fontsize=18)
plt.plot(xx_lis,y_Laglis, color='Red',label='Lagrange')
plt.plot(xx_lis,y_lis_exact, color='Black',label='Exact')
plt.legend(loc='upper left')
plt.show()¥

Résultat (2)

11 points de données échantillonnés en bleu. La ligne rouge est interpolée de Lagrange. La ligne noire représente la solution exacte.

** Au fur et à mesure que l'ordre (points de données) augmente, l'approximation de la partie centrale devient meilleure, mais l'approximation de la partie près des deux extrémités devient pire. Il est connu comme un exemple dans lequel l'erreur augmente à mesure que l'ordre augmente et diverge finalement vers l'infini. Ceci est dû à l'utilisation de points de division régulièrement espacés, et il est connu que cela peut être évité en rendant la coordination des points de division approximative près du centre et finement divisée aux deux extrémités [1]. ** **

Addendum: Conditions pour une interpolation de Lagrange régulièrement espacée pour se rapprocher de la fonction d'origine f (x) lorsque le score augmente.

** Pour l'intervalle [-1,1]: Lorsque la zone de définition de $ f (x) $ est analysée et connectée au plan complexe, sa singularité $ z $ est **

|(1+z)^{1+z}| \leqq 4 e^{\pi |Im(z)|}

** Ne répond pas **. Dans cet exemple, la singularité z de $ f (z) = 1 / (1 + z ^ 2) $ est $ ± i $. Le côté droit de l'inégalité est $ 4e ^ \ pi = 92,562770531 ... , Le côté gauche est|(1+i)^{1+i}| = 0.644793...$ Par conséquent, puisque l'inégalité ci-dessus est ** satisfaite **, l'erreur d'interpolation de Lagrange (interpolation polypolymétrique) utilisant des points de division régulièrement espacés augmente à mesure que le nombre de points de division augmente.

Si f (x) est une fonction continue dans l'intervalle [a, b], le polymorphisme d'interpolation s'approche de f (x) à la limite où N est infini si le point de division $ x_n $ est sélectionné comme suit [2]. ..

x_n = (a+b)/2 + (b-a)(sin(-\pi/2+n\pi/N))/2, $(n = 0, 1, 2, ...,N) $

De plus, le phénomène de Rung comme vu ci-dessus ne se produit pas dans l'interpolation polymorphe dans laquelle le point zéro d'un polynôme orthogonal (par exemple, le polynôme de Chebisif) est choisi comme point de division [1].

Les références

[1] Masatake Mori, ["Numerical Analysis Second Edition"](https://www.amazon.co.jp/%E6%95%B0%E5%80%A4%E8%A7%A3%E6%9E % 90-% E5% 85% B1% E7% AB% 8B% E6% 95% B0% E5% AD% A6% E8% AC% 9B% E5% BA% A7-% E6% A3% AE-% E6% AD% A3% E6% AD% A6 / dp / 4320017013), Kyoritsu Publishing, 2002. [2] Masao Iri et Kazutake Fujino, ["Connaissances communes du calcul numérique"](https://www.amazon.co.jp/%E6%95%B0%E5%80%A4%E8%A8%88 % E7% AE% 97% E3% 81% AE% E5% B8% B8% E8% AD% 98-% E4% BC% 8A% E7% 90% 86-% E6% AD% A3% E5% A4% AB / dp / 4320013433), Kyoritsu Publishing, 1985.

[Calcul scientifique / technique par Python] Interpolation de Lagrange, calcul numérique