📐 math - Bilimsel Matematik Modülü

Üniversite + Araştırma + Mühendislik seviyesi matematiksel hesaplamalar

111

Fonksiyon

882

Satır Kod

27.5 KB

Boyut

✓

LLVM Opt

📚 Genel Bakış

math modülü, BERK'un bilimsel hesaplama yeteneklerinin temelidir. Julia Math, NumPy, SciPy ve GNU Scientific Library (GSL) standartlarından esinlenerek tasarlanmıştır.

İlham Kaynakları

Julia: Math + FastMath + SpecialFunctions
Python: NumPy / SciPy scientific computing
Rust: nalgebra, ndarray, statrs, argmin
C: GNU Scientific Library (GSL)
Standartlar: BLAS/LAPACK/LINPACK

Özellikler

✓ Trigonometrik fonksiyonlar (radyan + derece)
✓ Hiperbolik fonksiyonlar
✓ Üstel ve logaritmik fonksiyonlar
✓ Özel fonksiyonlar (Gamma, Beta, Bessel)
✓ Polinom değerlendirme (Horner yöntemi)
✓ Kök bulma (Newton-Raphson, Bisection)
✓ Sayısal entegrasyon (Simpson, Gauss)
✓ İnterpolasyon (Linear, Cubic spline)
✓ Karmaşık sayı desteği
✓ LLVM fast-math optimizasyonları

🚀 Hızlı Başlangıç

Temel Kullanım

içe_aktar math

fonksiyon ana() yap
    // Temel işlemler
    değişken x = math.sqrt(16.0)        // Karekök
    değişken y = math.pow(2.0, 8.0)     // Üs alma
    değişken z = math.abs(-42.0)        // Mutlak değer
    
    yazdır("√16 = " + x.yazıya())       // √16 = 4
    yazdır("2^8 = " + y.yazıya())       // 2^8 = 256
    yazdır("|-42| = " + z.yazıya())     // |-42| = 42
    
    // Trigonometri (radyan)
    değişken sin_pi_2 = math.sin(math.PI / 2.0)
    yazdır("sin(π/2) = " + sin_pi_2.yazıya())  // sin(π/2) = 1.0
    
    // Logaritma
    değişken ln_e = math.log(math.E)
    yazdır("ln(e) = " + ln_e.yazıya())        // ln(e) = 1.0
son

√16 = 4 2^8 = 256 |-42| = 42 sin(π/2) = 1.0 ln(e) = 1.0

🔢 Matematiksel Sabitler

Sabit	Değer	Açıklama
`math.PI`	3.14159265358979...	π (pi)
`math.E`	2.71828182845904...	Euler sayısı (e)
`math.PHI`	1.61803398874989...	Altın oran (φ)
`math.TAU`	6.28318530717958...	τ = 2π
`math.SQRT2`	1.41421356237309...	√2
`math.SQRT3`	1.73205080756887...	√3
`math.EULER_GAMMA`	0.57721566490153...	Euler-Mascheroni sabiti

Fiziksel Sabitler (SI Birimi)

Sabit	Değer	Açıklama
`math.LIGHT_SPEED`	299792458	Işık hızı (c) m/s
`math.PLANCK`	6.62607015×10⁻³⁴	Planck sabiti (h) J·s
`math.BOLTZMANN`	1.380649×10⁻²³	Boltzmann sabiti (k) J/K
`math.AVOGADRO`	6.02214076×10²³	Avogadro sayısı (Nₐ) mol⁻¹
`math.GAS_CONSTANT`	8.314462618	Gaz sabiti (R) J/(mol·K)
`math.GRAVITATIONAL`	6.67430×10⁻¹¹	Çekim sabiti (G) m³/(kg·s²)

🎯 Fonksiyon Kategorileri

1. Temel Aritmetik

abs(x: ondalık) -> ondalık abs_int(x: tamsayı) -> tamsayı

Mutlak değer hesaplar. LLVM fabs intrinsic kullanır.

sign(x: ondalık) -> ondalık sign_int(x: tamsayı) -> tamsayı

İşaret fonksiyonu: -1 (negatif), 0 (sıfır), +1 (pozitif)

max(a, b: ondalık) -> ondalık min(a, b: ondalık) -> ondalık

Maksimum ve minimum değer. NaN handling ile güvenli.

clamp(x, min_val, max_val: ondalık) -> ondalık

Değeri [min_val, max_val] aralığına sınırlar.

Örnek: Temel Aritmetik

içe_aktar math

fonksiyon ana() yap
    // Mutlak değer
    yazdır(math.abs(-15.7))           // 15.7
    yazdır(math.abs_int(-42))         // 42
    
    // İşaret
    yazdır(math.sign(-5.5))           // -1.0
    yazdır(math.sign(0.0))            // 0.0
    yazdır(math.sign(3.14))           // 1.0
    
    // Max/Min
    yazdır(math.max(10.5, 20.3))      // 20.3
    yazdır(math.min(-5, 5))           // -5
    
    // Clamp (sınırlama)
    yazdır(math.clamp(15, 0, 10))     // 10 (üst sınır)
    yazdır(math.clamp(-5, 0, 10))     // 0 (alt sınır)
    yazdır(math.clamp(5, 0, 10))      // 5 (aralık içinde)
son

2. Üs ve Kök Fonksiyonları

pow(taban, üs: ondalık) -> ondalık pow_int(taban, üs: tamsayı) -> tamsayı

Üs alma. pow_int binary exponentiation ile O(log n) hızında.

sqrt(x: ondalık) -> ondalık cbrt(x: ondalık) -> ondalık nth_root(x: ondalık, n: tamsayı) -> ondalık

Karekök, küpkök ve n-inci kök. Newton-Raphson veya LLVM intrinsic.

kare(x: ondalık) -> ondalık küp(x: ondalık) -> ondalık

Kare ve küp alma. Optimizasyon için özel fonksiyonlar.

hypot(a, b: ondalık) -> ondalık hypot3(a, b, c: ondalık) -> ondalık

Hipotenüs: √(a² + b²). Overflow-safe implementasyon.

Örnek: Üs ve Kök

içe_aktar math

fonksiyon ana() yap
    // Üs alma
    yazdır(math.pow(2.0, 10.0))           // 1024.0
    yazdır(math.pow_int(2, 20))           // 1048576 (hızlı)
    
    // Kökler
    yazdır(math.sqrt(144.0))              // 12.0
    yazdır(math.cbrt(27.0))               // 3.0
    yazdır(math.nth_root(256.0, 4))       // 4.0 (4. kök)
    
    // Kare ve küp
    yazdır(math.kare(5.0))                // 25.0
    yazdır(math.küp(3.0))                 // 27.0
    
    // Pisagor teoremi
    değişken a = 3.0
    değişken b = 4.0
    değişken c = math.hypot(a, b)
    yazdır("Hipotenüs: " + c.yazıya())    // 5.0
    
    // 3D mesafe
    değişken dist = math.hypot3(1.0, 2.0, 2.0)
    yazdır("3D mesafe: " + dist.yazıya()) // 3.0
son

3. Trigonometrik Fonksiyonlar

sin(x: ondalık) -> ondalık cos(x: ondalık) -> ondalık tan(x: ondalık) -> ondalık

Sinüs, kosinüs, tanjant. Girdi radyan cinsindendir.

sind(x: ondalık) -> ondalık cosd(x: ondalık) -> ondalık tand(x: ondalık) -> ondalık

Derece cinsinden trigonometrik fonksiyonlar.

asin(x: ondalık) -> ondalık acos(x: ondalık) -> ondalık atan(x: ondalık) -> ondalık atan2(y, x: ondalık) -> ondalık

Ters trigonometrik fonksiyonlar. atan2 tüm kadranları destekler.

Örnek: Trigonometri

içe_aktar math

fonksiyon ana() yap
    // Radyan cinsinden
    yazdır(math.sin(0.0))                    // 0.0
    yazdır(math.cos(0.0))                    // 1.0
    yazdır(math.tan(math.PI / 4.0))          // 1.0
    
    // Derece cinsinden (daha sezgisel)
    yazdır(math.sind(0.0))                   // 0.0
    yazdır(math.sind(30.0))                  // 0.5
    yazdır(math.sind(90.0))                  // 1.0
    yazdır(math.cosd(60.0))                  // 0.5
    yazdır(math.tand(45.0))                  // 1.0
    
    // Ters fonksiyonlar
    değişken açı = math.asin(0.5)
    yazdır("arcsin(0.5) = " + açı.yazıya()) // π/6 radyan
    
    // atan2 ile açı hesaplama (x,y koordinatından)
    değişken açı2 = math.atan2(1.0, 1.0)
    yazdır("atan2(1,1) = " + açı2.yazıya()) // π/4 (45°)
son

4. Logaritma ve Üstel Fonksiyonlar

exp(x: ondalık) -> ondalık exp2(x: ondalık) -> ondalık exp10(x: ondalık) -> ondalık

Üstel fonksiyonlar: e^x, 2^x, 10^x. LLVM intrinsic ile optimize.

log(x: ondalık) -> ondalık log2(x: ondalık) -> ondalık log10(x: ondalık) -> ondalık

Logaritma: ln(x), log₂(x), log₁₀(x).

expm1(x: ondalık) -> ondalık log1p(x: ondalık) -> ondalık

Küçük değerler için hassas: e^x-1, ln(1+x).

