# Solveur numérique par méthode d'Euler (EDO premier ordre)

Résout le problème de Cauchy dy/dx = f(x,y), y(x₀)=y₀ par la méthode d'Euler explicite : y_{n+1} = y_n + h·f(x_n, y_n), avec tableau des itérations et estimation finale. La solution exacte y(x), optionnelle, ajoute une colonne d'erreur qui illustre l'erreur globale en O(h) de la méthode d'ordre 1. Exemple : dy/dx = y, y(0)=1, h=0,1 → y(1) ≈ 1,1¹⁰ = 2,593742 contre e = 2,718282 (erreur 0,124539).

> Page canonique: https://elysiatools.com/fr/tools/euler-method-solver

- **Catégorie:** Math & Numbers

- **Mots-clés:** méthode d'euler, euler explicite, edo numérique, intégration numérique, problème de cauchy, pas, méthode d'ordre 1, approximation, calcul

## Présentation

Ce solveur numérique applique la méthode d'Euler explicite pour approximer pas à pas la solution d'une équation différentielle ordinaire (EDO) du premier ordre de type dy/dx = f(x, y). Il génère un tableau complet des itérations intermédiaires selon la relation de récurrence y_{n+1} = y_n + h·f(x_n, y_n), fournit l'estimation finale au point cible et calcule l'erreur absolue lorsqu'une solution analytique exacte est renseignée.

## Entrées

- **f(x, y) dans dy/dx = f(x, y)** (text): Right-hand side in terms of x and y (functions: sin, cos, exp, ln, sqrt, …). Write products with *, e.g. x*y.
- **x₀ (x initial)** (number): e.g. 0
- **y₀ = y(x₀)** (number): e.g. 1
- **x cible** (number): Must be greater than x₀.
- **Nombre de pas n** (number): h = (target x − x₀)/n. More steps → smaller error, O(h) globally.
- **Solution exacte y(x) (facultatif)** (text): Exact solution in x, used to add an error column. Leave empty to skip.
- **Décimales** (number)

## Quand l'utiliser

- Pour approximer numériquement la solution d'un problème de Cauchy dy/dx = f(x, y) lorsque la solution analytique est difficile ou impossible à obtenir.
- Pour vérifier manuellement les calculs d'un exercice d'analyse numérique ou d'intégration d'équations différentielles ordinaires.
- Pour analyser l'impact du pas d'intégration h sur la précision et observer concrètement l'erreur globale en O(h) propre aux schémas d'ordre 1.

## Fonctionnement

- Saisissez la fonction f(x, y) représentant dy/dx ainsi que les conditions initiales x₀ et y₀ = y(x₀).
- Définissez le point cible x, le nombre de pas n (qui fixe le pas h = (x_cible - x₀)/n) et, si souhaité, la formule de la solution exacte y(x).
- Le solveur calcule récursivement y_{n+1} = y_n + h·f(x_n, y_n) à chaque étape et affiche le tableau des valeurs successives avec l'estimation finale.

## Cas d'usage

- Simulation numérique de modèles de croissance démographique ou de refroidissement thermique du premier ordre.
- Support pédagogique pour les cours d'introduction à l'analyse numérique et aux méthodes d'intégration pas à pas.
- Vérification rapide de solutions approchées pour des équations différentielles en physique appliquée et en ingénierie.

## Questions fréquentes

### Comment la taille du pas h est-elle déterminée ?

La taille du pas est calculée automatiquement par la formule h = (x_cible - x₀) / n, où n correspond au nombre de pas défini.

### Quelles fonctions sont reconnues dans l'expression f(x, y) ?

Vous pouvez employer les fonctions usuelles comme sin, cos, exp, ln, sqrt ainsi que les puissances et les opérateurs de base en utilisant * pour les multiplications.

### Pourquoi l'erreur globale est-elle en O(h) ?

La méthode d'Euler explicite est une méthode d'ordre 1 : l'erreur locale de troncature à chaque pas est en O(h²), ce qui conduit à une erreur globale accumulée proportionnelle à h.

### Le renseignement de la solution exacte est-il obligatoire ?

Non, ce champ est facultatif. Il sert uniquement à afficher une colonne d'erreur absolue pour comparer la solution approchée à la valeur exacte.

### La valeur cible de x peut-elle être inférieure à x₀ ?

Non, l'outil nécessite une valeur cible strictement supérieure à x₀ pour effectuer l'intégration numérique vers l'avant.

## Outils associés

