C++ ile Cholesky Metodu. (LU Decomposition)

[guvejokua]

//Kodlayan: Guvejokua

#include <iostream>
#include "hesaplama.h"  // Tüm hesaplamalar bu başlıkta yapılacak.
#include <locale.h>
using namespace::std;


int main(int argc, char** argv) {
    setlocale(LC_ALL, "Turkish");
    double **a, **l, *b, *d, *x;
    int i, j, k, n;
    cout << "Matris Boyutunu giriniz: ";
    cin >> n;
    a = new double * [n];                                                                                    //////////////////////////////////////////////////
    for(i=0; i<n; i++)                                                                                    //////// Katsayılar matrisi için yer ayırma///////
        a[i] = new double [n];                                                                            //////////////////////////////////////////////////
   
    l = new double * [n];                                                                                 /////////////////////////////////////////////////
    for(i=0; i<n; i++)                                                                                  ////////// l matrisi için yer ayırma ////////////
        l[i] = new double [n];                                                                         /////////////////////////////////////////////////
   
    b = new double [n];                                                                                  // Değerler matrisi için yer ayırma
    d = new double [n];                                                                              //  d matrisi için yer ayırma
    x = new double [n];                                                                              //   x matrisi için yer ayırma  
   
   
    for(i=0; i<n; i++)                                                                            //////////////////////////////////////////////////
        for(j=0; j<n; j++) {                                                                     //////////////////////////////////////////////////
            cout << "[" <<i+1 << "]" << "[" << j+1 << "].elamanı giriniz: ";                  //////////////////////////////////////////////////
            cin >> a[i][j];                                                                      /// Katsayılar matrisinin okunması ///////////////
            l[i][j]=0;                                                                       //// l matrisi sıfırlanıyor //////////////////////
        }                                                                                  //////////////////////////////////////////////////
       
       
    for(i=0; i<n; i++)                                                                    //////////////////////////////////////////////////
        for(j=0; j<n; j++)                                                               //// l matrisi hesaplanıyor //////////////////////
            l[j][i] = hesapL(a, j, i, n);                                                //////////////////////////////////////////////////
   
    cout << "Değerler matrisini giriniz: " << endl;
   
    for(i=0; i<n; i++) {                                                                    ///////////////////////////////////////////////
        cout << "[" << i+1 << "].elemanı giriniz: ";                                       ////Değer matrisi okunuyor ////////////////////
        cin >> b[i];                                                                      ///////////////////////////////////////////////
    }                                                                                     ///////////////////////////////////////////////
   
    for(i=0; i<n; i++)                                                                  ///////////////////////////////////////////////
        d[i] = hesapD(l, b, n, i);                                                       //// D matrisi hesaplanıyor //////////////////
   
    for(i=0; i<n; i++) {                                                              ////////////////////////////////////////////////
        x[i] = hesapX(l, b, d, n, i);                                                 ///// X matrisi hesaplanıyor ///////////////////
        cout << "X" << i+1 << " = " << x[i] << endl;                                ///// ve ekrana yazdırılıyor. //////////////////
    }
   
    system("PAUSE");
    return 0;
}

Hesaplamaların yapılabilmesi için aşağıdaki header dosyasını da programın yanında derlemelisiniz veya "hesaplama.h" taki tüm kodları main.cpp 'ye geçirip prototipleri ekleyerek çalıştırabilirsiniz.

#include <math.h>
#include <iostream>
using namespace::std;

double hesapL(double **A, int j, int i, int n) {   //l[j][i] ile lkk ve lki hesaplamak için kullanılan algoritma
    double **a = A;                               // Gelen a matrisi ile bu fonksiyon işaretçisi ile bu fonksiyonda tanımladığımız a matrisi eşleştiriliyor.
    double gecici=0, toplam=0;                    // Gerekli değişkenler
    int z, e;
   
    if( j == i ) {                             // l[k][k] denklemi ve aynı indisli olan l değerlerinin hesaplanması
        for(e=0; e<j; e++) {                 // Formüldeki toplam sembolünün yapılması
            gecici = hesapL(a, j, e, n);
            gecici = pow(gecici, 2);
            toplam = toplam + gecici;       //Toplam sembolünden elde edilecek sonuç "toplam" değişkenine aktarılıyor.
        }
       
       
        toplam = a[j][i] - toplam;         // Ardından formüldeki diğer işlemler yapılıyor.
        toplam = sqrt(toplam);
        return toplam;
    }
    else if( j != i ) {                    // l[k][i] formülü ile lki biçimindeki fonksiyonun tanıtılması
        for(z = 0; z < i; z++) {           // Formülde kullanılan toplam sembolü
            gecici = hesapL(a, i, z, n) * hesapL(a, j, z, n);
            toplam = gecici + toplam;      // Toplam sembolünden elde edilecek sonuç "toplam" değişkenine aktarılıyor.
        }
       
        toplam = a[j][i] - toplam;
        toplam = toplam / hesapL(a, i, i, n);
        return toplam;
    }
   
   
   
}

double hesapD(double **L, double *B,  int n, int i) {        // d[i] hesaplanması için kullanılan formül
    double **l = L;                                            // Matris işaretçileri eşleştiriliyor
    double *b = B;
    double toplam=0, gecici;
    int j;
    if(i == 0) {                                           // d[0] için kullanılan formül
        toplam = b[0] / l[0][0];
        return toplam;
     }
     else if(i != 0){                                       // İndis 0 olmadığında kullanılan formül
             for(j=0; j<i; j++) {                           //Formüldeki toplam sembolünü
            gecici = l[i][j] * hesapD(l, b, n, j);
            toplam = toplam + gecici;
        }
        toplam = b[i] - toplam;
        toplam = toplam / l[i][i];
        return toplam;
    }
   
}

double hesapX(double **L, double *B, double *D, int n, int i) {    // x[i] köklerinin hesaplanması için kullanılan fonksiyon
    double **l = L;                                               //Matris işaretçileri eşleştiriliyor
    double *b = B;
    double *d = D;
    int j;
    double gecici, toplam=0;
    if(i == (n-1)) {                                           //x[n] için kullanılan formül
        return (d[n-1] / l[n-1][n-1]);
    }
    else if( i != (n-1)){                                     // i != n durumunda kullanılacak formül
        for(j=i+1; j<=n-1; j++) {                                //Formüldeki toplam sembolü
            gecici = l[j][i] * hesapX(l, b, d, n, j);
            toplam = toplam + gecici;                            //Toplam sembolünden gelecek sonuç hesaplanıyor
        }
        toplam = d[i] - toplam;
        toplam = toplam / l[i][i];
        return toplam;
    }
   
}


// Bitiş

Cholesky Yönteminin nasıl hesaplandığını bilmiyorsanız:

​

Kaynak: https://drive.google.com/open?id=1rMDcszngIoPI4-9NcvPZA8wPAbEN8iYU