x030.h

Go to the documentation of this file.

#pragma once

#include "xmatrix.h"
#include "xvector.h"
#include <gsl/gsl_matrix.h>
#include <iomanip>
#include <iostream>

namespace nmx::apps::x030 {

inline void ex1() {
    //Spalten und Reihen der Matrix
    const size_t nrows = 4, nclmns = 4;

    //reserviere Speicher für die Matrix
    gsl_matrix *m = gsl_matrix_alloc(nrows, nclmns);

    //Initialisierung der Elemente
    for (size_t i = 0; i < nrows; i++) {
        for (size_t j = 0; j < nclmns; j++) {
            gsl_matrix_set(m, i, j, std::pow(sin(i + j), 2));
        }
    }
    //Ausgabe der Matrix auf dem Bildschirm
    std::cout << std::setprecision(10) << std::scientific;
    for (size_t i = 0; i < nrows; i++) {
        for (size_t j = 0; j < nclmns; j++) {
            std::cout << std::setw(10) //
                      << gsl_matrix_get(m, i, j) << "\t";
        }
        std::cout << "\n";
    }

    //vertausche Reihen 2 und 3
    gsl_matrix_swap_rows(m, 2, 3);

    //Ausgabe der geänderten Matrix auf dem Bildschirm
    std::cout << "--------------------" << std::endl;
    for (size_t i = 0; i < nrows; i++) {
        for (size_t j = 0; j < nclmns; j++) {
            std::cout << std::setw(10) //
                      << gsl_matrix_get(m, i, j) << "\t";
        }
        std::cout << "\n";
    }

    //Freigabe des Speichers
    gsl_matrix_free(m);
}

inline void ex2() {
    //Spalten und Reihen der Matrix
    const size_t nrows = 4, nclmns = 4;

    //statisches C-Feld
    double data[16];

    //eine Sicht auf das C-Feld. Die Daten werden als Matrix verwaltet
    gsl_matrix_view m = gsl_matrix_view_array(data, nrows, nclmns);

    //Initialisierung der Elemente
    for (size_t i = 0; i < nrows; i++) {
        for (size_t j = 0; j < nclmns; j++) {
            gsl_matrix_set(&m.matrix, i, j, std::pow(sin(i + j), 2));
        }
    }

    //Ausgabe der geänderten Matrix auf dem Bildschirm
    std::cout << std::setprecision(10) << std::scientific;
    for (size_t i = 0; i < nrows; i++) {
        for (size_t j = 0; j < nclmns; j++) {
            std::cout << std::setw(10) //
                      << gsl_matrix_get(&m.matrix, i, j) << "\t";
        }
        std::cout << "\n";
    }

    std::cout << "--------------------" << std::endl;

    //vertausche Reihen 2 und 3
    gsl_matrix_swap_rows(&m.matrix, 2, 3);

    //Ausgabe der geänderten Matrix auf dem Bildschirm
    for (size_t i = 0; i < nrows; i++) {
        for (size_t j = 0; j < nclmns; j++) {
            std::cout << std::setw(10) << //
                gsl_matrix_get(&m.matrix, i, j) << "\t";
        }
        std::cout << "\n";
    }
}

inline void ex3() {
    gsl::Matrix m{ { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
    gsl::Vector v{ 1, 2, 3 };
    auto vout = dot(m, v);
    std::cout << m << std::endl;
    std::cout << v << std::endl;
    std::cout << vout << std::endl;
    auto mout = dot(m, m);
    std::cout << mout << std::endl;
}

inline auto get_output_stream(const char *name, Format fmt = Output::csv) {
    auto ofs = Output::get_stream("x030", fmt, name);
    fmt.set_defaults(ofs);
    return ofs;
}

inline void mat1() {
    std::ofstream ofs = get_output_stream(__func__);
    const size_t rows = 2, columns = 2;
    //erzeuge eine 2x2 Matrix und setze alle Elemente gleich 5
    gsl::Matrix m(2, 2, 5.0);
    //schreibe Matrix in Datei
    for (size_t i = 0; i < rows; i++) {
        for (size_t j = 0; j < columns; j++) {
            ofs << m(i, j) << "\t";
        }
        ofs << std::endl;
    }
}

inline void mat2() {
    std::ofstream ofs = get_output_stream(__func__);
    constexpr size_t rows = 3, columns = 3;
    //die zu kopierende Daten
    double f[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    //Erzeuge eine 3x3 Sicht (Matrix) auf die Daten
    gsl::Matrix::View m{ 3, 3, f };
    //schreibe Matrix in Datei
    for (size_t i = 0; i < rows; i++) {
        for (size_t j = 0; j < columns; j++) {
            ofs << m(i, j) << "\t";
        }
        ofs << std::endl;
    }
}

inline void mat3() {
    std::ofstream ofs = get_output_stream(__func__);
    //drei Vektoren ergeben folgende 3x3-Matrix
    gsl::Matrix m{ { 1, 2, 3 }, { 10, 20, 30 }, { 100, 200, 300 } };
    ofs << m;
}

inline void mat4() {
    std::ofstream ofs = get_output_stream(__func__);
    //erzeuge eine 3x3 Matrix
    gsl::Matrix m1{ { 1, 2, 3 }, { 10, 20, 30 }, { 100, 200, 300 } };
    //schreibe Matrix in Datei
    ofs << m1;
    //kopiere m1
    gsl::Matrix m2{ m1 };
    ofs << "---------------------" << std::endl << m2;
}

inline void mat5() {
    std::ofstream ofs = get_output_stream(__func__);
    //erzeuge 3x3 Matrix
    gsl::Matrix m1{ { 1, 2, 3 }, { 10, 20, 30 }, { 100, 200, 300 } };
    ofs << m1;
    //übertrage Inhalt der Matrix
    gsl::Matrix m2 = std::move(m1);
    ofs << "---------------------" << std::endl;
    if (m1.empty()) {
        ofs << "m1 is empty" << std::endl;
    } else {
        ofs << "m1 is not empty" << std::endl;
    }
    ofs << "---------------------" << std::endl << m2;
}

inline void mat6() {
    std::ofstream ofs = get_output_stream(__func__);
    ofs << std::fixed << std::setprecision(2);

    //lambda Funktion zum schreiben der Daten in eine Datei
    auto print = [&ofs](const char *txt, const gsl::Matrix &m) {
        ofs << "--------" << txt << "----------" << std::endl;
        ofs << m;
    };

    gsl::Matrix m1{ { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
    print("m1", m1);
    gsl::Matrix m2{ { 10, 20, 30 }, { 40, 50, 60 }, { 70, 80, 90 } };
    print("m2", m2);

    //vertausche Matrizen
    gsl::Matrix tmp = m2;
    m2 = m1;
    m1 = tmp;

    //Ausgabe
    print("m1", m1);
    print("m2", m2);
}

inline void mat7() {
    using Matrix = gsl::Matrix;
    std::ofstream ofs = get_output_stream(__func__);
    ofs << std::fixed << std::setprecision(2);

    Matrix m1{ { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
    ofs << "----------m1-----------" << std::endl;
    m1.save(ofs);

    Matrix m2{ { 10, 20, 30 }, { 40, 50, 60 }, { 70, 80, 90 } };
    ofs << "----------m2----------" << std::endl;
    m2.save(ofs);

    gsl::Matrix tmp = std::move(m1);
    m1 = std::move(m2);
    m2 = std::move(tmp);

    ofs << "----------m1-----------" << std::endl << m1;
    ofs << "----------m2----------" << std::endl << m2;
    std::swap(m1, m2);
    ofs << "----------m1-----------" << std::endl << m1;
    ofs << "----------m2----------" << std::endl << m2;
}

inline void mat8() {
    std::ofstream ofs = get_output_stream(__func__);
    ofs << std::fixed << std::setprecision(2);

    gsl::Matrix m{ 3, 3 };
    gsl_matrix_set_identity(m.gsl());

    for (size_t i = 0; i < m.gsl()->size1; i++) {
        for (size_t j = 0; j < m.gsl()->size2; j++) {
            ofs << gsl_matrix_get(m.gsl(), i, j) //
                << Output::csv.sep();
        }
        ofs << Output::csv.lend();
    }
}

inline void mat9() {
    std::ofstream ofs = get_output_stream(__func__);
    //erzeuge Einheitsmatrix
    gsl::Matrix m = gsl::Matrix::identity(3);

    ofs << "---------------------" << std::endl << m;
    //verändere Elemente
    m(2, 2) = 22;
    m(1, 2) = 12;
    ofs << "---------------------" << std::endl << m;
}

inline void mat10() {
    std::ofstream ofs = get_output_stream(__func__);
    ofs << std::scientific << std::setprecision(2);
    //erzeuge Matrix
    gsl::Matrix m{ { 0, 20, 129, 3, 300 }, //
                   { 311, 0, 40, -1, -600 },
                   { -100, 3, 0, 5, 123 },
                   { -10, -342, -90, 1 } };

    ofs << m << "---------------\n";
    //suche Reihe und Spalte des kleinsten Elements
    auto [imin, jmin] = m.min_index();
    ofs << "min:" << imin << "," << jmin << "," << m.min() << "\n";

    //suche Reihe und Spalte des größten Elements
    auto [imax, jmax] = m.max_index();
    ofs << "max:" << imax << "," << jmax << "," << m.max() << "\n";
}

inline void mat11() {
    std::ofstream ofs = get_output_stream(__func__);
    ofs << std::fixed << std::setprecision(2);

    gsl::Matrix m1{ { 1, 2, 3 }, { 5, 6, 7 }, { 8, 9, 10 } };
    ofs << "---------- m ----------" << std::endl << m1;

    gsl::Matrix m2 = m1 + m1;
    ofs << "----------- m1+m1 ---------" << std::endl << m2;

    gsl::Matrix m3 = m1 - m1;
    ofs << "----------- m1-m1 --------" << std::endl << m3;
}

inline void mat12() {
    std::ofstream ofs = get_output_stream(__func__);
    ofs << std::fixed << std::setprecision(2);

    //erzeuge Matrix
    gsl::Matrix m1{ { 1, 2, 3 }, { 5, 6, 7 }, { 8, 9, 10 } };

    ofs << "---------------------" << std::endl << m1;
    //kopiere Matrix
    gsl::Matrix m2 = m1;

    //addiere zu allen Elemente eine Zahl
    m2 += 100.;
    ofs << "---------------------" << std::endl << m2;
}

inline void mat13() {
    using Matrix = gsl::Matrix;
    std::ofstream ofs = get_output_stream(__func__);
    //erzeuge Matrizen
    Matrix m1{ { 4, 3 }, { 1, 1 } }, m2{ { 1, -3 }, { -1, 4 } };

    //berechne Matrixprodukt
    Matrix m3 = dot(m1, m2);

    const char *sep = "---------------------";
    ofs << m1 << sep << "\n" << m2 << sep << "\n" << m3;
}

inline void mat14() {
    std::ofstream ofs = get_output_stream(__func__);
    //Koeffizientenmatrix
    gsl::Matrix m{ { 1, 3, -2 }, { 3, 5, 6 }, { 2, 4, 3 } };

    //Lösung und /rechte Seite des Gleichungssystems
    gsl::Vector x{ -15.0, 8.0, 2.0 }, b{ 5, 7, 8 };

    const char *sep = "---------------------";
    ofs << sep << std::endl << m << sep << std::endl << x;
    ofs << sep << std::endl << b;

    //multipliziere Koeffizientenmatrix mit Lösung
    gsl::Vector vSolution = dot(m, x);
    ofs << sep << std::endl << vSolution;
    ofs << std::boolalpha << (vSolution == b) << std::endl;
}

inline void mat15() {
    using Matrix = gsl::Matrix;
    std::ofstream ofs = get_output_stream(__func__);
    ofs << std::setprecision(8);
    //Drehung um x-Achse
    auto Dx = [](double phi) -> Matrix {
        return { { 1, 0, 0 }, //
                 { 0, cos(phi), -sin(phi) },
                 { 0, sin(phi), cos(phi) } };
    };
    //Drehung um y-Achse
    auto Dy = [](double phi) -> Matrix {
        return { { cos(phi), 0, -sin(phi) }, //
                 { 0, 1, 0 },
                 { sin(phi), 0, cos(phi) } };
    };
    //Drehung um z-Achse
    auto Dz = [](double phi) -> Matrix {
        return { { cos(phi), -sin(phi), 0 }, //
                 { sin(phi), cos(phi), 0 },
                 { 0, 0, 1 } };
    };
    //Drehmatrix
    Matrix D = { { 0.3536, -0.6124, -0.7071 },
                 { 0.5732, 0.7392, -0.3536 },
                 { 0.7392, -0.2803, 0.6124 } };
    //Winkel
    const auto phix = 30.0_deg;
    const auto phiy = 45.0_deg;
    const auto phiz = 60.0_deg;
    auto DxDyDz = dot(dot(Dx(phix), Dy(phiy)), Dz(phiz));

    //Prüfe ob Matrizen gleich sind (Vorsicht bei double-Zahlen)
    if (D == DxDyDz) {
        ofs << "true" << std::endl;
    } else {
        ofs << "false" << std::endl;
    }
    ofs << "----------------------------" << std::endl;
    //speichere Drehmatrix und Produkt  der Drehmatrizen in Datei
    D.save(ofs);
    ofs << "----------------------------" << std::endl;
    DxDyDz.save(ofs);
    //Berechne Differenz
    Matrix D1 = DxDyDz - D;
    ofs << "----------------------------" << std::endl;
    D1.save(ofs);
}

inline void mat16() {
    using Matrix = gsl::Matrix;
    std::ofstream ofs = get_output_stream(__func__);
    Matrix m{ { 2, -1, 5, 10 }, { 1, 1, -3, -2 }, { 2, 4, 1, 1 } };
    ofs << m;

    //multipliziere Reihe 1 mit 2
    auto mr1 = 2 * m.row(1);
    //und ersetze Reihe 1 durch das Ergebnis
    m.set_row(mr1, 1);
    //Reihe 2 - Reihe 1
    auto mr2 = m.row(2) - m.row(1);
    //ersetze Reihe 2 durch das Ergebnis
    m.set_row(mr2, 2);
    //Reihe1 - Reihe 0
    mr1 = m.row(1) - m.row(0);
    //ersetze Reihe 1 durch das Ergebnis
    m.set_row(mr1, 1);

    const char *sep = "----------------------------";
    ofs << sep << std::endl << m;
    mr2 = 3 * m.row(2);
    m.set_row(mr2, 2);
    ofs << sep << std::endl << m;
    auto v = m.row(1);
    mr2 = m.row(2) - 2 * m.row(1);
    m.set_row(mr2, 2);
    ofs << sep << std::endl << m;
    mr2 = m.row(2) / 43;
    m.set_row(mr2, 2);
    ofs << sep << std::endl << m;
}

inline void mat17() {
    using Matrix = gsl::Matrix;
    using Vector = gsl::Vector;

    Matrix m{ { 2, -1, 5, 10 }, //
              { 1, 1, -3, -2 },
              { 2, 4, 1, 1 } };
    std::cout << m;

    Vector mr1 = 2.0 * m.row_view(1);
    std::cout << m;
}

inline void mat18() {
    using Matrix = gsl::Matrix;
    using Vector = gsl::Vector;

    Matrix m{ { 1, 7, 8 }, //
              { 4, 5, 3 },
              { 2, 9, 7 } };
    Vector x{ 1, 2, 3 };
    Vector y(x.size());

    dgemv(CblasNoTrans, 3, m, x, 0, y);
    std::cout << y;
}

inline void mat19() {
    using Matrix = gsl::Matrix;
    using Vector = gsl::Vector;

    Matrix m{ { 1, 7, 8 }, //
              { 4, 5, 3 },
              { 2, 9, 7 } };
    Vector x{ 1, 2, 3 };
    Vector y{ 3, 4, 6 };
    dgemv(CblasNoTrans, 3, m, x, 2, y);
    std::cout << y;
}

} // namespace nmx::apps::x030