- [Calculateur d'intégrale de convolution (numérique)](https://elysiatools.com/fr/tools/convolution-integral-calculator): Calcule numériquement la convolution de deux signaux (f*g)(t) = ∫ f(τ)g(t−τ)dτ : mode causal (les deux signaux sont nuls pour t<0, intégrale sur \[max(τmin,0), min(τmax,t)\], adapté aux produits du domaine de Laplace) et mode fenêtre directe (intégrale sur tout \[τmin, τmax\], adapté aux signaux bilatéraux comme les gaussiennes), par la règle de Simpson composée (2000 intervalles par défaut). Classiques : e^(−t)*e^(−2t) = e^(−t)−e^(−2t), soit 0.2325 en t=1 ; deux gaussiennes se convoluent en √(π/2)·e^(−t²/2).
- [Calculateur de dérivation numérique (différences avant/arrière/centrée)](https://elysiatools.com/fr/tools/numerical-differentiation): Approche f′(x₀) par trois différences finies : avant (f(x₀+h)−f(x₀))/h, arrière (f(x₀)−f(x₀−h))/h et centrée (f(x₀+h)−f(x₀−h))/(2h), plus la dérivée seconde centrée. La dérivée exacte, optionnelle, ajoute l'erreur absolue de chaque méthode et illustre le contraste O(h) contre O(h²). Exemple : f=x², x₀=1, h=0,1 → avant 2,1 ; arrière 1,9 ; centrée exactement 2,0.
- [Solveur d'EDO du premier ordre (séparation des variables)](https://elysiatools.com/fr/tools/first-order-ode-solver): Résout dy/dx = g(x)·h(y) par séparation des variables : séparation, intégration terme à terme pour obtenir H(y) = G(x) + C puis, quand c'est possible, y = f(x). Accepte les h(y) à un terme (y, y^n, e^(ky), ky+m) et les polynômes du second degré décomposables en fractions simples (comme le logistique y(1−y)) ; avec la condition initiale y(x₀)=y₀, calcule C et détecte les solutions d'équilibre. Exemple : dy/dx = 2x·y → y = e^(x²+C).
- [Constructeur de Simulation Monte Carlo](https://elysiatools.com/fr/tools/monte-carlo-simulation-builder): Définissez des distributions d'entrée (normale/uniforme/lognormale/triangulaire), écrivez une formule, lancez des milliers d'essais et obtenez l'histogramme avec intervalles de confiance.
- [Calculateur de racines par Newton-Raphson](https://elysiatools.com/fr/tools/newton-raphson-root-finder): Résout f(x) = 0 par l'itération de Newton-Raphson x_{k+1} = x_k − f(x_k)/f'(x_k) : la dérivée peut être fournie analytiquement (sinon une différence centrale numérique est utilisée) ; sont affichés la table des itérations (x_k et f(x_k)), le critère d'arrêt (|f| < tolérance ou |Δx| < tolérance·max(1,|x|)), le nombre d'itérations et le |f(racine)| final. Classiques : x²−2 depuis x₀=1 converge en 4 itérations vers √2 ≈ 1.4142135624 ; cos(x)−x converge vers le nombre de Dottie 0.7390851332. Dérivée nulle, pas divergents ou dépassement du nombre d'itérations sont signalés explicitement.
- [Intégrateur par règle de Simpson (∫f(x)dx)](https://elysiatools.com/fr/tools/numerical-integration-simpson): Calcule ∫ₐᵇ f(x)dx par la règle de Simpson 1/3 composée (n pair) : S = h/3·(f(a) + 4Σnœuds impairs + 2Σnœuds pairs intérieurs + f(b)), erreur en O(h⁴), exacte pour les polynômes de degré ≤ 3. Tableau des nœuds, estimation et comparaison facultative avec la valeur exacte. Exemples : ∫₀¹x²dx avec n=4 donne 0,333333 (exacte !) ; ∫₀¹e^(−x²)dx (sans primitive élémentaire) avec n=10 donne 0,746825.
- [Intégrateur par règle du trapèze (∫f(x)dx)](https://elysiatools.com/fr/tools/numerical-integration-trapezoid): Calcule ∫ₐᵇ f(x)dx par la règle du trapèze composée : T = h/2·(f(a) + 2Σf(xᵢ) + f(b)), avec tableau des nœuds, estimation de l'intégrale et comparaison facultative avec la valeur exacte et l'erreur absolue ; erreur en O(h²) (exacte pour les fonctions linéaires). Exemple : ∫₀¹x²dx avec n=4 donne 0,34375 contre 1/3 exactement, erreur 0,010417.
- [Solveur numérique Runge-Kutta d'ordre 4 (RK4)](https://elysiatools.com/fr/tools/runge-kutta-rk4-solver): Résout dy/dx = f(x,y), y(x₀)=y₀ par le Runge-Kutta classique d'ordre 4 : chaque pas calcule les quatre pentes k1–k4 et met à jour y_{n+1} = y_n + h/6·(k1+2k2+2k3+k4), avec une erreur globale en O(h⁴) — diviser h par 2 réduit l'erreur d'un facteur ~16. Fournit le tableau des itérations, le détail des k1–k4 des premiers pas et l'estimation finale ; la solution exacte y(x), optionnelle, ajoute une colonne d'erreur. Exemple : dy/dx = y, y(0)=1, h=0,1 → y(1) ≈ 2,718282, quasiment e.

## Exemples

- [Exemples de Traitement d'Images Android Java](https://elysiatools.com/fr/samples/android-image-processing-java): Exemples de traitement d'images Android Java incluant lecture/écriture, mise à l'échelle et conversion de format
- [Exemples de Traitement d'Images Android Kotlin](https://elysiatools.com/fr/samples/android-image-processing-kotlin): Exemples de traitement d'images Android Kotlin incluant lecture/écriture, mise à l'échelle et conversion de format
- [Exemples de Traitement d'Images Web Python](https://elysiatools.com/fr/samples/web-image-processing-python): Exemples de traitement d'images Web Python utilisant PIL/Pillow incluant la lecture, l'enregistrement, le redimensionnement et la conversion de format
- [Exemples de Traitement d'Images Web Rust](https://elysiatools.com/fr/samples/web-image-processing-rust): Exemples de traitement d'images Web Rust incluant lecture/écriture, redimensionnement et conversion de format