Tous droits réservés

Interpolation linéaire

Notes sur la méthode d'interpolation la plus courante

Publié :
Auteur :
Catégorie :
Temps de lecture estimé : 3 minutes

Lorsqu’on connaît les valeurs que prend une fonction seulement en certains points et qu’on souhaite lui attribuer une valeur en d’autres points, on peut effectuer ce qu’on appelle une interpolation.

La plus courante des interpolations est l’interpolation linéaire : entre deux points connus, la fonction prend la valeur de la fonction affine définie par ces deux points.

Exemple

Voici un exemple pour la fonction sinus cardinal sur l’intervale $[0, 9]$.

Exemple d’interpolation linéaire.

Définition plus formelle

On dispose d’un ensemble de points $x_1$, …, $x_n$, rangés par ordre croissant, pour lesquels on connaît la valeur que prend la fonction $f$. Autrement dit, on connaît les valeurs $y_1 = f(x_1)$, …, $y_n = f(x_n)$.

L’interpolation linéaire consiste à attribuer aux points inconnus la valeur prise par la fonction affine liant les deux points les plus proches. Concrètement, la fonction $f$ est définie sur $[x_1, x_n]$ par :

$$ f(x) = \begin{cases} (1 - \frac{x - x_1}{x_2 - x_1}) y_1 + \frac{x - x_1}{x_2 - x_1} y_2 & x_1 \leq x < x_2 \\ (1 - \frac{x - x_2}{x_3 - x_2}) y_2 + \frac{x - x_1}{x_3 - x_2} y_3 & x_2 \leq x < x_3 \\ ... & & \\ (1 - \frac{x - x_{n-1}}{x_n - x_{n-1}}) y_{n-1} + \frac{x - x_{n-1}}{x_n - x_{n-1}} y_n & x_{n-1} \leq x \leq x_n & \end{cases} $$

Implémentation en Python

Une implémentation rudimentaire en Python se trouve ci-dessous.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
# coding: utf-8

# In[25]:

import numpy as np
x = np.linspace(0, 9, 30)
y = np.sinc(x)


# In[36]:
def interpolant2(x, y):
    def interpFn(x0):
        if x0 < x[0] or x0 > x[-1]:
            raise BaseException
        elif x0 == x[0]:
            return y[0]
        elif x0 == x[-1]:
            return y[-1]
        else:
            i2 = 0
            while x0 > x[i2]:
                i2 += 1
            i1 = i2 - 1
            t = (x0 - x[i1])/(x[i2]-x[i1])
            return y[i1]*(1-t) + t*y[i2]
    return interpFn


# In[45]:

f = interpolant2(x, y)


# In[46]:

x0 = np.linspace(0, 9, 10000)
y0 = np.zeros(10000)
for i in range(10000):
    y0[i] = f(x0[i])


# In[47]:

import matplotlib.pyplot as plt
plt.plot(x0, y0)
plt.xlabel('x')
plt.ylabel('f(x)')
# plt.plot(x,y,'ro')
plt.grid()
plt.show()

Discussion

Avantages

La fonction interpolée est continue.

La quantité de calculs nécessaire est modérée.

Inconvénients

La fonction interpolée n’est pas lisse (dérivée non continue).

Quand l’utiliser ?

Tout le temps. C’est probablement le meilleur choix quand on ne dispose pas d’informations particulières sur la fonction à interpoler.


Aucun commentaire

Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte