🚀 Hızlı Başlangıç

içe_aktar linalg

// 3×3 birim matris
değişken I = linalg_birim_mat(3)

// Sıfır matrisi
değişken Z = linalg_sıfır_mat(2, 3)

// Birler matrisi
değişken O = linalg_birler_mat(4, 4)

// Diyagonal matris
değişken d = [1.0, 2.0, 3.0]
değişken D = linalg_diyagonal_mat(d, 3)

// Rastgele matris
değişken R = linalg_rastgele_mat(3, 3, 12345)

Matris İşlemleri

// Transpoze
değişken A = [1.0, 2.0, 3.0, 4.0]  // 2×2
değişken AT = linalg_transpoz(A, 2, 2)

// Matris toplama
değişken C = linalg_mat_topla(A, B, 2, 2)

// Skaler çarpma
değişken D = linalg_mat_skaler(2.0, A, 2, 2)

// Matris çarpımı (A: 2×3, B: 3×2 → C: 2×2)
değişken C = linalg_mat_çarp(A, B, 2, 3, 2)

📚 API Referansı

Matris Oluşturma

linalg_birim_mat(n: tam_sayı) -> [ondalık]

n×n boyutunda birim (identity) matris oluşturur.

Parametre:

• n: Matris boyutu

Döndürür: Birim matris (düz dizi formatında)

Örnek:

değişken I3 = linalg_birim_mat(3)
// I3 = [1, 0, 0,
//       0, 1, 0,
//       0, 0, 1]

linalg_sıfır_mat(m: tam_sayı, n: tam_sayı) -> [ondalık]

m×n boyutunda sıfır matrisi oluşturur.

linalg_birler_mat(m: tam_sayı, n: tam_sayı) -> [ondalık]

m×n boyutunda tüm elemanları 1 olan matris oluşturur.

linalg_diyagonal_mat(d: [ondalık], n: tam_sayı) -> [ondalık]

Köşegen elemanları d dizisi olan n×n matris oluşturur.

Örnek:

değişken d = [2.0, 3.0, 5.0]
değişken D = linalg_diyagonal_mat(d, 3)
// D = [2, 0, 0,
//      0, 3, 0,
//      0, 0, 5]

Matris Aritmetiği

linalg_mat_topla(A: [ondalık], B: [ondalık], m: tam_sayı, n: tam_sayı) -> [ondalık]

İki m×n matrisini toplar: C = A + B

linalg_mat_çıkar(A: [ondalık], B: [ondalık], m: tam_sayı, n: tam_sayı) -> [ondalık]

İki m×n matrisini çıkarır: C = A - B

linalg_mat_skaler(α: ondalık, A: [ondalık], m: tam_sayı, n: tam_sayı) -> [ondalık]

Matrisi skaler ile çarpar: B = α · A

linalg_mat_çarp(A: [ondalık], B: [ondalık], m: tam_sayı, k: tam_sayı, n: tam_sayı) -> [ondalık]

Matris çarpımı: C = A × B

• A: m×k
• B: k×n
• C: m×n

Örnek:

// 2×2 matris çarpımı
değişken A = [1.0, 2.0,
              3.0, 4.0]
değişken B = [5.0, 6.0,
              7.0, 8.0]
değişken C = linalg_mat_çarp(A, B, 2, 2, 2)
// C = [19, 22,
//      43, 50]

linalg_mat_hadamard(A: [ondalık], B: [ondalık], m: tam_sayı, n: tam_sayı) -> [ondalık]

Element-wise çarpım (Hadamard product): C[i,j] = A[i,j] × B[i,j]

Vektör İşlemleri

linalg_iç_çarpım(u: [ondalık], v: [ondalık], n: tam_sayı) -> ondalık

İç çarpım (dot product): u · v = Σ(u[i] × v[i])

Örnek:

değişken u = [1.0, 2.0, 3.0]
değişken v = [4.0, 5.0, 6.0]
değişken dot = linalg_iç_çarpım(u, v, 3)  // 32.0

linalg_norm2(v: [ondalık], n: tam_sayı) -> ondalık

L2 norm (Euclidean norm): ||v|| = √(Σv[i]²)

linalg_norm1(v: [ondalık], n: tam_sayı) -> ondalık

L1 norm (Manhattan norm): ||v||₁ = Σ|v[i]|

linalg_norm_inf(v: [ondalık], n: tam_sayı) -> ondalık

L∞ norm (maximum norm): ||v||∞ = max(|v[i]|)

linalg_normalize(v: [ondalık], n: tam_sayı) -> [ondalık]

Vektörü normalize eder: v̂ = v / ||v||

linalg_dış_çarpım(u: [ondalık], v: [ondalık], m: tam_sayı, n: tam_sayı) -> [ondalık]

Dış çarpım (outer product): A[i,j] = u[i] × v[j]

linalg_cross_3d(u: [ondalık], v: [ondalık]) -> [ondalık]

3D vektör cross product (vektörel çarpım): w = u × v

Örnek:

değişken u = [1.0, 0.0, 0.0]
değişken v = [0.0, 1.0, 0.0]
değişken w = linalg_cross_3d(u, v)  // [0, 0, 1]

Matris Özellikleri

linalg_iz(A: [ondalık], n: tam_sayı) -> ondalık

İz (trace): tr(A) = Σ A[i,i]

linalg_frobenius_norm(A: [ondalık], m: tam_sayı, n: tam_sayı) -> ondalık

Frobenius norm: ||A||_F = √(Σ Σ A[i,j]²)

linalg_determinant_2x2(A: [ondalık]) -> ondalık

2×2 matris determinantı: det(A) = a₁₁a₂₂ - a₁₂a₂₁

linalg_determinant_3x3(A: [ondalık]) -> ondalık

3×3 matris determinantı (Sarrus kuralı)

Matris Tersi

linalg_inverse_2x2(A: [ondalık]) -> [ondalık]

2×2 matris tersini hesaplar: A⁻¹

Örnek:

değişken A = [4.0, 7.0,
              2.0, 6.0]
değişken A_inv = linalg_inverse_2x2(A)
// det(A) = 10
// A_inv = [0.6, -0.7,
//         -0.2,  0.4]

linalg_inverse_3x3(A: [ondalık]) -> [ondalık]

3×3 matris tersini hesaplar (cofactor expansion)

Doğrusal Sistemler

linalg_gauss_çöz(A: [ondalık], b: [ondalık], n: tam_sayı) -> [ondalık]

Ax = b doğrusal sistemini Gauss eliminasyonu ile çözer.

Özellikler:

• Partial pivoting
• Forward elimination
• Back substitution

Örnek:

// 3x + 2y = 7
// 2x + 5y = 12
değişken A = [3.0, 2.0,
              2.0, 5.0]
değişken b = [7.0, 12.0]
değişken x = linalg_gauss_çöz(A, b, 2)
// x = [1, 2]

Matris Ayrıştırmaları

linalg_lu_decompose(A: [ondalık], n: tam_sayı) -> [ondalık]

LU ayrıştırması: A = L × U

• L: Alt üçgen matris (köşegeni 1)
• U: Üst üçgen matris

Kullanım: Doğrusal sistemleri hızlı çözmek için

linalg_qr_gram_schmidt(A: [ondalık], m: tam_sayı, n: tam_sayı) -> ([ondalık], [ondalık])

QR ayrıştırması: A = Q × R

• Q: Ortogonal matris
• R: Üst üçgen matris

Algoritma: Gram-Schmidt orthogonalization

Döndürür: (Q, R) tuple'ı

linalg_cholesky(A: [ondalık], n: tam_sayı) -> [ondalık]

Cholesky ayrıştırması: A = L × Lᵀ

Gereksinim: A pozitif tanımlı simetrik matris olmalı

Kullanım: Kovaryans matrisleri, optimization

Özdeğer/Özvektör

linalg_power_iteration(A: [ondalık], n: tam_sayı, max_iter: tam_sayı, tolerans: ondalık) -> ([ondalık], ondalık)

Güç iterasyonu ile dominant eigenvector bulma.

Döndürür: (eigenvector, eigenvalue) tuple'ı

Örnek:

değişken A = [4.0, 1.0,
              1.0, 3.0]
değişken (v, λ) = linalg_power_iteration(A, 2, 100, 1e-6)
// λ ≈ 4.618 (dominant eigenvalue)
// v: karşılık gelen eigenvector

Matris Testleri

linalg_simetrik_mi(A: [ondalık], n: tam_sayı, tolerans: ondalık) -> mantıksal

Matrisin simetrik olup olmadığını kontrol eder: Aᵢⱼ = Aⱼᵢ

linalg_diagonal_mi(A: [ondalık], n: tam_sayı, tolerans: ondalık) -> mantıksal

Diyagonal matris kontrolü

linalg_üst_üçgen_mi(A: [ondalık], n: tam_sayı, tolerans: ondalık) -> mantıksal

Üst üçgen matris kontrolü

linalg_alt_üçgen_mi(A: [ondalık], n: tam_sayı, tolerans: ondalık) -> mantıksal

