# Numerischer Löser mit Euler-Verfahren (DGL 1. Ordnung)

Löst das Anfangswertproblem dy/dx = f(x,y), y(x₀)=y₀ mit dem expliziten Euler-Verfahren: y_{n+1} = y_n + h·f(x_n, y_n), mit Schrittabelle und Endschätzung. Die optionale exakte Lösung y(x) ergibt eine Fehlerspalte, die den globalen Fehler O(h) der Methode 1. Ordnung zeigt. Beispiel: dy/dx = y, y(0)=1, h=0,1 → y(1) ≈ 1,1¹⁰ = 2,593742 gegenüber e = 2,718282 (Fehler 0,124539).

> Kanonische Seite: https://elysiatools.com/de/tools/euler-method-solver

- **Kategorie:** Math & Numbers

- **Schlagwörter:** euler-verfahren, expliziter euler, numerische dgl, numerische integration, anfangswertproblem, schrittweite, verfahren 1. ordnung, näherung, analysis

## Überblick

Dieser Online-Rechner löst Anfangswertprobleme gewöhnlicher Differentialgleichungen erster Ordnung (dy/dx = f(x,y)) mit dem expliziten Euler-Verfahren. Das Werkzeug berechnet schrittweise die Iterationswerte, stellt Zwischenschritte übersichtlich tabellarisch dar und vergleicht das Ergebnis bei Bedarf mit der exakten analytischen Lösung.

## Eingaben

- **f(x, y) in 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₀ (Anfangs-x)** (number): e.g. 0
- **y₀ = y(x₀)** (number): e.g. 1
- **Ziel-x** (number): Must be greater than x₀.
- **Schrittanzahl n** (number): h = (target x − x₀)/n. More steps → smaller error, O(h) globally.
- **Exakte Lösung y(x) (optional)** (text): Exact solution in x, used to add an error column. Leave empty to skip.
- **Dezimalstellen** (number)

## Wann verwenden

- Zur schrittweisen numerischen Näherung von Anfangswertproblemen 1. Ordnung ohne geschlossene Stammfunktion.
- Zur Verifikation von Rechenschritten und Hausübungen in Vorlesungen der numerischen Mathematik.
- Zur Veranschaulichung des Diskretisierungsfehlers und der Konvergenzordnung O(h) bei veränderlicher Schrittweite.

## Funktionsweise

- Geben Sie die rechte Seite f(x, y) der Differentialgleichung sowie den Startpunkt x₀ und den Anfangswert y₀ ein.
- Legen Sie den Zielwert Ziel-x und die Schrittanzahl n fest, woraus das Tool die Schrittweite h = (Ziel-x − x₀) / n ermittelt.
- Der Algorithmus iteriert mit der Formel y_{n+1} = y_n + h · f(x_n, y_n) bis zum Ziel-x und gibt Zwischenwerte sowie Steigungen tabellarisch aus.
- Optional berechnet die Angabe der exakten Lösung y(x) in jedem Schritt den absoluten Fehler gegenüber dem Näherungswert.

## Anwendungsfälle

- Lösung linearer und nichtlinearer Anfangswertprobleme im Ingenieur- und Mathematikstudium.
- Demonstration von Diskretisierungsfehlern bei unterschiedlichen Schrittweiten in der Lehre.
- Numerische Annäherung von Ratengleichungen und Abkühlungsprozessen in der Physik.

## Häufig gestellte Fragen

### Welche mathematischen Funktionen werden in f(x, y) unterstützt?

Unterstützt werden Standardfunktionen wie sin, cos, exp, ln, sqrt sowie Grundrechenarten. Produkte müssen mit dem Multiplikationszeichen (*) eingegeben werden.

### Wie berechnet sich die Schrittweite h?

Die Schrittweite h wird automatisch über die Formel h = (Ziel-x − x₀) / n aus dem Intervall und der Schrittanzahl berechnet.

### Welche Ordnung besitzt das explizite Euler-Verfahren?

Es ist ein numerisches Einschrittverfahren 1. Ordnung mit einem globalen Diskretisierungsfehler von O(h).

### Wozu dient die optionale exakte Lösung?

Sie ergänzt die Ausgabetabelle um eine Fehlerspalte, die den absoluten Abstand zwischen numerischer Näherung und exaktem Wert anzeigt.

### Warum muss das Ziel-x größer als x₀ sein?

Das Verfahren führt eine Vorwärtsintegration durch, wodurch der Zielwert strikt größer als der Startwert sein muss.

## Ähnliche Tools

