Fourier Analizi

Sinyallerin frekans domenine dönüşümü: Seriler, dönüşümler ve uygulamalar

f(x) = a₀/2 + Σ(aₙcos(nx) + bₙsin(nx))
# Periyodik fonksiyonların harmonik analizi

Fourier Analizine Giriş

Fourier Analizi, periyodik ve periyodik olmayan fonksiyonları sinüs ve kosinüs gibi basit trigonometrik fonksiyonların toplamı olarak ifade etme yöntemidir. Joseph Fourier'in 1807'deki ısı denklemine çözüm arayışından doğmuştur.

Neden Önemlidir?
Fourier analizi, sinyal işleme, görüntü sıkıştırma, kuantum mekaniği, diferensiyel denklemler ve iletişim sistemlerinde temel rol oynar. MP3, JPEG ve radar sistemlerinin matematiksel temelidir.
Temel Fikir:

Her periyodik fonksiyon, farklı frekanslardaki sinüs ve kosinüs dalgalarının süperpozisyonu olarak yazılabilir. Bu, karmaşık sinyalleri basit bileşenlere ayırma gücü verir.

1. İç Çarpım Uzayları ve Özellikleri

Fourier analizinin matematiksel temeli iç çarpım uzaylarıdır. Bu uzaylar, vektörler arasında "açı" ve "uzunluk" kavramlarını genelleştirir.

İç Çarpım Tanımı

İç Çarpım: V vektör uzayı üzerinde tanımlı ⟨·,·⟩: V × V → ℂ fonksiyonu şu özellikleri sağlar:
  • Doğrusallık: ⟨αf + βg, h⟩ = α⟨f,h⟩ + β⟨g,h⟩
  • Konjuge Simetri: ⟨f,g⟩ = ⟨g,f⟩*
  • Pozitif Tanımlılık: ⟨f,f⟩ ≥ 0, eşitlik ancak f=0 için

L² Uzayı

L²[a,b] Uzayı
L²[a,b], kareleri integrallenebilir fonksiyonların uzayıdır:
⟨f,g⟩ = ∫ₐᵇ f(x)g̅(x)dx

Bu iç çarpım, Fourier serileri için doğal ortamı sağlar. Norm: ||f|| = √⟨f,f⟩ 
# Python ile iç çarpım hesaplama
import numpy as np
from scipy.integrate import quad

def inner_product(f, g, a, b):
    """L²[a,b] iç çarpımı"""
    def integrand(x):
        return f(x) * np.conj(g(x))
    
    result, error = quad(integrand, a, b)
    return result

def norm(f, a, b):
    """L² normu"""
    return np.sqrt(inner_product(f, f, a, b).real)

# Örnek: f(x) = sin(x), g(x) = cos(x) [0, 2π]
f = lambda x: np.sin(x)
g = lambda x: np.cos(x)

print(f"⟨sin, cos⟩ = {inner_product(f, g, 0, 2*np.pi):.6f}")
print(f"||sin|| = {norm(f, 0, 2*np.pi):.6f}")

2. Ortogonal ve Ortonormal Sistemler

Ortogonal sistemler, Fourier analizinin temel yapı taşlarıdır. İki fonksiyon ortogonaldir eğer iç çarpımları sıfır ise.

Ortogonallik: ⟨fₙ, fₘ⟩ = 0 (n ≠ m)
Ortonormallik: ⟨fₙ, fₘ⟩ = δₙₘ (Kronecker delta)

Trigonometrik fonksiyonlar {sin(nx), cos(nx)} ortogonal bir sistem oluşturur.

Trigonometrik Ortogonallik

Temel Ortogonallik İlişkileri

∫₋π^π sin(nx)sin(mx)dx = πδₙₘ
∫₋π^π cos(nx)cos(mx)dx = πδₙₘ
∫₋π^π sin(nx)cos(mx)dx = 0 

# Ortogonallik doğrulama
def verify_orthogonality(n, m):
    """sin(nx) ve sin(mx) ortogonalliğini kontrol et"""
    f = lambda x: np.sin(n * x)
    g = lambda x: np.sin(m * x)
    
    result = inner_product(f, g, -np.pi, np.pi)
    expected = np.pi if n == m else 0
    
    print(f"⟨sin({n}x), sin({m}x)⟩ = {result:.6f}")
    print(f"Beklenen: {expected:.6f}")

# Test
verify_orthogonality(2, 3)  # Farklı n,m → 0
verify_orthogonality(5, 5)  # Aynı n,m → π

Tam Ortogonal Sistemler

Bir ortogonal sistem tamdır eğer hiçbir sıfır olmayan fonksiyon tüm sistem elemanlarına ortogonal değilse. Trigonometrik sistem L²[-π,π]'de tamdır (Weierstrass teoremi).

3. Fourier Serileri ve Özellikleri

2π-periyodik bir f fonksiyonu için Fourier serisi:

Fourier Serisi Açılımı

f(x) = a₀/2 + Σ[aₙcos(nx) + bₙsin(nx)]

Fourier Katsayıları:
a₀ = (1/π)∫₋π^π f(x)dx
aₙ = (1/π)∫₋π^π f(x)cos(nx)dx
bₙ = (1/π)∫₋π^π f(x)sin(nx)dx

Katsayıların Anlamı
a₀/2: Fonksiyonun ortalama değeri
aₙ: n. harmonik kosinüs bileşeninin genliği
bₙ: n. harmonik sinüs bileşeninin genliği
Her terim farklı bir frekans bileşenini temsil eder! 
# Fourier katsayıları hesaplama
class FourierSeries:
    def __init__(self, f, period=2*np.pi):
        self.f = f
        self.period = period
        self.L = period / 2
    
    def coefficient_a0(self):
        """a₀ katsayısı"""
        result, _ = quad(self.f, -self.L, self.L)
        return result / self.L
    
    def coefficient_an(self, n):
        """aₙ katsayısı"""
        integrand = lambda x: self.f(x) * np.cos(n * np.pi * x / self.L)
        result, _ = quad(integrand, -self.L, self.L)
        return result / self.L
    
    def coefficient_bn(self, n):
        """bₙ katsayısı"""
        integrand = lambda x: self.f(x) * np.sin(n * np.pi * x / self.L)
        result, _ = quad(integrand, -self.L, self.L)
        return result / self.L
    
    def reconstruct(self, x, N):
        """İlk N terimle yeniden oluşturma"""
        result = self.coefficient_a0() / 2
        
        for n in range(1, N+1):
            an = self.coefficient_an(n)
            bn = self.coefficient_bn(n)
            result += an * np.cos(n*np.pi*x/self.L) + bn * np.sin(n*np.pi*x/self.L)
        
        return result

# Örnek: Kare dalga
def square_wave(x):
    return 1 if 0 <= x % (2*np.pi) < np.pi else -1

fs = FourierSeries(square_wave)
print(f"a₀ = {fs.coefficient_a0():.6f}")
print(f"a₁ = {fs.coefficient_an(1):.6f}")
print(f"b₁ = {fs.coefficient_bn(1):.6f}")

4. Karmaşık Fourier Serileri

Euler formülü (e^(ix) = cos(x) + i·sin(x)) kullanılarak daha kompakt gösterim:

Karmaşık Form

f(x) = Σ cₙe^(inx)

Karmaşık Katsayılar:
cₙ = (1/2π)∫₋π^π f(x)e^(-inx)dx

İlişki: cₙ = (aₙ - ibₙ)/2, c₋ₙ = (aₙ + ibₙ)/2

Avantajları
• Daha simetrik ve elegant gösterim
• Negatif frekansları doğal şekilde içerir
• Fourier dönüşümüne daha kolay geçiş
• Konvolüsyon işlemleri basitleşir 
# Karmaşık Fourier katsayıları
def complex_fourier_coefficient(f, n, L=np.pi):
    """cₙ karmaşık katsayısı"""
    integrand = lambda x: f(x) * np.exp(-1j * n * np.pi * x / L)
    result, _ = quad(integrand, -L, L, complex_func=True)
    return result / (2 * L)