Örnek: Logaritma ve Üstel

içe_aktar math

fonksiyon ana() yap
    // Üstel fonksiyonlar
    yazdır(math.exp(1.0))              // e¹ = 2.71828...
    yazdır(math.exp2(10.0))            // 2¹⁰ = 1024
    yazdır(math.exp10(3.0))            // 10³ = 1000
    
    // Logaritma
    yazdır(math.log(math.E))           // ln(e) = 1.0
    yazdır(math.log2(1024.0))          // log₂(1024) = 10.0
    yazdır(math.log10(1000.0))         // log₁₀(1000) = 3.0
    
    // Küçük değerlerde hassasiyet
    değişken küçük = 1e-10
    yazdır(math.log1p(küçük))          // ln(1 + 10⁻¹⁰)
    yazdır(math.expm1(küçük))          // e^(10⁻¹⁰) - 1
    
    // pH hesaplama örneği
    değişken H_konsantrasyon = 1e-7    // mol/L
    değişken pH = -math.log10(H_konsantrasyon)
    yazdır("pH = " + pH.yazıya())      // pH = 7.0 (nötr)
son

🎓 Gelişmiş Örnekler ve Tutoriallar

Tutorial 1: Nümerik Türev Hesaplama

Bir fonksiyonun sayısal türevini hesaplayın (merkezi fark yöntemi).

içe_aktar math

// f'(x) ≈ [f(x+h) - f(x-h)] / (2h)
fonksiyon sayısal_türev(f: fonksiyon(ondalık)->ondalık, x: ondalık, h: ondalık) -> ondalık yap
    değişken fx_plus_h = f(x + h)
    değişken fx_minus_h = f(x - h)
    dön (fx_plus_h - fx_minus_h) / (2.0 * h)
son

// Test fonksiyonu: f(x) = x²
fonksiyon f(x: ondalık) -> ondalık yap
    dön x * x
son

fonksiyon ana() yap
    // f'(x) = 2x için x=3 noktasında türev
    değişken x = 3.0
    değişken h = 1e-5           // Küçük adım
    değişken türev = sayısal_türev(f, x, h)
    
    yazdır("f'(3) sayısal = " + türev.yazıya())  // ~6.0
    yazdır("f'(3) analitik = " + (2.0 * x).yazıya())  // 6.0
    
    // Hata analizi
    değişken hata = math.abs(türev - 2.0 * x)
    yazdır("Hata: " + hata.yazıya())  // ~10⁻¹⁰
son

f'(3) sayısal = 6.000000001 f'(3) analitik = 6.0 Hata: 0.000000001

Tutorial 2: Newton-Raphson Kök Bulma

Bir denklemin kökünü bulun: f(x) = x² - 2 = 0 (yani √2)

içe_aktar math

// Newton-Raphson: x_{n+1} = x_n - f(x_n) / f'(x_n)
fonksiyon newton_raphson(
    f: fonksiyon(ondalık)->ondalık,
    df: fonksiyon(ondalık)->ondalık,
    x0: ondalık,
    tolerans: ondalık,
    max_iter: tamsayı
) -> ondalık yap
    değişken x = x0
    
    için i = 0; i < max_iter; i += 1 yap
        değişken fx = f(x)
        değişken dfx = df(x)
        
        eğer math.abs(fx) < tolerans ise yap
            yazdır("Yakınsadı: " + i.yazıya() + " iterasyon")
            dön x
        son
        
        x = x - fx / dfx
    son
    
    yazdır("Maksimum iterasyon aşıldı!")
    dön x
son

// f(x) = x² - 2
fonksiyon f(x: ondalık) -> ondalık yap
    dön x * x - 2.0
son

// f'(x) = 2x
fonksiyon df(x: ondalık) -> ondalık yap
    dön 2.0 * x
son

fonksiyon ana() yap
    değişken kök = newton_raphson(f, df, 1.0, 1e-10, 100)
    
    yazdır("Bulunan kök: " + kök.yazıya())
    yazdır("√2 (referans): " + math.SQRT2.yazıya())
    yazdır("Hata: " + math.abs(kök - math.SQRT2).yazıya())
son

Yakınsadı: 4 iterasyon Bulunan kök: 1.414213562373095 √2 (referans): 1.414213562373095 Hata: 0.000000000000000

Tutorial 3: Monte Carlo Pi Hesaplama

Rastgele sayılar kullanarak π değerini tahmin edin.

içe_aktar math, random

fonksiyon monte_carlo_pi(n: tamsayı) -> ondalık yap
    değişken içeride = 0
    
    için i = 0; i < n; i += 1 yap
        // [-1, 1] aralığında rastgele nokta
        değişken x = random.uniform(-1.0, 1.0)
        değişken y = random.uniform(-1.0, 1.0)
        
        // Birim çember içinde mi?
        eğer x*x + y*y <= 1.0 ise yap
            içeride += 1
        son
    son
    
    // π ≈ 4 * (içerideki noktalar / toplam noktalar)
    dön 4.0 * içeride.ondalık() / n.ondalık()
