Séries de Taylor et erreur de troncature

Les séries de Taylor constituent l'un des outils mathématiques les plus fondamentaux de l'analyse numérique. Elles permettent d'approximer des fonctions complexes par des polynômes, c'est-à-dire par des expressions que les ordinateurs peuvent évaluer efficacement à l'aide des seules opérations arithmétiques élémentaires. Cette leçon présente les fondements théoriques de cet outil ainsi que ses principales applications en calcul scientifique.

L'intuition derrière les séries de Taylor

Un problème concret

Considérons une question en apparence simple : comment un ordinateur calcule-t-il la valeur de ?

Un processeur ne dispose pas d'un circuit dédié à la fonction sinus. Il ne sait effectuer que quatre opérations fondamentales : l'addition, la soustraction, la multiplication et la division. Autrement dit, un processeur sait évaluer des polynômes, et uniquement des polynômes.

Pour calculer des fonctions comme le sinus, l'exponentielle ou le logarithme, il faut donc trouver un moyen de les exprimer sous forme polynomiale.

L'idée de Brook Taylor

Le mathématicien anglais Brook Taylor (1685-1731) a formulé une idée remarquable :

Au voisinage d'un point donné, toute fonction suffisamment régulière peut être approximée par un polynôme dont les coefficients dépendent des dérivées successives de la fonction en ce point.

Cette idée repose sur une intuition géométrique profonde : si deux fonctions ont la même valeur en un point, la même pente, la même courbure, et ainsi de suite pour toutes les dérivées, alors ces deux fonctions doivent être très proches l'une de l'autre au voisinage de ce point.

Une visualisation progressive

Pour illustrer cette idée, considérons la fonction exponentielle au voisinage de . On peut construire une suite de polynômes qui approximent cette fonction de mieux en mieux :

Degré 0 :  P₀(x) = 1                        → même valeur en 0
Degré 1 :  P₁(x) = 1 + x                    → même valeur et même pente
Degré 2 :  P₂(x) = 1 + x + x²/2             → même courbure également
Degré 3 :  P₃(x) = 1 + x + x²/2 + x³/6      → encore plus proche
...

À chaque degré supplémentaire, le polynôme épouse plus fidèlement la courbe de la fonction exponentielle, du moins au voisinage du point de référence.

Applications des séries de Taylor

Avant d'entrer dans les détails mathématiques, il est utile de comprendre pourquoi les séries de Taylor occupent une place si centrale en analyse numérique.

En calcul scientifique

Dans la technologie quotidienne

Les séries de Taylor interviennent, souvent de manière invisible, dans de nombreux systèmes :

• Les calculatrices scientifiques évaluent les fonctions trigonométriques et exponentielles à l'aide de séries polynomiales optimisées.
• Les moteurs physiques des jeux vidéo utilisent des approximations de Taylor pour accélérer les calculs de trajectoires.
• Les récepteurs GPS linéarisent les équations de positionnement grâce à des développements de Taylor.
• Les algorithmes de traitement du signal exploitent des approximations polynomiales pour filtrer et compresser les données.

Formulation mathématique à une variable

Construction du polynôme de Taylor

Soit une fonction définie au voisinage d'un point , et supposons que cette fonction admette des dérivées de tous ordres en . Nous cherchons un polynôme de degré qui approxime au voisinage de .

Pour que cette approximation soit la meilleure possible, nous imposons que le polynôme et la fonction coïncident en , non seulement en valeur, mais aussi pour toutes leurs dérivées jusqu'à l'ordre :

Écrivons le polynôme sous la forme :

En calculant les dérivées successives de et en les évaluant en , on obtient :

De manière générale, . En imposant l'égalité avec , on trouve :

où désigne la factorielle de , avec la convention .

Énoncé du théorème de Taylor

Cette formule peut s'écrire de manière plus compacte à l'aide du symbole de sommation :

Interprétation géométrique des premiers termes

Chaque terme du développement de Taylor possède une signification géométrique précise :

Cas particulier : la série de Maclaurin

Lorsque le point de référence est l'origine (), on parle de série de Maclaurin, du nom du mathématicien écossais Colin Maclaurin (1698-1746) :

Cette forme simplifiée est très fréquemment utilisée en pratique, car les calculs sont plus simples lorsque .

Le reste : mesurer l'erreur d'approximation

Importance du reste en analyse numérique

Lorsqu'on tronque une série de Taylor après termes, on commet une erreur de troncature. Le reste quantifie exactement cette erreur :

En analyse numérique, connaître une borne sur le reste est essentiel pour garantir la précision d'un calcul.