def complex_fourier_series(f, x, N, L=np.pi):
    """Karmaşık Fourier serisi yaklaşımı"""
    result = 0
    for n in range(-N, N+1):
        cn = complex_fourier_coefficient(f, n, L)
        result += cn * np.exp(1j * n * np.pi * x / L)
    return result.real

# Örnek kullanım
f = lambda x: np.abs(x)
x_vals = np.linspace(-np.pi, np.pi, 1000)
y_approx = [complex_fourier_series(f, x, 20) for x in x_vals]

5. Noktasal Yakınsaklık ve Dirichlet Teoremi

Fourier serisinin ne zaman ve nasıl yakınsadığını belirleyen temel teoremdir.

Dirichlet Teoremi: f(x) [-π,π]'de parçalı sürekli ve parçalı monoton ise, Fourier serisi her x noktasında
[f(x⁺) + f(x⁻)] / 2
değerine yakınsar. Burada f(x⁺) ve f(x⁻) sağ ve sol limitlerdir.
Sonuçlar
• Süreksizliklerde seri ortalamapostropheto yakınsar
• Sürekli noktalarda f(x)'e yakınsar
• Düzgün yakınsamaz ama L² anlamında yakınsar
• Gibbs fenomeni süreksizliklerde görülür

Uygulamalar 

# Kare dalga Fourier serisi analizi
def square_wave_fourier(x, N):
    """Kare dalganın Fourier yaklaşımı"""
    result = 0
    for n in range(1, N+1, 2):  # Sadece tek harmonikler
        result += (4/(n*np.pi)) * np.sin(n * x)
    return result

# Farklı N değerleri için yakınsama
x = np.linspace(-np.pi, np.pi, 1000)
for N in [5, 15, 50]:
    y = square_wave_fourier(x, N)
    print(f"N={N}: Maksimum hata = {np.max(np.abs(y - np.sign(np.sin(x)))):.6f}")

6. Parseval Özdeşliği ve Gibbs Fenomeni

Parseval Özdeşliği

Enerji korunumunun Fourier domenindeki karşılığıdır:

Parseval Formülü

(1/π)∫₋π^π |f(x)|²dx = a₀²/2 + Σ(aₙ² + bₙ²)

Fonksiyonun toplam enerjisi, harmoniklerinin enerjilerinin toplamına eşittir!

Gibbs Fenomeni

Gibbs Fenomeni: Süreksiz fonksiyonların Fourier serileri, süreksizlik noktalarında yaklaşık %9 oranında aşma (overshoot) gösterir. Bu aşma, terim sayısı arttıkça kaybolmaz, sadece daralır! 
# Parseval özdeşliğini doğrulama
def verify_parseval(f, N, L=np.pi):
    """Parseval özdeşliğini kontrol et"""
    # Sol taraf: fonksiyonun karesinin integrali
    f_squared = lambda x: abs(f(x))**2
    left_side, _ = quad(f_squared, -L, L)
    left_side /= L
    
    # Sağ taraf: katsayıların kareleri toplamı
    fs = FourierSeries(f, 2*L)
    a0 = fs.coefficient_a0()
    right_side = a0**2 / 2
    
    for n in range(1, N+1):
        an = fs.coefficient_an(n)
        bn = fs.coefficient_bn(n)
        right_side += an**2 + bn**2
    
    print(f"Sol taraf (integral): {left_side:.6f}")
    print(f"Sağ taraf (katsayılar): {right_side:.6f}")
    print(f"Fark: {abs(left_side - right_side):.6f}")

# Gibbs fenomeni gözlemleme
def gibbs_phenomenon():
    x = np.linspace(-np.pi, np.pi, 1000)
    
    for N in [10, 50, 100]:
        y = square_wave_fourier(x, N)
        overshoot = np.max(y) - 1
        print(f"N={N}: Aşma = {overshoot:.4f} ({overshoot*100:.2f}%)")

7. Fourier Serilerinin Diferensiyeli ve İntegrali

Fourier serileri terim terim türevlenebilir ve integrallenebilir (belirli koşullar altında).

Türev Alma

