Temel useım

import math

function main() do
    // Temel işlemler
    let x = math.sqrt(16.0)        // Karekök
    let y = math.pow(2.0, 8.0)     // Üs alma
    let 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)
    let sin_pi_2 = math.sin(math.PI / 2.0)
    yazdır("sin(π/2) = " + sin_pi_2.yazıya())  // sin(π/2) = 1.0
    
    // Logaritma
    let ln_e = math.log(math.E)
    yazdır("ln(e) = " + ln_e.yazıya())        // ln(e) = 1.0
end

Tutorial 1: Nümerik Türev Hesaplama

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

import math

// f'(x) ≈ [f(x+h) - f(x-h)] / (2h)
function sayısal_türev(f: function(ondalık)->ondalık, x: ondalık, h: ondalık) -> ondalık do
    let fx_plus_h = f(x + h)
    let fx_minus_h = f(x - h)
    return (fx_plus_h - fx_minus_h) / (2.0 * h)
end

// Test functionu: f(x) = x²
function f(x: ondalık) -> ondalık do
    return x * x
end

function main() do
    // f'(x) = 2x for x=3 noktasında türev
    let x = 3.0
    let h = 1e-5           // Küçük adım
    let 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
    
    // Error analizi
    let Error = math.abs(türev - 2.0 * x)
    yazdır("Error: " + Error.yazıya())  // ~10⁻¹⁰
end

Tutorial 2: Newton-Raphson Kök Bulma

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

import math

// Newton-Raphson: x_{n+1} = x_n - f(x_n) / f'(x_n)
function newton_raphson(
    f: function(ondalık)->ondalık,
    df: function(ondalık)->ondalık,
    x0: ondalık,
    tolerans: ondalık,
    max_iter: tamsayı
) -> ondalık do
    let x = x0
    
    for i = 0; i < max_iter; i += 1 do
        let fx = f(x)
        let dfx = df(x)
        
        if math.abs(fx) < tolerans  do
            yazdır("Yakınsadı: " + i.yazıya() + " iterasyon")
            return x
        end
        
        x = x - fx / dfx
    end
    
    yazdır("Maksimum iterasyon aşıldı!")
    return x
end

// f(x) = x² - 2
function f(x: ondalık) -> ondalık do
    return x * x - 2.0
end

// f'(x) = 2x
function df(x: ondalık) -> ondalık do
    return 2.0 * x
end

function main() do
    let 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("Error: " + math.abs(kök - math.SQRT2).yazıya())
end

Tutorial 3: Monte Carlo Pi Hesaplama

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

import math, random

function monte_carlo_pi(n: tamsayı) -> ondalık do
    let içeride = 0
    
    for i = 0; i < n; i += 1 do
        // [-1, 1] aralığında rastgele nokta
        let x = random.uniform(-1.0, 1.0)
        let y = random.uniform(-1.0, 1.0)
        
        // Birim çember in mi?
        if x*x + y*y <= 1.0  do
            içeride += 1
        end
    end
    
    // π ≈ 4 * (içerideki noktalar / toplam noktalar)
    return 4.0 * içeride.ondalık() / n.ondalık()
end

function main() do
    // Farklı Examplelem boyutları
    let boyutlar = [100, 1000, 10000, 100000, 1000000]
    
    yazdır("Gerçek π = " + math.PI.yazıya())
    yazdır("\nMonte Carlo Tahminleri:")
    yazdır("------------------------")
    
    for boyut in boyutlar do
        let tahmin = monte_carlo_pi(boyut)
        let Error = math.abs(tahmin - math.PI)
        let Error_yüzde = (Error / math.PI) * 100.0
        
        yazdır("n=" + boyut.yazıya() + ": π≈" + tahmin.yazıya() + 
               " (Error: %" + Error_yüzde.yazıya() + ")")
    end
end

Tutorial 4: Fourier Serisi Yaklaşımı

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

import math

// Kare dalga Fourier serisi: f(x) = (4/π) Σ [sin((2k-1)x) / (2k-1)]
function fourier_kare_dalga(x: ondalık, terimler: tamsayı) -> ondalık do
    let toplam = 0.0
    
    for k = 1; k <= terimler; k += 1 do
        let n = 2 * k - 1
        let terim = math.sin(n.ondalık() * x) / n.ondalık()
        toplam += terim
    end
    
    return (4.0 / math.PI) * toplam
end

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