Równania różniczkowe

Metoda Eulera (ang. Euler Method) to najprostsza metoda numeryczna służąca do przybliżonego rozwiązywania równań różniczkowych zwyczajnych pierwszego rzędu.

Wynikiem metody Eulera jest zbiór przybliżonych wartości (punktów) poszukiwanej funkcji dla określonych kroków, a nie cała funkcja w postaci wzoru matematycznego. Mówiąc najprościej: metoda Eulera daje nam tabelę z wynikami albo wykres złożony z kropek, które pokazują, jak zachowuje się rozwiązanie równania różniczkowego krok po kroku.

Oto jak to wygląda w szczegółach:

Co dokładnie dostajemy na końcu?

Ciąg punktów: Dostajemy pary liczb \({(x_0, y_0), (x_1, y_1), (x_2, y_2) \dots}\)

Przybliżenie, a nie ideał: Te wartości \(y\) są tylko przybliżeniem prawdziwego, idealnego rozwiązania. Metoda Eulera "idzie po omacku" za pomocą linii prostych, więc z każdym krokiem popełnia mały błąd.

Łamana linia: Jeśli połączymy te punkty na wykresie kreskami, otrzymamy tzw. łamaną Eulera, która mniej więcej naśladuje kształt prawdziwej krzywej.

Prosty przykład (analogia z podróżą samochodem): Wyobraź sobie, że jedziesz samochodem i nie działa Ci prędkościomierz, ale znasz równanie na swoją prędkość w każdej minucie. Chcesz wiedzieć, gdzie będziesz za 5 minut.

Prawdziwe rozwiązanie (analityczne): To dokładna, płynna trasa Twojego samochodu sekunda po sekundzie.

Wynik metody Eulera: To informacja typu: „W minucie 1. byłeś na 1. kilometrze, w minucie 2. na 2.2 kilometra, w minucie 3. na 3.5 kilometra”. Metoda sprawdza prędkość na początku każdej minuty i zakłada, że przez całą minutę jechałeś dokładnie tak samo, po czym przeskakuje do kolejnego punktu.