Teorem: f sürekli, periyodik ve türevi parçalı sürekli ise:
f'(x) ~ Σ[n·(-aₙsin(nx) + bₙcos(nx))]

Yani türev, terim terim alınabilir ve katsayılar n ile çarpılır.

İntegral Alma

İntegral Özellikleri
Fourier serisi her zaman terim terim integrallenebilir:
∫f(x)dx ~ a₀x/2 + Σ[(aₙsin(nx) - bₙcos(nx))/n]

İntegral, yüksek frekans bileşenlerini zayıflatır (1/n faktörü). 
# Fourier serisinin türevini alma
def fourier_derivative(an_list, bn_list, x):
    """Fourier serisinin türevi"""
    result = 0
    for n, (an, bn) in enumerate(zip(an_list, bn_list), 1):
        result += n * (-an * np.sin(n*x) + bn * np.cos(n*x))
    return result

def fourier_integral(a0, an_list, bn_list, x):
    """Fourier serisinin integrali"""
    result = a0 * x / 2
    for n, (an, bn) in enumerate(zip(an_list, bn_list), 1):
        result += (an * np.sin(n*x) - bn * np.cos(n*x)) / n
    return result

8. Fourier Dönüşümleri ve Özellikleri

Fourier dönüşümü, periyodik olmayan fonksiyonları frekans domenine taşır. Fourier serisinin sürekli limiti olarak düşünülebilir.

Fourier Dönüşümü Tanımı

F(ω) = ∫₋∞^∞ f(t)e^(-iωt)dt

F(ω): Frekans domenindeki temsil
f(t): Zaman domenindeki sinyal
ω: Açısal frekans (radyan/saniye)

Temel Özellikler

