x038.h

Go to the documentation of this file.

#pragma once

#include "xlu.h"
#include "xmatrix.h"

namespace nmx::apps::x038 {

using LU = gsl::LU_Decomposition;
using Matrix = LU::Matrix;
using Vector = LU::Vector;

inline auto get_output_stream(const char *name, Format fmt = Output::csv) {
    auto ofs = Output::get_stream("x038", fmt, name);
    ofs << std::fixed << std::setprecision(2);
    return ofs;
}

inline void lu1() {
    //öffne Ausgabestrom
    std::ofstream ofs = get_output_stream(__func__);

    //Koeffizientenmatrix
    Matrix left{ { { 3, -0.1, -0.2 }, //
                   { 0.1, 7, -0.3 },
                   { 0.3, -0.2, 10 } } };

    //rechte Seite des Gleichungssystems
    Vector right{ 7.85, -19.3, 71.4 };

    //Berechnung der Lösung
    LU lusolver{ left, right };
    lusolver.solve();
    const char *sep = "---------------------\n";

    auto mupper = lusolver.upper_matrix();
    auto mlower = lusolver.lower_matrix();
    auto pmatrix = lusolver.permutation_matrix();
    auto pdotleft = dot(pmatrix, left);
    auto ldotu = dot(lusolver.lower_matrix(), lusolver.upper_matrix());

    //schreibe Ergebnisse in Datei
    ofs << left << sep << right << sep << lusolver.solution();
    ofs << sep << lusolver.get_left();
    ofs << sep << mupper << sep << mlower << sep << pmatrix;
    ofs << sep << pdotleft << sep << ldotu;
}

inline void lu2() {
    //die Cramer'sche Regel für x_i als lambda-Funktion
    auto cramer_i = [](size_t i, const Matrix &m, const Vector &v) {
        // Kopiere linke Seite des GL-Systems
        auto m1 = m;
        //ersetze i-te Spalte durch rechte Seite
        m1.set_column(v, i);
        //Determinante Nenner
        auto det = LU::det(m);
        //Determinante Zähler
        auto det1 = LU::det(m1);
        // Lösung x_i
        return det1 / det;
    };

    std::ofstream ofs = get_output_stream(__func__);
    Matrix left{ { { 3, -0.1, -0.2 }, //
                   { 0.1, 7, -0.3 },
                   { 0.3, -0.2, 10 } } };
    Vector right{ 7.85, -19.3, 71.4 };

    //der Lösungsvektor
    const size_t N = right.size();
    Vector solution(N);
    for (size_t i = 0; i < N; i++) {
        solution[i] = cramer_i(i, left, right);
    }
    const char *sep = "---------------------\n";
    //Ausgabe
    ofs << sep << left << sep << right << sep << solution;
}

inline void lu3() {
    //erzeuge Ausgabestrom
    std::ofstream ofs = get_output_stream(__func__);

    //Koeffizientenmatrix
    Matrix left{ { { 3, -0.1, -0.2 }, //
                   { 0.1, 7, -0.3 },
                   { 0.3, -0.2, 10 } } };

    //die rechte Seite des Gleichungssystems
    Vector right{ 7.85, -19.3, 71.4 };

    //Berechnung der inversen Koeffizientenmatrix
    Matrix leftinverse = LU::inverse(left);

    //Lösung
    Vector solution = dot(leftinverse, right);

    const char *sep = "---------------------\n";
    //Ausgabe
    ofs << sep << left << sep << right;
    ofs << sep << leftinverse << sep << solution;

    auto m = dot(leftinverse, left);
    ofs << sep << std::endl << m;
}

inline void lu0() {
    // die Koeffizientenmatrix A
    double a_data[] = { 0.18, 0.60, 0.57, 0.96, //
                        0.41, 0.24, 0.99, 0.58, //
                        0.14, 0.30, 0.97, 0.66, //
                        0.51, 0.13, 0.19, 0.85 };

    // die rechte Seite des Gleichungssystems b
    double b_data[] = { 1.0, 2.0, 3.0, 4.0 };

    // eine view auf das lineare Feld
    // ...kann wie eine gsl Matrix behandelt werden
    gsl_matrix_view m = gsl_matrix_view_array(a_data, 4, 4);

    // eine view auf die rechte Seite
    // kann wie ein gsl Vektor behandelt werden
    gsl_vector_view b = gsl_vector_view_array(b_data, 4);

    // der Lösungsvektor
    gsl_vector *x = gsl_vector_alloc(4);
    //speichere Informationen zur Erzeugung der
    //Permutationsmatrix
    gsl_permutation *p = gsl_permutation_alloc(4);

    // s = (-1)^n n die Anzahl der Vertauschungen
    int s;
    //LU-Zerlegung der Koeffizientenmatrix. Sie enthält nach der
    //Zerlegung die Daten der oberen und unteren Dreiecksmatrix
    gsl_linalg_LU_decomp(&m.matrix, p, &s);
    //Lösung des Gleichungssystems
    gsl_linalg_LU_solve(&m.matrix, p, &b.vector, x);
    //schreibe Lösungsvektor
    printf("x = \n");
    gsl_vector_fprintf(stdout, x, "%g");
    //gebe gsl-Resourcen frei
    gsl_permutation_free(p);
    gsl_vector_free(x);
}

inline void lu11() {
    //öffne Ausgabestrom
    std::ofstream ofs = get_output_stream(__func__);

    //Koeffizientenmatrix
    Matrix left{ { 0.18, 0.60, 0.57, 0.96 },
                 { 0.41, 0.24, 0.99, 0.58 },
                 { 0.14, 0.30, 0.97, 0.66 },
                 { 0.51, 0.13, 0.19, 0.85 } };

    //rechte Seite des Gleichungssystems
    Vector right{ -4.05205, -12.6056, 1.66091, 8.69377 };

    //Berechnung der Lösung
    LU lusolver{ left, right };
    lusolver.solve();
    const char *sep = "---------------------";
    ofs << sep << std::endl << left;
    ofs << sep << std::endl << right;
    ofs << sep << std::endl << lusolver.solution();
    ofs << sep << std::endl << lusolver.get_left();
    auto mupper = lusolver.upper_matrix();
    ofs << sep << std::endl << mupper;
    auto mlower = lusolver.lower_matrix();
    ofs << sep << std::endl << mlower;
    auto pmatrix = lusolver.permutation_matrix();
    ofs << sep << std::endl << pmatrix;
    ofs << sep << std::endl;
    ofs << lusolver.permutation_vector();
    ofs << sep << std::endl;
    ofs << dot(pmatrix, left) << std::endl;
    ofs << sep << std::endl;
    ofs << dot(lusolver.lower_matrix(), lusolver.upper_matrix()) << std::endl;
}

} // namespace nmx::apps::x038