Forme intégrale du reste

Le reste peut s'exprimer sous forme d'une intégrale :

Cette expression est exacte, mais son évaluation nécessite de connaître la dérivée -ième de sur tout l'intervalle d'intégration.

Forme de Lagrange du reste

Une forme plus pratique pour estimer l'erreur est la forme de Lagrange :

où est un point situé strictement entre et . La valeur exacte de est généralement inconnue, mais cette formule permet d'obtenir une majoration de l'erreur.

Majoration pratique de l'erreur

Soit une borne supérieure de pour compris entre et :

Alors l'erreur est majorée par :

Visualisation graphique de l'erreur de troncature

Une approche intuitive pour comprendre l'erreur de troncature consiste à la visualiser graphiquement. Cette section montre comment « lire » l'erreur sur un graphique et comment l'estimer visuellement.

Le principe : comparer la fonction et ses approximations

Considérons une fonction et ses polynômes de Taylor successifs , , ... En traçant ces courbes sur un même graphique, l'erreur de troncature à l'ordre apparaît comme l'écart vertical entre et .

y
│
│     f(x)
│    ╱ ↑
│   ╱  │ Erreur R₂(x) = f(x) - P₂(x)
│  ╱   ↓
│ ╱  ·······P₂(x)
│╱
├──────────────────────x
0       x₀

L'erreur se lit directement comme la distance verticale
entre la courbe de f et celle du polynôme de Taylor.

Observation fondamentale : convergence vers le point de référence

Sur un graphique comparant et ses approximations polynomiales, on observe systématiquement :

1. Au point de référence : toutes les courbes passent par le même point — l'erreur y est nulle par construction.

2. Près de : l'écart est très faible, et plus est grand, plus le polynôme « colle » à la fonction sur une zone étendue.

3. Loin de : les polynômes de Taylor divergent progressivement de la fonction. L'erreur croît rapidement.

Exemple visuel : l'exponentielle et ses approximations

Considérons au voisinage de . Les polynômes de Taylor successifs sont :

Le graphique interactif ci-dessous permet de visualiser comment ces polynômes approximent la fonction exponentielle. Utilisez les boutons pour afficher ou masquer différents ordres.

Comment lire l'erreur sur le graphique

Pour estimer visuellement en un point donné :

1. Repérer le point sur l'axe horizontal.
2. Tracer une verticale passant par ce point.
3. Mesurer l'écart entre la courbe de et celle de .

La zone grisée (ou hachurée) entre les deux courbes représente visuellement le domaine de l'erreur.

Déterminer graphiquement le nombre de termes nécessaires

En pratique, on peut utiliser le graphique pour répondre à la question : combien de termes faut-il pour atteindre une précision donnée sur un intervalle donné ?

Méthode :

1. Tracer et plusieurs polynômes .
2. Définir une « bande de tolérance » autour de (par exemple ).
3. Identifier le plus petit tel que reste dans cette bande sur tout l'intervalle d'intérêt.

Le graphique interactif ci-dessous illustre cette méthode pour la fonction sinus avec trois polynômes : , et . La bande de tolérance (en pointillés gris) entoure la courbe de sin(x). Ajustez le curseur pour voir quel polynôme reste dans la bande acceptable.

Lien avec l'erreur de troncature en analyse numérique

Cette visualisation illustre un concept fondamental en analyse numérique : l'erreur de troncature est inévitable dès qu'on approxime une série infinie par un nombre fini de termes.

La question pratique devient alors : comment choisir le bon compromis entre :

