Diferansiyel Denklemlerde Sayısal Çözümler

Diferansiyel Denklemlerde Sayısal Çözüm Nedir?

Birçok diferansiyel denklemin analitik (kapalı form) çözümü mümkün değildir. Bu durumlarda sayısal yöntemler kullanarak yaklaşık çözümler elde ederiz.

Temel Problem: Başlangıç değer problemi (IVP):
$y' = f(x, y)$, $y(x_0) = y_0$

Amaç: Belirli noktalarda $y(x)$ değerlerini yaklaşık olarak hesaplamak.

Sayısal yöntemler, sürekli problemi diskret (ayrık) problemlere dönüştürür. Çözüm aralığını küçük adımlara böleriz ve her adımda yaklaşık değer hesaplarız.

x_0, x_1, x_2, \ldots, x_n \quad \text{ile} \quad x_{i+1} = x_i + h

Adım Büyüklüğü (h)

h: Ardışık noktalar arası mesafe
Küçük h: Daha doğru sonuçlar, daha fazla hesaplama
Büyük h: Daha hızlı hesaplama, daha az doğruluk
Optimal h seçimi: Hata ve verimlilik dengesi

Hata Türleri:

Kesme Hatası (Truncation Error): Yöntemin matematiksel yaklaşımından kaynaklanan hata
Yuvarlama Hatası (Roundoff Error): Bilgisayar aritmetiğinden kaynaklanan hata
Global Hata: Tüm adımların birikimli hatası
Lokal Hata: Tek bir adımdaki hata

Pratik Kural: Yöntemin mertebesi n ise, adım büyüklüğünü yarıya indirdiğinizde hata yaklaşık 2^n kat azalır. RK4 için: h/2 yapınca hata ~16 kat azalır!

Fark Denklemleri

Fark denklemleri, diferansiyel denklemlerin ayrık versiyonlarıdır. Türevleri fark operatörleri ile değiştiririz.

Fark Operatörleri:

\Delta f_i = f_{i+1} - f_i \quad \text{(İleri fark)}

\nabla f_i = f_i - f_{i-1} \quad \text{(Geri fark)}

\delta f_i = f_{i+1/2} - f_{i-1/2} \quad \text{(Merkezi fark)}

Türev Yaklaşımları:

İleri Fark: $f'(x_i) \approx \frac{f(x_{i+1}) - f(x_i)}{h}$ ··· O(h) hata

Geri Fark: $f'(x_i) \approx \frac{f(x_i) - f(x_{i-1})}{h}$ ··· O(h) hata

Merkezi Fark: $f'(x_i) \approx \frac{f(x_{i+1}) - f(x_{i-1})}{2h}$ ··· O(h²) hata

İkinci türev yaklaşımı:
$f''(x_i) \approx \frac{f(x_{i+1}) - 2f(x_i) + f(x_{i-1})}{h^2}$

Taylor Serisinden Türetme

Taylor açılımı kullanarak fark formüllerini türetebiliriz:
$f(x+h) = f(x) + hf'(x) + \frac{h^2}{2}f''(x) + O(h^3)$
Buradan: $f'(x) = \frac{f(x+h) - f(x)}{h} - \frac{h}{2}f''(x) + O(h^2)$

Merkezi fark neden daha iyi: Simetrik olduğu için tek dereceli terimler iptal olur ve O(h²) hata verir. İleri/geri fark O(h) hata verir.

Tek Adım Metotlar

Tek adım metotlar, bir sonraki noktayı hesaplamak için sadece mevcut noktayı kullanır.

Euler Metodu:

y_{n+1} = y_n + h \cdot f(x_n, y_n)

Algoritma:
Başlangıç: $(x_0, y_0)$
Her adımda: $y_{n+1} = y_n + h \cdot f(x_n, y_n)$
$x_{n+1} = x_n + h$

Lokal hata: O(h²)
Global hata: O(h)

Taylor Serisi Metodu:

Daha yüksek dereceli türevleri kullanarak doğruluğu artırır:

