xlu.h

Go to the documentation of this file.

#pragma once

#include "xmatrix.h"

namespace nmx::gsl {

class LU_Decomposition
{
public:
    using Matrix = gsl::Matrix;
    using Vector = gsl::Vector;

private:
    //linke Seite des Gleichungssystems
    Matrix _left;
    //rechte Seite des Gleichungssystems
    Vector _right;
    // Lösungsvektor
    Vector _solution;

public:
    //Reihen- und Zeilenvertauschung (gsl)
    gsl_permutation *_permutation;
    // (-1)^n Anzahl der Vertauschungen (gsl)
    int _permutation_sign;

public:
    inline LU_Decomposition() {}

    inline LU_Decomposition(const Matrix &m, const Vector &v)
        : _left{ m }
        , _right{ v }
        , _solution(_right.size()) {}

    inline ~LU_Decomposition() {
        if (_permutation != nullptr) {
            //gsl-Struktur wird freigegeben
            gsl_permutation_free(_permutation);
        }
    }

    inline void set_left(const Matrix &m) { _left = m; }

    inline void set_right(const Vector &v) { _right = v; }

    inline const Matrix &get_left() const { return _left; }

    const Vector &get_right() const { return _right; }

    inline double operator()(size_t idx) const { //
        return _solution[idx];
    }

    inline double operator()(size_t i, size_t j) const { //
        return _left(i, j);
    }

    inline void decompose() {
        _permutation = gsl_permutation_alloc(std::min(_left.rows(), //
                                                      _left.columns()));
        gsl_linalg_LU_decomp(_left.gsl(),
                             _permutation, //
                             &_permutation_sign);
    }

    inline void solve() {
        //zerlege Koeffizientenmatrix in obere und untere Dreiecksmatrix
        decompose();
        //Lösungsvektor muss die gleiche Länge haben wie die
        //rechte Seite
        if (_solution.size() != _right.size()) {
            _solution = Vector(_right.size());
        }
        //löse das Gleichungssystem
        gsl_linalg_LU_solve(_left.gsl(), //
                            _permutation,
                            _right.gsl(),
                            _solution.gsl());
    }

    inline void solve(const Matrix &m, const Vector &v) {
        set_left(m);
        set_right(v);
        solve();
    }

    inline const Vector &solution() const { return _solution; }

    inline Matrix lower_matrix() const {
        //reserviere Speicher fur das Ergebnis
        Matrix mout(_left.rows(), _left.columns());

        for (size_t i = 0; i < _left.rows(); i++) {
            for (size_t j = 0; j < _left.columns(); j++) {
                if (i < j) {
                    mout(i, j) = 0;
                } else if (i == j) {
                    mout(i, j) = 1.0; //diagonale
                } else
                    mout(i, j) = _left(i, j);
            }
        }

        return mout;
    }

    inline Matrix upper_matrix() const {
        //reserviere Speicher fur das Ergebnis
        Matrix mout(_left.rows(), _left.columns());

        for (size_t i = 0; i < _left.rows(); i++) {
            for (size_t j = 0; j < _left.columns(); j++) {
                if (i > j) {
                    mout(i, j) = 0;
                } else
                    mout(i, j) = _left(i, j);
            }
        }

        return mout;
    }

    inline Matrix permutation_matrix() {
        //Anzahl der Elemente der Permutation
        size_t psize = static_cast<size_t>(_permutation->size);

        Matrix pMatrix(_left.rows(), _left.columns());
        for (size_t idx = 0; idx < psize; idx++) {
            //für jede Reihe gebe die Position des Elements,
            //welches 1 ist
            size_t pIdx = gsl_permutation_get(_permutation, idx);
            pMatrix(idx, pIdx) = 1;
        }
        return pMatrix;
    }

    inline static double det(const Matrix &m) {
        LU_Decomposition lu;
        lu._left = m;
        //LU-Zerlegung der Matrix
        lu.decompose();
        //Berechnung der Determinante
        return gsl_linalg_LU_det(lu._left.gsl(), lu._permutation_sign);
    }

    inline static Matrix inverse(const Matrix &m) {
        //reserviere Speicher für die Inverse Matrix
        Matrix mInverse(m.rows(), m.columns());
        LU_Decomposition lu;
        lu._left = m;
        //LU-Zerlegung der Matrix
        lu.decompose();
        //Berechnung der Inversen Matrix
        gsl_linalg_LU_invert(lu.get_left().gsl(), //
                             lu._permutation,
                             mInverse.gsl());
        return mInverse;
    }

    inline Vector permutation_vector() const {
        //erzeuge Vektor für die Elemente der Permutation
        gsl::Vector vec(_permutation->size);

        for (size_t idx = 0; idx < vec.size(); idx++) {
            vec[idx] = gsl_permutation_get(_permutation, idx);
        }
        return vec;
    }
};

} // namespace nmx::gsl