Alt üçgen matris kontrolü

Matris Rankı

linalg_rank(A: [ondalık], m: tam_sayı, n: tam_sayı, tolerans: ondalık) -> tam_sayı

Matris rankını Gaussian elimination ile hesaplar.

Örnek:

değişken A = [1.0, 2.0, 3.0,
              2.0, 4.0, 6.0,
              3.0, 6.0, 9.0]
değişken r = linalg_rank(A, 3, 3, 1e-10)  // r = 1

🔬 Kullanım Örnekleri

Örnek 1: Doğrusal Regresyon

kullan linalg
kullan stats

// y = ax + b modelini fit et
fonksiyon linear_fit(X: [ondalık], y: [ondalık], n: tam_sayı): (ondalık, ondalık) yap
    // X matrix: [ones, x_values]
    değişken A = yeni_dizi(n * 2)
    değişken i = 0
    iken (i < n) yap
        A[i * 2] = 1.0
        A[i * 2 + 1] = X[i]
        i = i + 1
    son
    
    // Normal equations: (A^T A) β = A^T y
    değişken params = linalg_least_squares(A, y, n, 2)
    dön (params[0], params[1])  // (b, a)
son

Örnek 2: PCA (Principal Component Analysis)

kullan linalg

// Veriyi merkeze al
fonksiyon center_data(data: [ondalık], m: tam_sayı, n: tam_sayı): [ondalık] yap
    değişken centered = linalg_mat_kopyala(data, m, n)
    
    // Her sütun için ortalamayı çıkar
    değişken j = 0
    iken (j < n) yap
        değişken ortalama = 0.0
        değişken i = 0
        iken (i < m) yap
            ortalama = ortalama + linalg_mat_al(data, i, j, n)
            i = i + 1
        son
        ortalama = ortalama / m
        
        i = 0
        iken (i < m) yap
            değişken değer = linalg_mat_al(centered, i, j, n) - ortalama
            linalg_mat_yaz(centered, i, j, n, değer)
            i = i + 1
        son
        
        j = j + 1
    son
    
    dön centered
son

// Kovaryans matrisini hesapla
fonksiyon covariance_matrix(data: [ondalık], m: tam_sayı, n: tam_sayı): [ondalık] yap
    değişken centered = center_data(data, m, n)
    değişken CT = linalg_transpoz(centered, m, n)
    değişken cov = linalg_mat_çarp(CT, centered, n, m, n)
    
    // (n-1) ile böl
    değişken i = 0
    iken (i < n * n) yap
        cov[i] = cov[i] / (m - 1)
        i = i + 1
    son
    
    dön cov
son

Örnek 3: Matris Normu ve Condition Number

kullan linalg

fonksiyon analyze_matrix(A: [ondalık], n: tam_sayı): hiçbir yap
    // Frobenius norm
    değişken norm = linalg_frobenius_norm(A, n, n)
    yazdır("||A||_F = " + norm)
    
    // Determinant
    eğer (n == 2) ise yap
        değişken det = linalg_determinant_2x2(A)
        yazdır("det(A) = " + det)
        
        // Inverse ve condition number
        eğer (math_mutlak(det) > 1e-10) ise yap
            değişken A_inv = linalg_inverse_2x2(A)
            değişken κ = linalg_condition_frobenius(A, A_inv, n)
            yazdır("κ(A) = " + κ)
            
            eğer (κ > 100.0) ise yap
                yazdır("UYARI: Matris kötü koşullu!")
            son
        son
    son
    
    // Simetri kontrolü
    eğer (linalg_simetrik_mi(A, n, 1e-10)) ise yap
        yazdır("Matris simetriktir")
    son
son

⚡ Performans Notları

Kompleksite

Optimizasyon İpuçları

1. BLAS/LAPACK Kullanın (gelecek sürüm):

   // Native BLAS matris çarpımı
   değişken C = linalg_gemm_blas(A, B, m, k, n)
   

2. Seyrek Matrisler için özel algoritmalar (v1.5):

   kullan sparse
   değişken A_sparse = sparse_csr(A, m, n)
   

3. GPU Acceleration (planlanan):

   kullan cuda
   değişken C = cuda_matmul(A, B, m, k, n)
   

🔗 İlgili Modüller

• stats - İstatistiksel hesaplamalar için linalg kullanır
• optim - Optimizasyon algoritmaları için matris işlemleri
• math - Temel matematik fonksiyonları

📖 Daha Fazla Bilgi

• Julia LinearAlgebra
• NumPy Linear Algebra
• Rust nalgebra
• LAPACK User Guide