- [Faltungsintegral-Rechner (numerisch)](https://elysiatools.com/de/tools/convolution-integral-calculator): Berechnet numerisch die Faltung zweier Signale (f*g)(t) = ∫ f(τ)g(t−τ)dτ: Kausalmodus (beide Signale null für t<0, Integral über \[max(τmin,0), min(τmax,t)\] — passend zu Laplace-Bereichsprodukten) und direkter Fenstermodus (Integral über das gesamte \[τmin, τmax\] — passend zu beidseitigen Signalen wie Gaußkurven), mittels zusammengesetzter Simpson-Regel (standardmäßig 2000 Intervalle). Klassiker: e^(−t)*e^(−2t) = e^(−t)−e^(−2t), bei t=1 gleich 0.2325; zwei Gaußkurven falten sich zu √(π/2)·e^(−t²/2).
- [Numerische-Differenziation-Rechner (Vorwärts-/Rückwärts-/zentrale Differenzen)](https://elysiatools.com/de/tools/numerical-differentiation): Nähert f′(x₀) durch drei endliche Differenzen: vorwärts (f(x₀+h)−f(x₀))/h, rückwärts (f(x₀)−f(x₀−h))/h und zentral (f(x₀+h)−f(x₀−h))/(2h), dazu die zentrale zweite Ableitung. Die optionale exakte Ableitung liefert den absoluten Fehler jeder Methode und zeigt den Kontrast O(h) vs. O(h²). Beispiel: f=x², x₀=1, h=0,1 → vorwärts 2,1; rückwärts 1,9; zentral exakt 2,0.
- [Löser für DGL 1. Ordnung (Variablentrennung)](https://elysiatools.com/de/tools/first-order-ode-solver): Löst dy/dx = g(x)·h(y) durch Variablentrennung: trennen, gliedweise integrieren zu H(y) = G(x) + C und, wenn möglich, nach y auflösen. Unterstützt eintermige h(y) (y, y^n, e^(ky), ky+m) und per Partialbruchzerlegung behandelbare quadratische Polynome (etwa die logistische Gleichung y(1−y)); mit Anfangsbedingung y(x₀)=y₀ wird C berechnet und Gleichgewichtslösungen erkannt. Beispiel: dy/dx = 2x·y → y = e^(x²+C).
- [Monte-Carlo-Simulations-Builder](https://elysiatools.com/de/tools/monte-carlo-simulation-builder): Definieren Sie Eingangsverteilungen (normal/uniform/lognormal/triangular), schreiben Sie eine Formel, führen Sie Tausende Durchläufe aus und erhalten Sie das Histogramm mit Konfidenzintervallen.
- [Newton-Raphson-Nullstellenrechner](https://elysiatools.com/de/tools/newton-raphson-root-finder): Löst f(x) = 0 mit der Newton-Raphson-Iteration x_{k+1} = x_k − f(x_k)/f'(x_k): Die Ableitung kann analytisch angegeben werden (bleibt das Feld leer, wird eine numerische zentrale Differenz verwendet); ausgegeben werden die Iterationstabelle (x_k und f(x_k)), das Abbruchkriterium (|f| < Toleranz oder |Δx| < Toleranz·max(1,|x|)), die Iterationszahl und das endgültige |f(Wurzel)|. Klassiker: x²−2 konvergiert von x₀=1 in 4 Schritten gegen √2 ≈ 1.4142135624; cos(x)−x konvergiert gegen die Dottie-Zahl 0.7390851332. Nullableitung, divergierende Schritte oder das Überschreiten des Iterationslimits werden explizit gemeldet.
- [Simpson-Regel-Integrator (∫f(x)dx)](https://elysiatools.com/de/tools/numerical-integration-simpson): Berechnet ∫ₐᵇ f(x)dx mit der zusammengesetzten Simpson-1/3-Regel (n gerade): S = h/3·(f(a) + 4Σungerade Knoten + 2Σgerade innere Knoten + f(b)), Fehler O(h⁴), exakt für Polynome vom Grad ≤ 3. Knotentabelle, Schätzung und optionaler Vergleich mit dem exakten Wert. Beispiele: ∫₀¹x²dx mit n=4 ergibt 0,333333 (exakt!); ∫₀¹e^(−x²)dx (ohne elementare Stammfunktion) mit n=10 ergibt 0,746825.
- [Trapezregel-Integrator (∫f(x)dx)](https://elysiatools.com/de/tools/numerical-integration-trapezoid): Berechnet ∫ₐᵇ f(x)dx mit der zusammengesetzten Trapezregel: T = h/2·(f(a) + 2Σf(xᵢ) + f(b)), mit Knotentabelle, Integral-Schätzung und optionalem Vergleich mit exaktem Wert und absolutem Fehler; Fehler O(h²) (exakt für lineare Funktionen). Beispiel: ∫₀¹x²dx mit n=4 ergibt 0,34375 gegenüber exakt 1/3, Fehler 0,010417.
- [Numerischer Löser Runge-Kutta 4. Ordnung (RK4)](https://elysiatools.com/de/tools/runge-kutta-rk4-solver): Löst dy/dx = f(x,y), y(x₀)=y₀ mit dem klassischen Runge-Kutta-Verfahren 4. Ordnung: pro Schritt werden vier Steigungen k1–k4 berechnet und y_{n+1} = y_n + h/6·(k1+2k2+2k3+k4) aktualisiert; globaler Fehler O(h⁴) — halbiertes h teilt den Fehler ungefähr durch 16. Liefert die Schrittabelle, die k1–k4-Werte der ersten Schritte und die Endschätzung; die optionale exakte Lösung y(x) ergibt eine Fehlerspalte. Beispiel: dy/dx = y, y(0)=1, h=0,1 → y(1) ≈ 2,718282, fast exakt e.

## Beispiele

- [Android Java Bildverarbeitungsbeispiele](https://elysiatools.com/de/samples/android-image-processing-java): Android Java Bildverarbeitungsbeispiele einschließlich Lesen/Schreiben, Skalierung und Formatkonvertierung
- [Android Kotlin Bildverarbeitungsbeispiele](https://elysiatools.com/de/samples/android-image-processing-kotlin): Android Kotlin Bildverarbeitungsbeispiele einschließlich Lesen/Schreiben, Skalierung und Formatkonvertierung
- [Web Python Bildverarbeitung Beispiele](https://elysiatools.com/de/samples/web-image-processing-python): Web Python Bildverarbeitungsbeispiele mit PIL/Pillow einschließlich Lesen, Speichern, Skalieren und Formatkonvertierung
- [Web Rust Bildverarbeitungsbeispiele](https://elysiatools.com/de/samples/web-image-processing-rust): Web Rust Bildverarbeitungsbeispiele einschließlich Lesen/Schreiben, Skalierung und Formatkonvertierung