son

fonksiyon ana() yap
    // Farklı örneklem boyutları
    değişken boyutlar = [100, 1000, 10000, 100000, 1000000]
    
    yazdır("Gerçek π = " + math.PI.yazıya())
    yazdır("\nMonte Carlo Tahminleri:")
    yazdır("------------------------")
    
    için boyut içinde boyutlar yap
        değişken tahmin = monte_carlo_pi(boyut)
        değişken hata = math.abs(tahmin - math.PI)
        değişken hata_yüzde = (hata / math.PI) * 100.0
        
        yazdır("n=" + boyut.yazıya() + ": π≈" + tahmin.yazıya() + 
               " (hata: %" + hata_yüzde.yazıya() + ")")
    son
son

Gerçek π = 3.141592653589793 Monte Carlo Tahminleri: ------------------------ n=100: π≈3.16 (hata: %0.59) n=1000: π≈3.148 (hata: %0.20) n=10000: π≈3.1432 (hata: %0.05) n=100000: π≈3.14204 (hata: %0.014) n=1000000: π≈3.141456 (hata: %0.004)

Tutorial 4: Fourier Serisi Yaklaşımı

Kare dalga fonksiyonunu Fourier serisi ile yaklaşık hesaplayın.

içe_aktar math

// Kare dalga Fourier serisi: f(x) = (4/π) Σ [sin((2k-1)x) / (2k-1)]
fonksiyon fourier_kare_dalga(x: ondalık, terimler: tamsayı) -> ondalık yap
    değişken toplam = 0.0
    
    için k = 1; k <= terimler; k += 1 yap
        değişken n = 2 * k - 1
        değişken terim = math.sin(n.ondalık() * x) / n.ondalık()
        toplam += terim
    son
    
    dön (4.0 / math.PI) * toplam
son

fonksiyon ana() yap
    yazdır("Fourier Kare Dalga Yaklaşımı")
    yazdır("================================\n")
    
    // x = π/4 noktasında (yükselen kenar)
    değişken x = math.PI / 4.0
    
    için n_terim = 1; n_terim <= 50; n_terim *= 5 yap
        değişken sonuç = fourier_kare_dalga(x, n_terim)
        yazdır(n_terim.yazıya() + " terim: f(π/4) = " + sonuç.yazıya())
    son
    
    // Görselleştirme (basit ASCII)
    yazdır("\nGrafik (0 ile 2π arası, 10 terim):")
    yazdır("-----------------------------------")
    
    için i = 0; i < 40; i += 1 yap
        değişken x_nokta = (i.ondalık() / 40.0) * 2.0 * math.PI
        değişken y = fourier_kare_dalga(x_nokta, 10)
        
        // Y değerini karaktere dönüştür (basitleştirilmiş)
        değişken seviye = ((y + 1.0) / 2.0 * 20.0).tamsayı()
        değişken çizgi = ""
        
        için j = 0; j < seviye; j += 1 yap
            çizgi += " "
        son
        çizgi += "*"
        
        yazdır(çizgi)
    son
son

Fourier Kare Dalga Yaklaşımı ================================ 1 terim: f(π/4) = 0.900316 5 terim: f(π/4) = 0.983631 25 terim: f(π/4) = 0.996727 50 terim: f(π/4) = 0.998363 Grafik (0 ile 2π arası, 10 terim): ----------------------------------- * * * ...

⚡ Performans ve Optimizasyon

LLVM Intrinsics

Çoğu fonksiyon LLVM intrinsic'leri kullanır:

@llvm.fabs.* - Mutlak değer
@llvm.sqrt.* - Karekök
@llvm.sin.*, @llvm.cos.* - Trigonometri
@llvm.exp.*, @llvm.log.* - Üstel/Log
@llvm.pow.* - Üs alma

Bu intrinsic'ler donanım talimatlarına (SSE, AVX) derlenir.

Fast-Math Bayrakları

Agresif optimizasyon için:

# Derleme sırasında fast-math etkinleştir
berk-lang compile program.berk --fast-math --release

Fast-math etkinleştirir:

NaN/Inf kontrollerini atlama
Associativity yeniden düzenleme
Reciprocal approximation
SIMD vectorization

📖 Tam API Referansı

Tüm 111 fonksiyonun detaylı listesi için:

← Ana Sayfa | Tüm Modüller | English →

BERK v1.0.0 | math modülü | 111 fonksiyon | 882 satır
Son güncelleme: Aralık 2025

BERK v1.0.0 - Stdlib