Podsumowanie matematyczne: Jeśli rozwiązujesz równanie \(y' = f(x, y)\) z warunkiem początkowym \(y(x_0) = y_0\), to wynikiem metody Eulera jest ciąg obliczony ze wzoru: \({y_{n+1}=y_{n}+h\cdot f(x_{n},y_{n})}\) gdzie \(h\) to wielkość skoku (kroku). Wynikiem jest lista kolejnych wartości \({y_1, y_2, y_3 \dots}\), które odpowiadają punktom \({x_1, x_2, x_3 \dots}\).

Dane wejściowe

1. Równanie różniczkowe w postaci: \({y' = f(x, y)}\) (czyli pochodna po jednej stronie, reszta po prawej).
2. Warunek początkowy: punkt startowy \(x_0\) oraz wartość funkcji w tym punkcie \(y_0\), czyli \({y(x_0) = y_0}\).
3. Krok \(h\): długość odcinka, o jaki będziemy się przesuwać na osi X (im mniejszy krok h, tym dokładniejszy wynik).
4. Punkt końcowy: wartość \(x\), dla której chcesz obliczyć przybliżoną wartość \(y\).

Wzór ogólny

Kolejne punkty na osi X obliczamy, dodając krok \(h\):

Wartości igreków \(y\) dla kolejnych kroków obliczamy z kluczowego wzoru metody Eulera:

Przykład

Rozwiążmy konkretne zadanie:

• Równanie: \({y' = x + y}\), czyli nasza funkcja \({f(x,y) = x + y}\)
• Warunek początkowy: \({y(0) = 1}\), czyli \({x₀ = 0, y₀ = 1}\)
• Krok: \(h = 0{,}1\)
• Cel: Chcemy obliczyć przybliżoną wartość \(y\) dla \({x = 0{,}3}\).

Musimy wykonać 3 kroki (od 0 do 0,1, potem do 0,2 i do 0,3).

KROK 1 Wyznaczamy wartości dla \({x_1 = 0{,}1}\):

Mamy punkt startowy: \({x_0 = 0, y_0 = 1}\). Obliczamy nachylenie w tym punkcie: \({f(x_0,y_0) = 0 + 1 = 1}\). Podstawiamy do wzoru:

Nasz nowy punkt to: \({x_1 = 0{,}1, y_1 = 1{,}1}\).

KROK 2 Wyznaczamy wartości dla \({x_2 = 0{,}2}\):

Mamy aktualny punkt: \({x_1 = 0{,}1, y_1 = 1{,}1}\). Obliczamy nachylenie w tym punkcie: \({f(x_1, y_1) = 0{,}1 + 1{,}1 = 1{,}2}\). Podstawiamy do wzoru na \(y_2\):

Nasz nowy punkt to: \({x_2 = 0{,}2, y_2 = 1{,}22}\).

KROK 3 Wyznaczamy wartość końcową dla \({x_3 = 0{,}3}\):

Mamy aktualny punkt: \({x_2 = 0{,}2, y_2 = 1{,}22}\). Obliczamy nachylenie w tym punkcie: \({f(x_2, y_2) = 0{,}2 + 1{,}22 = 1{,}42}\). Podstawiamy do wzoru na \(y_3\):

Wynik

Przybliżona wartość funkcji dla \({x = 0{,}3}\) obliczona metodą Eulera wynosi \(1{,}362\).

Dla porównania: dokładny wynik wyliczony wzorami matematycznymi to około \(1{,}399\), więc przy kroku \(0{,}1\) błąd jest niewielki.

Algorytm metody Eulera

Specyfikacja problemu

Dane wejściowe

Dane wyjściowe

Zmienne pomocnicze+

Lista kroków nr 1

Algorytm metody Eulera można uprościć, jeśli odstęp \(h\) mieści się całkowitą liczbę razy w przedziale \({[x_s,x_k]}\):

Lista kroków nr 2

Zalety metody Eulera

Niezwykła prostota algorytmiczna: Jest to najprostsza metoda numeryczna do zrozumienia i zaimplementowania. Wymaga zaledwie jednej małej pętli i jednej linijki kodu ze wzorem.

Minimalny koszt obliczeniowy na jeden krok: W każdej iteracji komputer musi wyznaczyć wartość funkcji \(f(x,y)\) tylko jeden raz. Dla porównania, popularna metoda RK4 (klasyczna metoda Rungego-Kutty czwartego rzędu; ang. Classical fourth-order Runge-Kutta method) wymaga aż czterokrotnego wyliczania funkcji w każdym kroku.

Doskonała wartość dydaktyczna: Stanowi idealny punkt wyjścia do nauki analizy numerycznej. Pokazuje uczniom intuicyjne przejście od geometrycznej definicji pochodnej (stycznej) do dyskretnych kroków w kodzie.

Szybkość działania przy małych wymaganiach: Jeśli zjawisko jest w miarę liniowe lub błąd nie ma krytycznego znaczenia, metoda ta działa błyskawicznie.

Wady metody Eulera

Bardzo niska dokładność (Metoda I rzędu): Lokalny błąd obcięcia jest proporcjonalny do \(h^2\), a błąd globalny (skumulowany na całym przedziale) do \(h\). Aby zwiększyć dokładność np. 10-krotnie, trzeba zmniejszyć krok \(h\) 10-krotnie, co drastycznie wydłuża czas obliczeń.

Szybka kumulacja błędu: Metoda "idzie po linii prostej" (stycznej). Jeśli prawdziwe rozwiązanie mocno skręca (ma dużą krzywiznę), algorytm szybko "wylatuje z zakrętu" i z każdym krokiem oddala się od rzeczywistego wyniku.

Słaba stabilność numeryczna: Dla wielu równań (tzw. równań sztywnych, ang. stiff equations) metoda Eulera staje się niestabilna. Jeśli krok \(h\) będzie minimalnie za duży, wykres zamiast dążyć do rozwiązania zacznie gwałtownie oscylować i wartości \(y\) uciekną do nieskończoności.

Konieczność stosowania bardzo małych kroków: Aby utrzymać stabilność i sensowną dokładność dla bardziej dynamicznych funkcji, trzeba drastycznie zmniejszać \(h\). To z kolei zwiększa liczbę iteracji i naraża program na kumulację błędów zaokrągleń zmiennoprzecinkowych (ang. floating-point round-off errors).

Metoda Eulera jest najprostszą metodą numeryczną do rozwiązywania równań różniczkowych zwyczajnych (ODE) pierwszego rzędu z zadanym warunkiem początkowym. Działa ona "krok po kroku": znając wartość funkcji w punkcie startowym oraz tempo jej zmian (pochodną), wyznaczamy wartość w kolejnym punkcie, przesuwając się wzdłuż linii stycznej o mały krok \(h\). Poniższe programy rozwiązują równanie różniczkowe \({\frac{dy}{dx} = x + y}\) z warunkiem  początkowym \({y(0) = 1}\) na przedziale od \({x = 0}\) do \({x = 2{,}5}\). Jako odstęp \(h\) wybieramy \(0{,}125\) (taka liczba jest przez komputer pamiętana dokładnie bez błędu zaokrągleń zmiennoprzecinkowych). Wyjaśnienia są w komentarzach.

Dla porównania programy wyświetlają również wartość dokładną funkcji \(y(x)\). Rozwiązaniem analitycznym (dokładnym) równania różniczkowego \({\frac{dy}{dx} = x + y}\) z warunkiem początkowym \({y(0) = 1}\) jest funkcja:

// Równania różniczkowe
// metoda Eulera
// Metody numeryczne 0085
// --------------------------
// (C)2026 mgr Jerzy Wałaszek

#include <windows.h>
#include <iostream>
#include <iomanip>
#include <cmath>

using namespace std;

// Stałe
//------
// Przedział (start,koniec)
const double x_s = 0.000;
const double x_k = 2.500;
// Warunek początkowy
const double y_s = 1.000;
// Odstęp na osi OX
const double h   = 0.125;

// Funkcja prawej strony
// równania różniczkowego
//-----------------------
double f(double x,double y)
{
  return x + y;
}

// Funkcja wynikowa
// obliczona analitycznie
//-----------------------
double rf(double x)
{
  return 2 * exp(x) - x - 1;
}

// Wypisuje wyniki
//----------------
void pisz(int c, double x, double y)
{
  cout << setw(3) << c
  << ": x = " << setw(7) << x
  << "  y = " << setw(8) << y
  << "| dokładnie y = "
  << setw(8) << rf(x)
  << endl;
}

// Program główny
//---------------

int main()
{
  SetConsoleOutputCP(CP_UTF8);
  SetConsoleCP(CP_UTF8);

  cout << setprecision(5)
       << fixed;

  // inicjujemy zmienne
  double x = x_s;
  double y = y_s;
  int    c = 0;

  cout << "Rozwiązywanie równania "
          "różniczkowego metodą "
          "Eulera\n"
          "-----------------------"
          "---------------------"
          "------\n\n";
  pisz(c,x,y);
  // Metoda Eulera
  while(x < x_k)
  {
    c++;
    y = y + h * f(x,y);
    x = x_s + c * h;
    pisz(c,x,y);
  }
  cout << endl;
  system("pause");
  return 0;
}

Rozwiązywanie równania różniczkowego metodą Eulera
--------------------------------------------------

  0: x = 0.00000  y =  1.00000| dokładnie y =  1.00000
  1: x = 0.12500  y =  1.12500| dokładnie y =  1.14130
  2: x = 0.25000  y =  1.28125| dokładnie y =  1.31805
  3: x = 0.37500  y =  1.47266| dokładnie y =  1.53498
  4: x = 0.50000  y =  1.70361| dokładnie y =  1.79744
  5: x = 0.62500  y =  1.97906| dokładnie y =  2.11149
  6: x = 0.75000  y =  2.30457| dokładnie y =  2.48400
  7: x = 0.87500  y =  2.68639| dokładnie y =  2.92275
  8: x = 1.00000  y =  3.13157| dokładnie y =  3.43656
  9: x = 1.12500  y =  3.64802| dokładnie y =  4.03543
 10: x = 1.25000  y =  4.24464| dokładnie y =  4.73069
 11: x = 1.37500  y =  4.93147| dokładnie y =  5.53515
 12: x = 1.50000  y =  5.71978| dokładnie y =  6.46338
 13: x = 1.62500  y =  6.62225| dokładnie y =  7.53184
 14: x = 1.75000  y =  7.65316| dokładnie y =  8.75921
 15: x = 1.87500  y =  8.82856| dokładnie y = 10.16664
 16: x = 2.00000  y = 10.16650| dokładnie y = 11.77811
 17: x = 2.12500  y = 11.68731| dokładnie y = 13.62079
 18: x = 2.25000  y = 13.41385| dokładnie y = 15.72547
 19: x = 2.37500  y = 15.37183| dokładnie y = 18.12703
 20: x = 2.50000  y = 17.59019| dokładnie y = 20.86499

# Równania różniczkowe
# metoda Eulera
# Metody numeryczne 0085
# --------------------------
# (C)2026 mgr Jerzy Wałaszek

from math import exp

# Stałe
#------
# Przedział (start,koniec)
x_s = 0.0
x_k = 2.5
# Warunek początkowy
y_s = 1.0
# Odstęp na osi OX
h   = 0.125

# Funkcja prawej strony
# równania różniczkowego
#-----------------------
def f(x, y):
    return x + y

# Funkcja wynikowa
# obliczona analitycznie
#-----------------------
def rf(x):
    return 2 * exp(x) - x - 1

# Wypisuje wyniki
#----------------
def pisz(c, x, y):
    print(f"{c:3d}: x = {x:7.5f}    "
          f"y = {y:8.5f}| "
          f"dokładnie y = {rf(x):8.5f}")

# Program główny
#---------------

# inicjujemy zmienne
x = x_s
y = y_s
c = 0
print("Rozwiązywanie równania "
      "różniczkowego metodą "
      "Eulera\n"
      "-----------------------"
      "---------------------"
      "------\n")
pisz(c,x,y)

# Metoda Eulera
while x < x_k:
    c += 1
    y = y + h * f(x, y)
    x = x_s + c * h
    pisz(c, x, y)

print()
input("Naciśnij Enter...")