y_{n+1} = y_n + hy'_n + \frac{h^2}{2}y''_n + \frac{h^3}{6}y'''_n + \cdots

İkinci mertebe Taylor:
$y_{n+1} = y_n + hf(x_n, y_n) + \frac{h^2}{2}f'(x_n, y_n)$

Burada: $f' = \frac{\partial f}{\partial x} + \frac{\partial f}{\partial y}f$

Düzeltilmiş Euler Metodu (Heun):

Tahmin-Düzeltme Yaklaşımı:
Önce Euler ile tahmin yap, sonra düzelt.

\tilde{y}_{n+1} = y_n + h \cdot f(x_n, y_n) \quad \text{(tahmin)}

y_{n+1} = y_n + \frac{h}{2}[f(x_n, y_n) + f(x_{n+1}, \tilde{y}_{n+1})] \quad \text{(düzeltme)}

Python Örneği: Euler Metodu

def euler(f, x0, y0, h, n):
    x, y = [x0], [y0]
    for i in range(n):
        y_new = y[-1] + h * f(x[-1], y[-1])
        x.append(x[-1] + h)
        y.append(y_new)
    return x, y

Yakınsaklık:

Yakınsaklık Koşulu: Bir metot yakınsaktır eğer h→0 iken yaklaşık çözüm gerçek çözüme yaklaşıyorsa.

Tutarlılık: Lokal kesme hatası h ile birlikte sıfıra gidiyorsa metot tutarlıdır.

Kararlılık: Küçük başlangıç hataları büyümüyorsa metot kararlıdır.

Lax Denklik Teoremi: Tutarlı bir metot için: Kararlılık ⟺ Yakınsaklık

Runge-Kutta İkinci Mertebe Metotlar

Runge-Kutta (RK) metotları, Taylor serisinin yüksek doğruluğunu türev hesaplamadan sağlar.

RK2 Genel Formu:

$k_1 = hf(x_n, y_n)$

k_2 = hf(x_n + \alpha h, y_n + \beta k_1)

y_{n+1} = y_n + w_1k_1 + w_2k_2

İkinci mertebe için koşullar:
$w_1 + w_2 = 1$
$w_2 \alpha = 1/2$
$w_2 \beta = 1/2$

Popüler RK2 Varyantları:

Düzeltilmiş Euler (α = β = 1)

$k_1 = hf(x_n, y_n)$
$k_2 = hf(x_n + h, y_n + k_1)$
$y_{n+1} = y_n + \frac{1}{2}(k_1 + k_2)$

Orta Nokta Metodu (α = β = 1/2)

$k_1 = hf(x_n, y_n)$
$k_2 = hf(x_n + h/2, y_n + k_1/2)$
$y_{n+1} = y_n + k_2$

Örnek: $y' = -2y + x$, $y(0) = 1$, $h = 0.1$
$k_1 = 0.1 \cdot (-2 \cdot 1 + 0) = -0.2$
$k_2 = 0.1 \cdot (-2(1-0.1) + 0.05) = -0.175$
$y_1 = 1 + \frac{1}{2}(-0.2 - 0.175) = 0.8125$

RK2 Avantajı: Taylor serisindeki ikinci türev hesaplamadan O(h³) lokal hata elde ederiz. Daha verimli ve uygulaması kolay!

RK2 vs Euler karşılaştırması

RK2 aynı adım büyüklüğünde çok daha doğru sonuç verir

Yüksek Mertebe Runge-Kutta Metotları

RK4 - Klasik Dördüncü Mertebe:

En yaygın kullanılan sayısal yöntemlerden biri. Doğruluk ve verimlilik dengesinde mükemmeldir.

$k_1 = hf(x_n, y_n)$

k_2 = hf(x_n + \frac{h}{2}, y_n + \frac{k_1}{2})

k_3 = hf(x_n + \frac{h}{2}, y_n + \frac{k_2}{2})

$k_4 = hf(x_n + h, y_n + k_3)$

y_{n+1} = y_n + \frac{1}{6}(k_1 + 2k_2 + 2k_3 + k_4)

