Systèmes d'équations non linéaires

Objectifs d'apprentissage

À la fin de cette leçon, vous serez en mesure de :

• Comprendre pourquoi on rencontre des systèmes non linéaires et leurs particularités
• Appliquer la méthode du point fixe à plusieurs variables
• Maîtriser la méthode de Newton multivariable
• Calculer et interpréter la matrice jacobienne
• Choisir une bonne estimation initiale et comprendre son importance

Prérequis

• Méthode de Newton pour une équation (Chapitre 2)
• Systèmes linéaires et factorisation LU (ce chapitre)
• Notion de dérivées partielles

Pourquoi des systèmes non linéaires ?

Le monde réel est rarement linéaire

Jusqu'ici, nous avons résolu des systèmes linéaires . Mais dans de nombreuses applications, les équations ne sont pas linéaires :

Exemple 1 : Cinématique d'un robot

Un bras robotique à 2 articulations doit atteindre un point dans l'espace. Si les bras ont des longueurs et , les angles et doivent satisfaire :

Ce sont des équations non linéaires en à cause des fonctions trigonométriques.

Exemple 2 : Équilibre chimique

Les concentrations à l'équilibre d'une réaction chimique satisfont des relations impliquant des produits de concentrations (loi d'action de masse).

Exemple 3 : Intersection de courbes

Trouver où un cercle intersecte une hyperbole :

Formulation générale

Un système de n équations non linéaires à n inconnues s'écrit :

où :

• est le vecteur des inconnues
• est une fonction vectorielle

Chaque peut dépendre de toutes les variables de manière non linéaire.

Différences fondamentales avec le cas linéaire

Illustration géométrique

Notre exemple et a 4 solutions (les 4 points d'intersection du cercle et de l'hyperbole). Selon le point de départ, Newton convergera vers l'une ou l'autre.

La matrice jacobienne : généralisation de la dérivée

Rappel : Newton en 1D

Pour résoudre en une variable, Newton utilise la dérivée :

Qu'est-ce qui joue le rôle de pour un système à plusieurs variables ?

La jacobienne : la "dérivée" d'une fonction vectorielle

Exemple concret

Pour notre système cercle-hyperbole :

La jacobienne est :

Au point :

Interprétation géométrique

La jacobienne donne la meilleure approximation linéaire de autour d'un point :

C'est l'analogue multidimensionnel de .

Méthode de Newton multivariable

Principe : linéariser et résoudre

L'idée de Newton est simple : remplacer le problème non linéaire par une suite de problèmes linéaires.

À chaque itération :

1. Linéariser autour de :
2. Résoudre l'équation linéarisée
3. Itérer avec la solution comme nouveau point

Formule de Newton

En posant , on obtient le système linéaire :

puis :

Exemple pas à pas

Résolvons et en partant de .

Itération 1 :

1. Évaluer :

2. Calculer la jacobienne :

3. Résoudre :

Par élimination de Gauss (ou substitution) : ,

4. Mettre à jour :

Itération 2 :

On est déjà proche de zéro ! Après quelques itérations supplémentaires, on converge vers .

Vérification : ✓ et ✓

Visualisation interactive

Convergence de Newton

Théorème de convergence locale

Interprétation de la convergence quadratique

Quadratique signifie que le nombre de chiffres corrects double à chaque itération :

| Itération | Erreur approximative | |-----------|---------------------| | k = 0 | (1 chiffre) | | k = 1 | (2 chiffres) | | k = 2 | (4 chiffres) | | k = 3 | (8 chiffres) | | k = 4 | (précision machine !) |

En 4-5 itérations, on atteint souvent la précision maximale possible.

Quand Newton échoue

La méthode peut échouer si :

1. Jacobienne singulière : → division par zéro
2. Point de départ trop loin : on peut diverger ou osciller
3. Pas de solution : n'a pas de solution

Choix de l'estimation initiale

Le succès de Newton dépend fortement du point de départ .

Stratégies pratiques

Exemple : trouver les 4 solutions

Pour notre système cercle-hyperbole, les 4 solutions sont dans les 4 quadrants. En partant de points dans chaque quadrant, on peut les trouver toutes :

| Point de départ | Solution trouvée | |-----------------|------------------| | | | | | | | | | | | |

Approximation numérique de la jacobienne

Quand les dérivées analytiques sont difficiles

Parfois, calculer les dérivées partielles analytiquement est :

• Fastidieux (formules complexes)
• Impossible (fonction définie par du code, pas une formule)

On peut alors approximer la jacobienne par différences finies.

Formule par différences finies

où est le j-ème vecteur de base.

Choix de h : typiquement en double précision.

Coût computationnel

Pour une jacobienne :

• Analytique : une évaluation de J
• Numérique : évaluations de F (une pour F(x), une pour chaque colonne)

Pour de grands systèmes, l'approximation numérique peut être coûteuse !

Méthode du point fixe (alternative)

Principe

Comme pour une équation scalaire, on peut reformuler en :

et itérer .

Exemple

Pour et , une reformulation :

Condition de convergence

Comparaison avec Newton

En pratique, Newton est généralement préféré pour sa convergence rapide.

Résumé

Points clés à retenir :

1. Systèmes non linéaires : peuvent avoir plusieurs solutions, pas de méthode directe
2. Jacobienne : matrice des dérivées partielles, généralise la dérivée
3. Newton : convergence quadratique, résout un système linéaire à chaque itération
4. Estimation initiale : cruciale — détermine vers quelle solution on converge
5. Jacobienne numérique : alternative quand les dérivées analytiques sont indisponibles

Implémentations Python

Méthode de Newton avec jacobienne analytique

import numpy as np

def newton_systeme(F, jacobian, x0, max_iter=50, tol=1e-10):
  """
  Méthode de Newton pour système F(x) = 0.

  Paramètres:
  -----------
  F : fonction qui retourne le vecteur F(x)
  jacobian : fonction qui retourne la matrice J(x)
  x0 : estimation initiale
  max_iter : nombre maximum d'itérations
  tol : tolérance pour ||F(x)||

  Retourne:
  ---------
  x : solution approchée
  """
  x = np.array(x0, dtype=float)

  for k in range(max_iter):
      f = F(x)

      # Test de convergence sur ||F(x)||
      if np.linalg.norm(f) < tol:
          print(f"Convergence en {k+1} itérations")
          return x

      # Calculer la jacobienne
      J = jacobian(x)

      # Résoudre le système linéaire J · Δx = -F
      delta_x = np.linalg.solve(J, -f)

      # Mise à jour : x = x + Δx
      x = x + delta_x

  print(f"Non convergé après {max_iter} itérations")
  return x

Jacobienne par différences finies

def jacobienne_numerique(F, x, h=1e-8):
  """
  Calcule la matrice jacobienne par différences finies.

  Coût : n+1 évaluations de F pour une jacobienne n×n.
  """
  n = len(x)
  f0 = F(x)
  J = np.zeros((n, n))

  for j in range(n):
      x_perturb = x.copy()
      x_perturb[j] += h
      J[:, j] = (F(x_perturb) - f0) / h

  return J

def newton_numerique(F, x0, max_iter=50, tol=1e-10):
  """
  Newton avec jacobienne calculée numériquement.
  Utile quand les dérivées analytiques sont indisponibles.
  """
  x = np.array(x0, dtype=float)

  for k in range(max_iter):
      f = F(x)

      if np.linalg.norm(f) < tol:
          print(f"Convergence en {k+1} itérations")
          return x

      J = jacobienne_numerique(F, x)
      delta_x = np.linalg.solve(J, -f)
      x = x + delta_x

  print(f"Non convergé après {max_iter} itérations")
  return x

Méthode du point fixe

def point_fixe_systeme(G, x0, max_iter=100, tol=1e-8):
  """
  Méthode du point fixe pour système x = G(x).

  Converge si le rayon spectral de ∂G/∂x < 1
  près de la solution.
  """
  x = np.array(x0, dtype=float)

  for k in range(max_iter):
      x_new = G(x)

      if np.linalg.norm(x_new - x) < tol:
          print(f"Convergence en {k+1} itérations")
          return x_new

      x = x_new

  print(f"Non convergé après {max_iter} itérations")
  return x

Exemple complet : cercle et hyperbole

import numpy as np

# Système : x² + y² = 4 et xy = 1
def F(x):
  return np.array([
      x[0]**2 + x[1]**2 - 4,
      x[0] * x[1] - 1
  ])

def J(x):
  return np.array([
      [2*x[0], 2*x[1]],
      [x[1], x[0]]
  ])

# Trouver les 4 solutions avec différents points de départ
print("=== Recherche des 4 solutions ===\n")

points_depart = [
  [1.5, 0.5],    # Quadrant 1
  [-1.5, -0.5],  # Quadrant 3
  [0.5, 1.5],    # Quadrant 1 (autre solution)
  [-0.5, -1.5]   # Quadrant 3 (autre solution)
]

for x0 in points_depart:
  sol = newton_systeme(F, J, x0)
  print(f"  Point de départ : {x0}")
  print(f"  Solution trouvée : ({sol[0]:.6f}, {sol[1]:.6f})")
  print(f"  Vérification : x² + y² = {sol[0]**2 + sol[1]**2:.6f}, xy = {sol[0]*sol[1]:.6f}")
  print()

Fin du chapitre

Ce chapitre a couvert les méthodes de résolution des systèmes d'équations linéaires et non linéaires. Les concepts clés sont :

1. Méthodes directes : Gauss, LU, pivotage — solution exacte en temps fini
2. Analyse : rang, déterminant, conditionnement — comprendre le système
3. Méthodes itératives : Jacobi, Gauss-Seidel, SOR — grands systèmes creux
4. Systèmes non linéaires : Newton multivariable — convergence quadratique locale

Ces outils sont fondamentaux pour de nombreuses applications en sciences, ingénierie, et informatique.