• Précision (plus de termes = moins d'erreur)
• Coût de calcul (plus de termes = plus d'opérations)
• Stabilité numérique (trop de termes peut introduire des erreurs d'arrondi)

Le graphique permet de visualiser ce compromis et d'identifier la « zone utile » où l'approximation est acceptable.

Visualiser directement l'erreur de troncature

Pour mieux comprendre le comportement de l'erreur, on peut tracer directement la fonction . Ce graphique montre comment l'erreur varie en fonction de et de l'ordre .

Développements de Taylor des fonctions usuelles

La fonction exponentielle

Calculons le développement de Maclaurin de .

La fonction exponentielle possède une propriété remarquable : toutes ses dérivées sont égales à elle-même.

Par conséquent, pour tout entier .

Le développement de Maclaurin s'écrit donc :

Cette série converge pour tout nombre réel . Illustrons la rapidité de convergence en calculant :

Avec seulement onze termes, on atteint une précision de six décimales.

La fonction sinus

Pour , les dérivées successives suivent un cycle de période 4 :

En évaluant ces dérivées en , on obtient la suite :

Seules les dérivées d'ordre impair sont non nulles, ce qui donne :

La présence exclusive de puissances impaires reflète le fait que le sinus est une fonction impaire : .

La fonction cosinus

Un raisonnement analogue pour conduit à :

Cette fois, seules les puissances paires apparaissent, conformément au caractère pair de la fonction cosinus : .

Tableau récapitulatif des développements usuels

Extension aux fonctions de plusieurs variables

En analyse numérique, on rencontre fréquemment des fonctions dépendant de plusieurs variables. Le développement de Taylor se généralise naturellement à ce contexte.

Développement à deux variables

Considérons une fonction que l'on souhaite développer au voisinage d'un point . Le développement de Taylor à l'ordre 2 s'écrit :

Notation des dérivées partielles

Pour alléger l'écriture, on utilise souvent les notations abrégées suivantes :

L'approximation linéaire

L'approximation de Taylor à l'ordre 1 pour une fonction de deux variables s'écrit :

Cette expression définit le plan tangent à la surface au point . Elle est fondamentale pour l'étude des extrema et pour la résolution numérique de systèmes d'équations non linéaires.

Formulation vectorielle

Pour une fonction de variables , où , le développement de Taylor au voisinage de prend la forme :

Dans cette expression :

• désigne le gradient de , c'est-à-dire le vecteur des dérivées partielles premières.
• désigne la matrice hessienne de , c'est-à-dire la matrice des dérivées partielles secondes.

Application pratique : calcul du sinus

Pour conclure cette leçon, examinons comment une bibliothèque mathématique pourrait implémenter le calcul du sinus à l'aide de sa série de Taylor.

import math

def sinus_taylor(x, nombre_termes=10):
  """
  Calcule sin(x) par développement de Taylor.

  Développement utilisé :
  sin(x) = x - x³/3! + x⁵/5! - x⁷/7! + ...

  Paramètres :
      x : angle en radians
      nombre_termes : nombre de termes de la série à utiliser

  Retourne :
      approximation de sin(x)
  """
  # Réduction de l'argument à l'intervalle [-π, π]
  # pour améliorer la convergence
  x = x % (2 * math.pi)
  if x > math.pi:
      x -= 2 * math.pi

  resultat = 0.0
  for k in range(nombre_termes):
      signe = (-1) ** k
      exposant = 2 * k + 1
      terme = signe * (x ** exposant) / math.factorial(exposant)
      resultat += terme

  return resultat


# Comparaison avec la fonction sinus de la bibliothèque standard
print("Comparaison entre l'implémentation par série de Taylor et math.sin()")
print()
print(f"{'Angle (rad)':<12} | {'Taylor':<22} | {'math.sin()':<22} | {'Écart':<12}")
print("-" * 75)

angles_test = [0.1, 0.5, 1.0, math.pi/4, math.pi/2, math.pi]

for angle in angles_test:
  valeur_taylor = sinus_taylor(angle)
  valeur_exacte = math.sin(angle)
  ecart = abs(valeur_taylor - valeur_exacte)
  print(f"{angle:<12.4f} | {valeur_taylor:<22.15f} | {valeur_exacte:<22.15f} | {ecart:<12.2e}")

Synthèse

Les séries de Taylor constituent un outil théorique et pratique indispensable en analyse numérique. Elles permettent de :

1. Approximer des fonctions complexes par des polynômes, qui sont faciles à évaluer numériquement.

2. Quantifier les erreurs de troncature grâce à la formule du reste, ce qui permet de garantir la précision des calculs.

3. Analyser le comportement local des fonctions en les linéarisant ou en les approximant à un ordre supérieur.

4. Construire des méthodes numériques pour la résolution d'équations, l'intégration et les équations différentielles.

La formule du reste de Lagrange, , est l'outil clé pour déterminer le nombre de termes nécessaires afin d'atteindre une précision donnée.

Dans la prochaine leçon, nous utiliserons les développements de Taylor pour étudier comment les erreurs se propagent à travers une séquence de calculs.

Exercices

Exercice 1 : Calcul d'un développement

Déterminez les quatre premiers termes non nuls du développement de Maclaurin de la fonction .

Indication : Calculez successivement , , et , sachant que .

Exercice 2 : Estimation de l'erreur

On souhaite calculer en utilisant les cinq premiers termes de la série de Taylor de l'exponentielle.

1. Calculez la valeur approchée obtenue.
2. Utilisez la formule du reste de Lagrange pour majorer l'erreur commise.
3. Comparez votre résultat avec la valeur exacte

Exercice 3 : Éviter l'annulation catastrophique

La fonction pose un problème numérique lorsque est proche de zéro.

1. Expliquez pourquoi le calcul direct de cette expression est numériquement instable pour .
2. En utilisant le développement de Taylor de , établissez un développement de valable au voisinage de zéro.
3. Déduisez-en une méthode de calcul stable pour lorsque est petit.

Exercice 4 : Fonction de deux variables

Soit .

1. Calculez les dérivées partielles , , , et .
2. Évaluez ces dérivées au point .
3. Écrivez le développement de Taylor de à l'ordre 2 au voisinage de l'origine.
4. Utilisez ce développement pour estimer , puis comparez avec la valeur exacte.

Matériel supplémentaire : code Python

Les visualisations interactives de cette leçon sont implémentées en JavaScript avec la bibliothèque Recharts. Voici les équivalents Python pour ceux qui souhaitent reproduire ces graphiques localement ou les adapter à leurs besoins.

Visualisation des approximations de Taylor de l'exponentielle

import numpy as np
import matplotlib.pyplot as plt
from math import factorial

def exp_taylor(x, n):
  """Calcule le polynôme de Taylor de e^x à l'ordre n en a=0."""
  resultat = 0
  for k in range(n + 1):
      resultat += x**k / factorial(k)
  return resultat

# Créer les données
x = np.linspace(-2, 3, 500)
y_exact = np.exp(x)

# Créer le graphique
plt.figure(figsize=(12, 6))

# Tracer la fonction exacte
plt.plot(x, y_exact, 'k-', linewidth=2, label=r'$e^x$ (exacte)')

# Tracer les approximations de Taylor
couleurs = ['red', 'blue', 'green', 'orange']
for n, couleur in enumerate(couleurs, start=1):
  y_taylor = np.array([exp_taylor(xi, n) for xi in x])
  plt.plot(x, y_taylor, color=couleur, linestyle='--',
           label=f'$P_{n}(x)$ (ordre {n})')

# Mise en forme
plt.xlim(-2, 3)
plt.ylim(-1, 12)
plt.axhline(y=0, color='gray', linewidth=0.5)
plt.axvline(x=0, color='gray', linewidth=0.5, linestyle='--')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Approximations de Taylor de $e^x$ au voisinage de $x = 0$')
plt.legend()
plt.grid(True, alpha=0.3)

# Annoter l'erreur pour x = 2
x_point = 2
y_exact_point = np.exp(x_point)
y_taylor_point = exp_taylor(x_point, 2)
plt.annotate('', xy=(x_point, y_exact_point), xytext=(x_point, y_taylor_point),
           arrowprops=dict(arrowstyle='<->', color='purple'))
plt.text(x_point + 0.1, (y_exact_point + y_taylor_point) / 2,
       f'$R_2({x_point}) = {y_exact_point - y_taylor_point:.2f}$', fontsize=10)

plt.tight_layout()
plt.savefig('taylor_exp.png', dpi=150)
plt.show()

Visualisation de sin(x) avec bande de tolérance

import numpy as np
import matplotlib.pyplot as plt
from math import factorial

def sin_taylor(x, n):
  """Polynôme de Taylor de sin(x) avec n+1 termes non nuls (ordre 2n+1)."""
  resultat = 0
  for k in range(n + 1):
      signe = (-1) ** k
      exposant = 2 * k + 1
      resultat += signe * x**exposant / factorial(exposant)
  return resultat

# Intervalle d'intérêt
x = np.linspace(-np.pi, np.pi, 500)
y_exact = np.sin(x)

# Tolérance souhaitée
tolerance = 0.05

plt.figure(figsize=(12, 6))

# Tracer sin(x) avec bande de tolérance centrée sur la courbe
plt.fill_between(x, y_exact - tolerance, y_exact + tolerance,
               alpha=0.3, color='gray', label=f'Tolérance ±{tolerance}')
plt.plot(x, y_exact, 'k-', linewidth=2, label=r'$sin(x)$')

# Polynômes P₃, P₇, P₁₅
polynomes = [(1, 3), (3, 7), (7, 15)]  # (n, ordre) où ordre = 2n+1
couleurs = ['red', 'blue', 'green']

for (n, ordre), couleur in zip(polynomes, couleurs):
  y_taylor = np.array([sin_taylor(xi, n) for xi in x])
  plt.plot(x, y_taylor, color=couleur, linestyle='--',
           label=f'$P_{{{ordre}}}(x)$')

plt.xlim(-np.pi, np.pi)
plt.ylim(-1.5, 1.5)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Précision des approximations de Taylor de sin(x)')
plt.legend()
plt.grid(True, alpha=0.3)

# Ajouter les labels en π
plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],
         [r'$-pi$', r'$-pi/2$', '0', r'$pi/2$', r'$pi$'])

plt.tight_layout()
plt.savefig('taylor_sin_tolerance.png', dpi=150)
plt.show()

Visualisation directe de l'erreur de troncature

import numpy as np
import matplotlib.pyplot as plt
from math import factorial

def exp_taylor(x, n):
  """Calcule le polynôme de Taylor de e^x à l'ordre n en a=0."""
  resultat = 0
  for k in range(n + 1):
      resultat += x**k / factorial(k)
  return resultat

# Créer les données
x = np.linspace(-2, 3, 500)

plt.figure(figsize=(12, 6))

# Tracer l'erreur pour différents ordres
couleurs = ['red', 'blue', 'green', 'orange', 'purple', 'brown']

for ordre, couleur in zip(range(1, 7), couleurs):
  erreur = np.exp(x) - np.array([exp_taylor(xi, ordre) for xi in x])
  plt.plot(x, erreur, color=couleur, linewidth=1.5,
           label=f'$R_{ordre}(x)$')

plt.axhline(y=0, color='gray', linewidth=0.5)
plt.axvline(x=0, color='gray', linewidth=0.5, linestyle='--')
plt.xlabel('x')
plt.ylabel('Erreur $R_n(x) = e^x - P_n(x)$')
plt.title('Erreur de troncature pour différents ordres')
plt.legend()
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('taylor_erreur.png', dpi=150)
plt.show()

Version interactive avec widgets (Jupyter)

Pour une expérience interactive similaire aux graphiques de cette leçon, vous pouvez utiliser les widgets Jupyter :

import numpy as np
import matplotlib.pyplot as plt
from math import factorial
from ipywidgets import interact, IntSlider, FloatSlider

def exp_taylor(x, n):
  """Polynôme de Taylor de e^x à l'ordre n."""
  return sum(x**k / factorial(k) for k in range(n + 1))

def sin_taylor(x, n_termes):
  """Polynôme de Taylor de sin(x) avec n_termes termes non nuls."""
  return sum((-1)**k * x**(2*k+1) / factorial(2*k+1) for k in range(n_termes))

# Graphique interactif pour l'exponentielle
def plot_exp_taylor(ordre_max=4):
  x = np.linspace(-2, 3, 300)
  plt.figure(figsize=(10, 5))
  plt.plot(x, np.exp(x), 'k-', lw=2, label=r'$e^x$')

  couleurs = plt.cm.tab10(np.linspace(0, 1, ordre_max))
  for n in range(1, ordre_max + 1):
      y = np.array([exp_taylor(xi, n) for xi in x])
      plt.plot(x, y, '--', color=couleurs[n-1], label=f'$P_{n}$')

  plt.xlim(-2, 3)
  plt.ylim(-1, 12)
  plt.axhline(0, color='gray', lw=0.5)
  plt.axvline(0, color='gray', lw=0.5, ls='--')
  plt.legend()
  plt.grid(alpha=0.3)
  plt.title(f'Approximations de Taylor de $e^x$ (ordres 1 à {ordre_max})')
  plt.show()

# Graphique interactif pour le sinus avec tolérance
def plot_sin_tolerance(tolerance=0.01, n_termes_max=4):
  x = np.linspace(-np.pi, np.pi, 300)
  y_exact = np.sin(x)

  plt.figure(figsize=(10, 5))
  plt.fill_between(x, y_exact - tolerance, y_exact + tolerance,
                   alpha=0.3, color='gray')
  plt.plot(x, y_exact, 'k-', lw=2, label=r'$sin(x)$')

  couleurs = plt.cm.tab10(np.linspace(0, 1, n_termes_max))
  for n in range(1, n_termes_max + 1):
      y = np.array([sin_taylor(xi, n) for xi in x])
      ordre = 2*n - 1
      plt.plot(x, y, '--', color=couleurs[n-1], label=f'$P_{{{ordre}}}$')

  plt.xlim(-np.pi, np.pi)
  plt.ylim(-1.5, 1.5)
  plt.legend()
  plt.grid(alpha=0.3)
  plt.title(f'Tolérance ±{tolerance}')
  plt.show()

# Utilisation dans Jupyter :
# interact(plot_exp_taylor, ordre_max=IntSlider(min=1, max=8, value=4))
# interact(plot_sin_tolerance,
#          tolerance=FloatSlider(min=0.001, max=0.1, step=0.001, value=0.01),
#          n_termes_max=IntSlider(min=1, max=6, value=4))