RK4 Özellikleri:
• Lokal hata: O(h⁵)
• Global hata: O(h⁴)
• 4 fonksiyon değerlendirmesi gerekir
• Türev hesabı gerekmez
• Çoğu pratik problem için yeterlidir

Python: RK4 Uygulaması

def rk4(f, x0, y0, h, n):
    x, y = [x0], [y0]
    for i in range(n):
        k1 = h * f(x[-1], y[-1])
        k2 = h * f(x[-1] + h/2, y[-1] + k1/2)
        k3 = h * f(x[-1] + h/2, y[-1] + k2/2)
        k4 = h * f(x[-1] + h, y[-1] + k3)
        y_new = y[-1] + (k1 + 2*k2 + 2*k3 + k4)/6
        x.append(x[-1] + h)
        y.append(y_new)
    return x, y

RK5 ve Daha Yüksek:

RK5 (Butcher): 6 fonksiyon değerlendirmesi, O(h⁶) lokal hata
RK6: 7 fonksiyon değerlendirmesi, O(h⁷) lokal hata
RK8: 11 fonksiyon değerlendirmesi, yüksek hassasiyet

Dikkat: Mertebe arttıkça hesaplama maliyeti artar ama her zaman daha iyi sonuç vermeyebilir. Pratik uygulamalarda RK4 genelde yeterlidir.

Adaptif Adım Boyutu (RKF45):

Runge-Kutta-Fehlberg metodu, hatayı tahmin ederek adım boyutunu otomatik ayarlar.

Fikir: Hem 4. hem 5. mertebe çözüm hesapla, farkı kullanarak hatayı tahmin et:
$\epsilon = |y_5 - y_4|$

Eğer ε > tolerans ise: h'yi küçült
Eğer ε << tolerans ise: h'yi büyült

Modern Yaklaşım: Profesyonel yazılımlar (MATLAB ode45, SciPy solve_ivp) adaptif RK metotları kullanır. Kullanıcı sadece toleransı belirtir, algoritma adım boyutunu optimize eder.

Açık Çok Adım Metotlar

Çok adım metotlar, bir sonraki değeri hesaplamak için birden fazla önceki noktayı kullanır.

Adams-Bashforth Metotları:

Genel Form: $y' = f(x, y)$ denklemini integre ederiz:
$y_{n+1} = y_n + \int_{x_n}^{x_{n+1}} f(x, y(x)) dx$

f'yi geçmiş noktalardan interpolasyon ile tahmin ederiz.

\text{AB2: } y_{n+1} = y_n + \frac{h}{2}(3f_n - f_{n-1})

\text{AB3: } y_{n+1} = y_n + \frac{h}{12}(23f_n - 16f_{n-1} + 5f_{n-1})

\text{AB4: } y_{n+1} = y_n + \frac{h}{24}(55f_n - 59f_{n-1} + 37f_{n-2} - 9f_{n-3})

Başlatma Problemi

Çok adım metotlar için başlangıçta yeterli nokta yoktur. AB4 için y₀, y₁, y₂, y₃ gerekir.

Çözüm: İlk birkaç noktayı RK4 gibi tek adım metotla hesapla, sonra çok adım metoda geç.

Nyström Metotları:

İkinci mertebe diferansiyel denklemler için özelleştirilmiş çok adım metotlar.

$y'' = f(x, y, y')$

Nyström 2-adım:
$y_{n+1} = 2y_n - y_{n-1} + h^2f_n$

Bu, $y'' = f(x)$ için özellikle verimlidir (salınım problemleri).

Açık Metot Dezavantajı: Kararlılık bölgesi RK metotlarından daha küçüktür. Stiff (katı) diferansiyel denklemlerde sorun çıkarabilir.

Avantaj: Fonksiyon değerlendirmesi RK'dan daha az. Her adımda sadece bir kez f hesaplanır (RK4'te 4 kez). Uzun simülasyonlarda verimli!

Kapalı Çok Adım Metotlar