Dönüşüm Özellikleri
Doğrusallık: ℱ{af + bg} = aℱ{f} + bℱ{g}
Öteleme: ℱ{f(t-a)} = e^(-iωa)F(ω)
Modülasyon: ℱ{e^(iω₀t)f(t)} = F(ω-ω₀)
Ölçekleme: ℱ{f(at)} = (1/|a|)F(ω/a)
Türev: ℱ{f'(t)} = iωF(ω) 
# Sayısal Fourier Dönüşümü (FFT kullanarak)
import numpy.fft as fft

def compute_fourier_transform(signal, dt):
    """FFT ile Fourier dönüşümü"""
    N = len(signal)
    
    # FFT hesaplama
    F = fft.fft(signal)
    
    # Frekans ekseni
    freqs = fft.fftfreq(N, dt)
    
    # Normalizasyon
    F = F * dt
    
    return freqs, F

def fourier_transform_properties():
    """Fourier dönüşüm özelliklerini göster"""
    t = np.linspace(-10, 10, 1000)
    dt = t[1] - t[0]
    
    # Gauss fonksiyonu
    f = np.exp(-t**2)
    
    # Fourier dönüşümü
    freqs, F = compute_fourier_transform(f, dt)
    
    # Öteleme özelliği
    a = 2
    f_shifted = np.exp(-(t-a)**2)
    _, F_shifted = compute_fourier_transform(f_shifted, dt)
    
    print("Öteleme doğrulaması:")
    print(f"Faz farkı: {np.angle(F_shifted[100]/F[100]):.6f}")
    print(f"Beklenen: {-2*np.pi*freqs[100]*a:.6f}")

# Örnek sinyaller ve dönüşümleri
def example_transforms():
    t = np.linspace(-20, 20, 2000)
    dt = t[1] - t[0]
    
    # 1. Dikdörtgen darbe
    rect = np.where(np.abs(t) < 1, 1, 0)
    freqs, F_rect = compute_fourier_transform(rect, dt)
    
    # 2. Gauss darbesi
    gauss = np.exp(-t**2)
    _, F_gauss = compute_fourier_transform(gauss, dt)
    
    print("Dikdörtgen → Sinc fonksiyonu")
    print("Gauss → Gauss (kendine benzer)")

9. Ters Fourier Dönüşümleri ve Özellikleri

Frekans domeninden zaman domenine geri dönüş:

Ters Fourier Dönüşümü

f(t) = (1/2π)∫₋∞^∞ F(ω)e^(iωt)dω

Fourier çifti: f(t) ⟷ F(ω)
İki dönüşüm birbirinin tersidir.

Fourier Ters Dönüşüm Teoremi: f integrallenebilir ve F de integrallenebilir ise, f hemen hemen her yerde ters dönüşümle elde edilebilir. f sürekli ise, eşitlik her yerde geçerlidir. 
# Ters Fourier dönüşümü
def inverse_fourier_transform(F, freqs):
    """IFFT ile ters Fourier dönüşümü"""
    df = freqs[1] - freqs[0]
    f = fft.ifft(F) / df
    return f.real

def test_inverse_transform():
    """Fourier ve ters Fourier dönüşümünü test et"""
    t = np.linspace(-10, 10, 1024)
    dt = t[1] - t[0]
    
    # Orijinal sinyal
    f_original = np.exp(-t**2) * np.cos(5*t)
    
    # İleri dönüşüm
    freqs, F = compute_fourier_transform(f_original, dt)
    
    # Geri dönüşüm
    f_reconstructed = inverse_fourier_transform(F, freqs)
    
    # Hata hesaplama
    error = np.max(np.abs(f_original - f_reconstructed))
    print(f"Yeniden oluşturma hatası: {error:.10f}")
    
    return error < 1e-10  # Test başarılı mı?

10. Kısmi Türevli Diferensiyel Denklemlere Uygulamalar

Fourier analizi, PDE'lerin çözümünde güçlü bir araçtır. Isı, dalga ve Laplace denklemleri için temel çözüm yöntemidir.

Isı Denklemi

Bir Boyutlu Isı Denklemi

∂u/∂t = α∂²u/∂x²
u(0,t) = u(L,t) = 0 (sınır koşulları)
u(x,0) = f(x) (başlangıç koşulu)

Çözüm: u(x,t) = Σbₙe^(-α(nπ/L)²t)sin(nπx/L) 

# Isı denklemi Fourier çözümü
def heat_equation_fourier(f, L, alpha, t, N=50):
    """
    Isı denkleminin Fourier serisi çözümü
    f: Başlangıç sıcaklık dağılımı
    L: Çubuğun uzunluğu
    alpha: Termal difüzyon katsayısı
    t: Zaman
    """
    def solution(x):
        result = 0
        for n in range(1, N+1):
            # Fourier katsayısı bn
            integrand = lambda xi: f(xi) * np.sin(n * np.pi * xi / L)
            bn, _ = quad(integrand, 0, L)
            bn *= 2 / L
            
            # Zaman evrimi
            decay = np.exp(-alpha * (n * np.pi / L)**2 * t)
            result += bn * decay * np.sin(n * np.pi * x / L)
        
        return result
    
    return solution

# Örnek: Başlangıçta üçgen dağılım
L = 1.0
alpha = 0.01
f_initial = lambda x: 1 - abs(2*x/L - 1)

x_vals = np.linspace(0, L, 100)
for t in [0, 0.1, 0.5, 1.0]:
    u = heat_equation_fourier(f_initial, L, alpha, t)
    y_vals = [u(x) for x in x_vals]
    print(f"t={t}: Maks sıcaklık = {max(y_vals):.4f}")

Dalga Denklemi

Dalga Denklemi Çözümü
∂²u/∂t² = c²∂²u/∂x² (dalga denklemi)

Çözüm: u(x,t) = Σ[Aₙcos(ωₙt) + Bₙsin(ωₙt)]sin(nπx/L)
ωₙ = cnπ/L (karakteristik frekanslar)
Fourier yöntemi, değişkenleri ayırma (separation of variables) tekniğine dayanır. PDE'yi ODE sistemine dönüştürür ve her modun bağımsız olarak evrilmesini sağlar.

11. Fourier Dönüşümlerinin İleri Özellikleri

Belirsizlik İlkesi

Heisenberg Belirsizlik İlkesi:
Δt · Δω ≥ 1/2

Bir sinyal zaman domeninde ne kadar dar ise, frekans domeninde o kadar geniştir ve tersi. Bu, sinyal işleme ve kuantum mekaniğinde temeldir.

Simetri Özellikleri

Simetri İlişkileri
Gerçek ve Çift: f(t) = f(-t), gerçel → F(ω) gerçel ve çift
Gerçek ve Tek: f(t) = -f(-t), gerçel → F(ω) salt imajiner ve tek
Dualite: ℱ{F(t)} = 2πf(-ω)
Evrişim: ℱ{f * g} = F(ω)G(ω)

12. Ters Fourier ve Plancherel Özdeşliği

Plancherel teoremi, Parseval özdeşliğinin Fourier dönüşümü için genelleştirilmesidir.

Plancherel Özdeşliği

∫₋∞^∞ |f(t)|²dt = (1/2π)∫₋∞^∞ |F(ω)|²dω

Zaman domenindeki toplam enerji = Frekans domenindeki toplam enerji

Plancherel Teoremi: Fourier dönüşümü, L² uzayında bir izometr postropheidir. Yani iç çarpımı ve normu korur:
⟨f,g⟩_L² = (1/2π)⟨F,G⟩_L² 
# Plancherel özdeşliğini doğrulama
def verify_plancherel(f, t_range=(-20, 20), N=4096):
    """Plancherel özdeşliğini kontrol et"""
    t = np.linspace(t_range[0], t_range[1], N)
    dt = t[1] - t[0]
    
    # Zaman domeninde enerji
    signal = np.array([f(ti) for ti in t])
    time_energy = np.sum(np.abs(signal)**2) * dt
    
    # Frekans domeninde enerji
    freqs, F = compute_fourier_transform(signal, dt)
    freq_energy = np.sum(np.abs(F)**2) * (freqs[1]-freqs[0]) / (2*np.pi)
    
    print(f"Zaman enerji: {time_energy:.6f}")
    print(f"Frekans enerji: {freq_energy:.6f}")
    print(f"Fark: {abs(time_energy - freq_energy):.6f}")

# Test
f_test = lambda t: np.exp(-t**2/2)
verify_plancherel(f_test)

13. Rezidü Teoremi ve Uygulamaları

Karmaşık analiz ve rezidü teoremi, Fourier dönüşümlerinin hesaplanmasında güçlü bir araçtır.

Rezidü Teoremi: f(z) analitik fonksiyon, C kapalı eğri ve z₁,...,zₙ kutuplar:
∮_C f(z)dz = 2πi·Σ Res(f, zₖ)

Fourier Dönüşümü Hesabı

Rezidü ile FT
Rasyonel fonksiyonların Fourier dönüşümü rezidü teoremi ile analitik olarak hesaplanabilir:
F(ω) = ∫₋∞^∞ f(t)e^(-iωt)dt → Karmaşık kontür integrali

Jordan lemması ve uygun kontür seçimi kritiktir. 
# Rezidü hesaplama örneği
def residue_at_pole(f, z0, order=1):
    """Basit veya çoklu kutuptaki rezidü"""
    if order == 1:
        # Basit kutup: Res(f,z0) = lim (z-z0)f(z)
        return lambda z: (z - z0) * f(z)
    else:
        # m. mertebe: (1/(m-1)!) * d^(m-1)/dz^(m-1) [(z-z0)^m f(z)]
        pass  # Nümerik türev gerekli

# Örnek: F(ω) = ∫₋∞^∞ e^(-|t|)e^(-iωt)dt
def exponential_ft_residue(omega):
    """
    e^(-|t|) fonksiyonunun FT'si rezidü ile
    Sonuç: 2/(1 + ω²)
    """
    return 2 / (1 + omega**2)

# Doğrulama
omega_test = 2.0
print(f"Analitik sonuç: {exponential_ft_residue(omega_test):.6f}")
Laplace dönüşümü, Fourier dönüşümünün karmaşık düzlemde genelleştirilmesidir: ℒ{f(t)} = ∫₀^∞ f(t)e^(-st)dt. Kontrol teorisi ve diferensiyel denklemlerde yaygın kullanılır.

14. Konvolüsyonlar ve Özellikleri

Konvolüsyon (evrişim), iki fonksiyonun "karıştırılması" işlemidir ve sinyal işleme, görüntü işleme ve olasılık teorisinde temeldir.

Konvolüsyon Tanımı

(f * g)(t) = ∫₋∞^∞ f(τ)g(t-τ)dτ

Konvolüsyon Teoremi:
ℱ{f * g} = ℱ{f} · ℱ{g}
ℱ{f · g} = (1/2π)(ℱ{f} * ℱ{g})

Önemi
Konvolüsyon teoremi, zaman domeninde karmaşık evrişim işlemini frekans domeninde basit çarpıma dönüştürür. Bu, FFT algoritmaları ile çok hızlı hesaplama imkanı verir.

Uygulamalar

Kullanım Alanları
Sinyal Filtreleme: Gürültü azaltma, düzgünleştirme
Görüntü İşleme: Bulanıklaştırma, keskinleştirme, kenar tespiti
Olasılık: Bağımsız rassal değişkenlerin toplamının dağılımı
Diferensiyel Denklemler: Green fonksiyonu ile çözüm 
# Konvolüsyon hesaplama
def convolution_time_domain(f, g, t_range, N=1000):
    """Zaman domeninde doğrudan konvolüsyon"""
    t = np.linspace(t_range[0], t_range[1], N)
    dt = t[1] - t[0]
    
    def conv_at_t(t_val):
        tau = t
        integrand = f(tau) * g(t_val - tau)
        return np.trapz(integrand, tau)
    
    return conv_at_t

def convolution_frequency_domain(f_signal, g_signal):
    """FFT ile hızlı konvolüsyon"""
    # FFT hesapla
    F = fft.fft(f_signal)
    G = fft.fft(g_signal)
    
    # Frekans domeninde çarp
    H = F * G
    
    # Ters FFT
    result = fft.ifft(H)
    return result.real

# Örnek: İki Gauss fonksiyonunun konvolüsyonu
def gaussian_convolution_example():
    t = np.linspace(-10, 10, 1024)
    dt = t[1] - t[0]
    
    # İki Gauss
    sigma1, sigma2 = 1.0, 1.5
    f = np.exp(-t**2/(2*sigma1**2))
    g = np.exp(-t**2/(2*sigma2**2))
    
    # FFT ile konvolüsyon
    conv_result = convolution_frequency_domain(f, g) * dt
    
    # Analitik sonuç: Gauss * Gauss = Gauss
    sigma_result = np.sqrt(sigma1**2 + sigma2**2)
    analytic = np.sqrt(2*np.pi*sigma_result**2) * np.exp(-t**2/(2*sigma_result**2))
    
    error = np.max(np.abs(conv_result - analytic))
    print(f"Konvolüsyon hatası: {error:.6f}")
    print(f"Sonuç sigma: {sigma_result:.4f}")

gaussian_convolution_example()

Özel Konvolüsyonlar

Dirac Delta ile Konvolüsyon: f * δ = f (özdeşlik)
Dikdörtgen Pencere: Düzgünleştirme (smoothing)
Gauss Çekirdeği: Bulanıklaştırma, gürültü azaltma
Türev Çekirdeği: Kenar tespiti

Fourier Analizi Yolculuğunuza Başlayın!

Önerilen Kaynaklar
Kitaplar:
• "Fourier Analysis" - Elias M. Stein & Rami Shakarchi
• "The Fourier Transform and Its Applications" - Ronald N. Bracewell
• "A Student's Guide to Fourier Transforms" - J.F. James

Yazılım:
• NumPy/SciPy (Python)
• MATLAB Signal Processing Toolbox
• FFTW (En hızlı FFT kütüphanesi)

Alıştırma:
• Farklı sinyallerin Fourier serilerini hesaplayın
• FFT ile görüntü filtreleme deneyin
• PDE'leri Fourier yöntemi ile çözün

import numpy.fft as fft
F = fft.fft(signal)
frequency_domain.explore()

Her sinyal, frekansların bir senfonisidir!