Kapalı metotlar, y_{n+1} hesabında f_{n+1}'i de kullanır. Bu implicit denklem verir.

Adams-Moulton Metotları:

\text{AM2: } y_{n+1} = y_n + \frac{h}{2}(f_{n+1} + f_n)

Bu yamuk kuralıdır ve implicit denklemi çözmek gerekir.

\text{AM3: } y_{n+1} = y_n + \frac{h}{12}(5f_{n+1} + 8f_n - f_{n-1})

\text{AM4: } y_{n+1} = y_n + \frac{h}{24}(9f_{n+1} + 19f_n - 5f_{n-1} + f_{n-2})

Kapalı Metot Özellikleri:
• Daha iyi kararlılık
• Daha büyük kararlılık bölgesi
• Stiff problemler için uygun
• Implicit denklem çözümü gerekir (daha maliyetli)

Milne-Simpson Metotları:

Milne Tahmini (açık):
$y_{n+1}^{(0)} = y_{n-3} + \frac{4h}{3}(2f_n - f_{n-1} + 2f_{n-2})$

Simpson Düzeltmesi (kapalı):
$y_{n+1} = y_{n-1} + \frac{h}{3}(f_{n+1}^{(0)} + 4f_n + f_{n-1})$

Açık vs Kapalı Karşılaştırma

Açık (Adams-Bashforth):
✓ Hızlı hesaplama
✗ Küçük kararlılık bölgesi

Kapalı (Adams-Moulton):
✓ Geniş kararlılık bölgesi
✓ Stiff problemlerde kararlı
✗ Her adımda iterasyon gerekir

En İyi Pratik: Kapalı metotları çözmek için genelde 1-2 iterasyon yeterlidir. Açık metotla iyi bir başlangıç tahmini yaparsanız, hızlıca yakınsama elde edersiniz.

Deneme-Düzeltme (Predictor-Corrector) Metotları

Deneme-düzeltme metotları, açık ve kapalı metotları birleştirir: önce açık metotla tahmin yap, sonra kapalı metotla düzelt.

ABM (Adams-Bashforth-Moulton) Metodu:

Tahmin (Adams-Bashforth-4):
$y_{n+1}^{(0)} = y_n + \frac{h}{24}(55f_n - 59f_{n-1} + 37f_{n-2} - 9f_{n-3})$

Değerlendirme:
$f_{n+1}^{(0)} = f(x_{n+1}, y_{n+1}^{(0)})$

Düzeltme (Adams-Moulton-4):
$y_{n+1} = y_n + \frac{h}{24}(9f_{n+1}^{(0)} + 19f_n - 5f_{n-1} + f_{n-2})$

Algoritma Akışı:
1. İlk 4 değeri RK4 ile hesapla (başlatma)
2. AB4 ile y_{n+1} tahmin et
3. Tahmini kullanarak f_{n+1} hesapla
4. AM4 ile y_{n+1} düzelt
5. Sonraki adıma geç

Hata Tahmini ve Adaptif Adım:

\epsilon = |y_{n+1}^{\text{düzeltme}} - y_{n+1}^{\text{tahmin}}|

Adım Kontrolü

Tahmin ve düzeltme arasındaki fark, lokal hatanın göstergesidir:

ε > tolerans: Adımı küçült veya tekrarla
ε << tolerans: Adımı büyütebilirsin
ε ≈ tolerans: İdeal durum, devam et

Kararlılık Notu: Deneme-düzeltme, tahmin metodunun kararlılığı ile sınırlıdır. Düzeltme daha kararlı olsa da, tahminin kararsızlığı genel kararlılığı etkiler.

Modern Kullanım: ABM metodu, MATLAB'deki ode113 gibi profesyonel çözücülerin temelini oluşturur. Değişken mertebe ve adım boyutu ile çok verimlidir.

Yüksek Mertebe Problemlerin İndirgenmesi

Yüksek mertebeden tek diferansiyel denklemi, birinci mertebeden denklem sistemine dönüştürebiliriz.

İkinci Mertebe Örnek:

$y'' = f(x, y, y')$

Yeni değişkenler tanımla:

y_1 = y, \quad y_2 = y'

Sistem formuna dönüşür:

\begin{cases} y_1' = y_2 \\ y_2' = f(x, y_1, y_2) \end{cases}

Örnek: $y'' + 2y' + y = \sin(x)$
Sistem: $y_1' = y_2$
$y_2' = \sin(x) - 2y_2 - y_1$

n-inci Mertebe Genel Durum:

y^{(n)} = f(x, y, y', \ldots, y^{(n-1)})

Değişken Dönüşümü:
$y_1 = y$
$y_2 = y'$
$y_3 = y''$
$\vdots$
$y_n = y^{(n-1)}$

Sistem: $y_i' = y_{i+1}$ for $i=1,\ldots,n-1$
$y_n' = f(x, y_1, y_2, \ldots, y_n)$

Uygulama: Harmonik Osilatör

Sönümlü harmonik osilatör: $m\ddot{x} + c\dot{x} + kx = 0$

Sistem formunda:
$v = \dot{x}$ (hız)
$\dot{x} = v$
$\dot{v} = -\frac{c}{m}v - \frac{k}{m}x$

Bu sistemi RK4 ile çözebiliriz!

Avantaj: Birinci mertebe sistem için geliştirilen tüm metotları (Euler, RK4, Adams vb.) kullanabiliriz. Yeni metot geliştirmeye gerek yok!

Sistem Çözümü: Tek Adım Metotlar

Diferansiyel denklem sistemleri vektör notasyonu ile ifade edilir:

\mathbf{y}' = \mathbf{f}(x, \mathbf{y})

\mathbf{y} = \begin{pmatrix} y_1 \\ y_2 \\ \vdots \\ y_n \end{pmatrix}, \quad \mathbf{f} = \begin{pmatrix} f_1(x, y_1, \ldots, y_n) \\ f_2(x, y_1, \ldots, y_n) \\ \vdots \\ f_n(x, y_1, \ldots, y_n) \end{pmatrix}

Vektörel Euler Metodu:

\mathbf{y}_{n+1} = \mathbf{y}_n + h \cdot \mathbf{f}(x_n, \mathbf{y}_n)

Vektörel RK4:

$\mathbf{k}_1 = h\mathbf{f}(x_n, \mathbf{y}_n)$
$\mathbf{k}_2 = h\mathbf{f}(x_n + h/2, \mathbf{y}_n + \mathbf{k}_1/2)$
$\mathbf{k}_3 = h\mathbf{f}(x_n + h/2, \mathbf{y}_n + \mathbf{k}_2/2)$
$\mathbf{k}_4 = h\mathbf{f}(x_n + h, \mathbf{y}_n + \mathbf{k}_3)$
$\mathbf{y}_{n+1} = \mathbf{y}_n + \frac{1}{6}(\mathbf{k}_1 + 2\mathbf{k}_2 + 2\mathbf{k}_3 + \mathbf{k}_4)$

Python: Sistem RK4

import numpy as np

def system_rk4(f, x0, y0, h, n):
    x = [x0]
    y = [np.array(y0)]
    for i in range(n):
        k1 = h * f(x[-1], y[-1])
        k2 = h * f(x[-1] + h/2, y[-1] + k1/2)
        k3 = h * f(x[-1] + h/2, y[-1] + k2/2)
        k4 = h * f(x[-1] + h, y[-1] + k3)
        y_new = y[-1] + (k1 + 2*k2 + 2*k3 + k4)/6
        x.append(x[-1] + h)
        y.append(y_new)
    return x, y

Örnek: Lotka-Volterra (av-avcı modeli)
$\frac{dx}{dt} = ax - bxy$ (av popülasyonu)
$\frac{dy}{dt} = -cy + dxy$ (avcı popülasyonu)

Sistem: $\mathbf{y} = (x, y)^T$
$\mathbf{f} = (ax - bxy, -cy + dxy)^T$

Faz uzayı: Lotka-Volterra çözümü

Sistem çözümleri periyodik yörüngeler oluşturur

Sistem Çözümü: Çok Adım Metotlar

Çok adım metotlar da vektörel forma genişletilebilir.

Vektörel Adams-Bashforth:

\mathbf{y}_{n+1} = \mathbf{y}_n + \frac{h}{24}(55\mathbf{f}_n - 59\mathbf{f}_{n-1} + 37\mathbf{f}_{n-2} - 9\mathbf{f}_{n-3})

Vektörel ABM (Deneme-Düzeltme):

Tahmin: Vektörel AB4 kullan
Değerlendirme: $\mathbf{f}_{n+1}^{(0)} = \mathbf{f}(x_{n+1}, \mathbf{y}_{n+1}^{(0)})$
Düzeltme: Vektörel AM4 kullan

Uygulama: N-Cisim Problemi

N gezegenin hareketi 6N boyutlu sistem:
Konum: $(x_1, y_1, z_1, \ldots, x_N, y_N, z_N)$
Hız: $(v_{x1}, v_{y1}, v_{z1}, \ldots, v_{xN}, v_{yN}, v_{zN})$

Newton'un yerçekimi kanunu ile birleşik 6N denklem sistemi. RK4 veya ABM ile çözülebilir.

Hesaplama Maliyeti: n boyutlu sistem için her fonksiyon değerlendirmesi n adet skaler fonksiyon hesabı demektir. Büyük sistemlerde verimlilik kritiktir!

Optimizasyon İpucu: Vektörleştirme (NumPy gibi kütüphaneler) kullanarak hesaplamaları paralelize edin. 100 kat hız artışı mümkün!

Sınır Değer Problemleri: Sonlu Fark Metodu

Sınır değer problemi (BVP): Farklı noktalarda koşullar verilir.

y'' = f(x, y, y'), \quad y(a) = \alpha, \quad y(b) = \beta

İkinci Mertebe Sonlu Fark:

Aralığı [a,b] eşit n parçaya böl: $h = (b-a)/n$

y''_i \approx \frac{y_{i+1} - 2y_i + y_{i-1}}{h^2}

y'_i \approx \frac{y_{i+1} - y_{i-1}}{2h}

Diferansiyel denklemi her noktada diskretize et:

\frac{y_{i+1} - 2y_i + y_{i-1}}{h^2} = f\left(x_i, y_i, \frac{y_{i+1} - y_{i-1}}{2h}\right)

Lineer Problem: $y'' + p(x)y' + q(x)y = r(x)$

Her nokta için:
$\frac{1}{h^2}y_{i-1} + \left(-\frac{2}{h^2} + q_i\right)y_i + \frac{1}{h^2}y_{i+1} + \frac{p_i}{2h}(y_{i+1} - y_{i-1}) = r_i$

Bu (n-1)×(n-1) lineer sistem verir!

Örnek: $y'' + 2y = x^2$, $y(0) = 0$, $y(1) = 1$
h = 0.25 (4 bölüm) için sistem:
$-2y_1 + y_2 = -2 \cdot 0.25^2 + 0$
$y_1 - 2y_2 + y_3 = -2 \cdot 0.5^2$
$y_2 - 2y_3 = -2 \cdot 0.75^2 + 1$
Çöz ve y₁, y₂, y₃ bul!

Matris Formu

Sistem Ay = b formunda yazılır.
A tipik olarak tridiagonal (üç köşegenli) matristir.
Thomas algoritması (O(n)) ile çok verimli çözülür!

Doğruluk Artırma: Daha yüksek mertebe fark formülleri kullanarak (5 noktalı stencil gibi) O(h⁴) veya daha iyi doğruluk elde edebilirsiniz.

Atış (Shooting) Metodu

Atış metodu, BVP'yi bir dizi IVP'ye dönüştürür.

Temel Fikir:

Problem: $y'' = f(x, y, y')$, $y(a) = \alpha$, $y(b) = \beta$

Atış Yaklaşımı:
1. y'(a) = s değerini tahmin et
2. IVP çöz: $y'' = f(x, y, y')$, $y(a) = \alpha$, $y'(a) = s$
3. y(b) değerini kontrol et
4. Eğer y(b) ≠ β ise, s'yi ayarla ve tekrarla

\text{Amaç: } y(b; s) = \beta \text{ olacak } s \text{ bul}

Lineer Problem için Analitik Atış:

Lineer BVP için iki IVP çöz:

IVP 1: $y_1'' = f(x, y_1, y_1')$, $y_1(a) = \alpha$, $y_1'(a) = 0$
IVP 2: $y_2'' = f(x, y_2, y_2')$, $y_2(a) = 0$, $y_2'(a) = 1$

Çözüm: $y(x) = y_1(x) + c \cdot y_2(x)$
c'yi bul: $y(b) = y_1(b) + c \cdot y_2(b) = \beta$
$c = \frac{\beta - y_1(b)}{y_2(b)}$

Nonlineer Problem: Sekant Metodu:

İteratif Atış Algoritması

1. İki başlangıç tahmini: s₀, s₁
2. Her biri için IVP çöz, y(b; sᵢ) hesapla
3. Sekant formülü ile yeni tahmin:
$s_{k+1} = s_k - \frac{(y(b; s_k) - \beta)(s_k - s_{k-1})}{y(b; s_k) - y(b; s_{k-1})}$
4. Yakınsama: |y(b; sₖ) - β| < tolerans

Kararlılık Problemi: Bazı BVP'ler "ill-conditioned"dır. Küçük s değişimi y(b)'de büyük değişime yol açar. Bu durumlarda atış metodu başarısız olabilir.

Ne Zaman Hangisi:
• Atış metodu: Küçük aralık, düzgün problem, IVP çözücüsü varsa
• Sonlu fark: Büyük aralık, stiff problem, kararsız BVP

Atış metodu iterasyonları

Her iterasyon hedefe daha yakın "atış" yapar

Sayısal Çözümlerde Ustalaşmak

Diferansiyel denklemlerin sayısal çözümleri, modern bilim ve mühendisliğin temel araçlarıdır.

Metot Seçim Rehberi

Basit IVP: RK4 (altın standart)
Uzun simülasyon: ABM (verimli)
Stiff problem: Implicit metotlar (BDF, Radau)
Yüksek doğruluk: RK8 veya adaptif RKF45
BVP: Sonlu fark (genel), Atış (küçük aralık)
PDE: Sonlu elemanlar, sonlu hacimler

Profesyonel Araçlar:

• Python: scipy.integrate.solve_ivp (RK45, BDF)
• MATLAB: ode45, ode15s, ode113, bvp4c
• Julia: DifferentialEquations.jl (en hızlı)
• Fortran: LSODE, ODEPACK (klasikler)
• C++: Boost.Numeric.Odeint

Yaygın Hatalar:
✗ Çok büyük adım boyutu (kararsızlık)
✗ Yanlış metot seçimi (stiff için explicit)
✗ Yuvarlama hatası kontrolsüzlüğü
✗ Başlangıç değer hatası
✗ Kararlılık analizini atlama

Başarı Formülü:
• Problemi iyi anlayın (stiff mi, smooth mi?)
• Uygun metodu seçin
• Adaptif adım boyutu kullanın
• Sonuçları doğrulayın (enerji korunumu, fiziksel sınırlar)
• Farklı h değerleri ile test edin (yakınsama kontrolü)

y_approx → y_exact

Sayısal yöntemlerin gücünü öğrendiniz!

İleri Çalışma Konuları

Stiff Diferansiyel Denklemler: Çok farklı zaman ölçeklerinde değişim
Delay Diferansiyel Denklemler: Gecikme içeren sistemler
Diferansiyel-Cebirsel Denklemler (DAE): Kısıtlı sistemler
Kısmi Diferansiyel Denklemler (PDE): Uzay ve zaman
Stokastik Diferansiyel Denklemler: Rastgele süreçler
Optimal Kontrol: Diferansiyel oyunlar ve optimizasyon