x029.h

Go to the documentation of this file.

#pragma once

#include "xdata.h"
#include "xfmt.h"
#include "xmath.h"
#include "xoutput.h"
#include "xtools.h"
#include "xvector.h"
#include <forward_list>
#include <fstream>
#include <gsl/gsl_sf_trig.h>
#include <iostream>

namespace nmx::apps::x029 {

inline void ex0() {
    const size_t n = 5;
    // reserviere Speicher für Vektor
    gsl_vector *v = gsl_vector_alloc(n);
    //initialisiere Elemente
    for (size_t idx = 0; idx < n; idx++) {
        gsl_vector_set(v, idx, idx);
    }
    //schreibe Elemente auf dem Bildschirm
    for (size_t idx = 0; idx < n; idx++) {
        std::cout << gsl_vector_get(v, idx) << " ";
    }
    std::cout << " -> ";
    //vertausche Elemente mit Index 2 und 3
    gsl_vector_swap_elements(v, 2, 3);
    //schreibe Elemente auf dem Bildschirm
    for (size_t idx = 0; idx < n; idx++) {
        std::cout << gsl_vector_get(v, idx) << " ";
    }
    //Speicherfreigabe
    gsl_vector_free(v);
}

inline void ex00() {
    const size_t n = 5;
    // erzeuge C-Feld
    double data[] = { 0, 1, 2, 3, 4 };

    //erzeuge Sicht auf C-Feld
    gsl_vector_view v = gsl_vector_view_array(data, n);

    //schreibe Elemente auf dem Bildschirm
    for (size_t idx = 0; idx < n; idx++) {
        std::cout << gsl_vector_get(&v.vector, idx) << "\t";
    }
    std::cout << std::endl;
    //vertausche Elemente mit Index 2 und 3
    gsl_vector_swap_elements(&v.vector, 2, 3);

    //schreibe Elemente auf dem Bildschirm
    for (size_t idx = 0; idx < n; idx++) {
        std::cout << gsl_vector_get(&v.vector, idx) << "\t";
    }
    std::cout << std::endl;
}

inline void ex1() {
    const size_t n = 3;
    //erzeuge Vektor mit 3 Elementen
    gsl_vector *v = gsl_vector_alloc(n);

    //Elemente werden initialisiert
    for (size_t idx = 0; idx < n; idx++) {
        gsl_vector_set(v, idx, idx);
    }

    //Vektor wird auf dem Bildschirm geschrieben
    for (size_t idx = 0; idx < n; idx++) {
        std::cout << gsl_vector_get(v, idx) << "\t";
    }
    std::cout << std::endl;

    //zu allen Elementen wird eine Zahl addiert
    gsl_vector_add_constant(v, 10);
    //alle Elemente werden mit einer Zahl multipliziert
    gsl_vector_scale(v, 10);

    //der Vektor wird auf dem Bildschirm geschrieben
    for (size_t idx = 0; idx < n; idx++) {
        std::cout << gsl_vector_get(v, idx) << "\t";
    }
    std::cout << std::endl;

    //erzeuge C-Feld
    double f[] = { -10, -20, -30 };

    gsl_vector_view view = gsl_vector_view_array(f, n);

    //zu den Elemente des Vektors werden die Elemente
    // des C-Feldes addiert
    gsl_vector_add(v, &view.vector);

    //der Vektor wird auf dem Bildschirm geschrieben
    for (size_t idx = 0; idx < n; idx++) {
        std::cout << gsl_vector_get(v, idx) << "\t";
    }

    std::cout << std::endl;
    //Freigabe des Speichers
    gsl_vector_free(v);
}

static inline std::ofstream get_output_stream(const std::string &name,
                                              const Format &fmt = Output::csv) {
    return Output::get_stream("x029", fmt, name);
}

inline void vec0() {
    using Vector = gsl::Vector;
    std::ofstream ofs = get_output_stream(__func__);
    ofs << std::fixed;
    //erzeuge Vektor aus einer Liste von Zahlen
    Vector v1{ 1.0, 2.0, 3.0 };
    ofs << v1;
    //erzeuge zweiten Vektor aus einer Liste von Zahlen
    Vector v2{ 2, 3, 4 };
    ofs << v2;
    //Kopierkonstruktor v3 = v1
    gsl::Vector v3{ v1 };
    ofs << v3;
    v3 = v2;
    ofs << v3;
    //erzeuge Vektor mit C-Array
    double f[] = { 10, 20, 30 };
    Vector::View v4(3, f);
    ofs << v4;
}

inline void vec11() {
    using namespace gsl;
    //öffne Ausgabestrom
    std::ofstream ofs = get_output_stream(__func__);
    ofs << std::fixed;
    //erzeuge Vektor und schreibe ihn in die Datei
    Vector v1{ 1, 2, 3, 4 };
    ofs << v1;
    //übertrage Inhalt
    Vector v2 = std::move(v1);

    if (v1.empty()) {
        ofs << "v1 is empty" << std::endl;
    } else {
        ofs << v1;
    }
    ofs << v2;
}

inline void vec1() {
    using Vector = gsl::Vector;
    std::ofstream ofs = get_output_stream(__func__);
    ofs << std::fixed;

    //erzeuge Vektor aus einer Liste von Zahlen
    Vector v1(10);
    for (size_t idx = 0; idx < v1.size(); idx++) {
        v1[idx] = idx;
    }
    ofs << v1;
    //view auf Vektor beginnend ab der Stelle 3 und
    //insgesamt 4 Elementen
    auto view = v1.view(3, 4);
    ofs << view;
    //view auf Vektor beginnend ab der Stelle 3 und
    //insgesamt 4 Elementen und Schrittweite 2
    auto view1 = v1.view(3, 2, 4);
    ofs << view1;
}

inline void vec2() {
    using Vector = gsl::Vector;
    std::ofstream ofs = get_output_stream(__func__);
    ofs << std::fixed << std::setprecision(2);
    //erzeuge Nullvektor
    Vector v1(4);
    ofs << v1;

    //die Elemente erhalten die Werte 0,1,2,3
    v1.transform([](double x) {
        (void) x;
        double static val = 0;
        return val++;
    });
    ofs << v1;

    //berechne den sin der Elemente von v1 und speichere diese in v2
    Vector v2 = apply([](double x) { return sin(x); }, v1);
    ofs << v2;
    Vector v3 = apply([](double x) { return cos(x); }, v1);
    ofs << v3;

    auto fn = [](double x, double y) { //
        return std::pow(x, 2) + std::pow(y, 2);
    };
    Vector v4 = apply(fn, v2, v3);
    ofs << v4;

    auto fn1 = [](double x, double y) { //
        return std::pow(cos(x), 2) + std::pow(sin(y), 2);
    };
    Vector v5 = apply(fn1, v1, v1);
    ofs << v5;
}

inline void vec5() {
    using gsl::Vector;
    std::ofstream ofs = get_output_stream(__func__);
    constexpr size_t dim = 6;
    gsl::Vector v(dim);
    //Vektor wird gefüllt
    for (size_t idx = 0; idx < dim; idx++) {
        v[idx] = sin(idx + 1) / (idx + 1);
    }
    //Suche nach Minimum Maximum mit Schleife
    double maxelement = v[0], minelement = v[0];
    for (size_t jdx = 0; jdx < dim; jdx++) {
        const double jelement = v[jdx];
        maxelement = std::max(maxelement, jelement);
        minelement = std::min(minelement, jelement);
    }
    //Suche nach Minimum Maximum mit stl
    auto imaxlement = std::max_element(std::begin(v), //
                                       std::end(v));
    auto iminlement = std::min_element(std::begin(v), //
                                       std::end(v));
    //Ergebnisse
    ofs << v;
    ofs << "max loop:" << maxelement << std::endl;
    ofs << "min loop:" << minelement << std::endl;
    ofs << "max method:" << v.max() << std::endl;
    ofs << "min method:" << v.min() << std::endl;
    ofs << "max stl:" << *imaxlement << std::endl;
    ofs << "min stl:" << *iminlement << std::endl;
}

inline void vec6() {
    using gsl::Vector;
    std::ofstream ofs = get_output_stream(__func__);
    const gsl::Vector r0{ 3, 1 };
    const gsl::Vector r1{ -1, 6 };

    //Funktion Parameterform
    auto paramForm = [r0, r1](double l) { return r0 + l * (r1 - r0); };

    const double l1 = 1, l2 = 2;
    const auto v1 = paramForm(l1);
    const auto v2 = paramForm(l2);

    //Ausgabe
    ofs << r0 << r1;
    ofs << "lambda 1=" << l1 << std::endl;
    ofs << v1;
    ofs << "lambda 2=" << l2 << std::endl;
    ofs << v2;
}

inline void vec3() {
    using Vector = gsl::Vector;
    std::ofstream ofs = get_output_stream(__func__);
    Format fmt{ ",", "\t" };
    ofs << fmt << std::fixed;

    const Vector a{ 3, 5 };
    const Vector b{ 4, -2 };
    auto v1 = a + b, v2 = a - b, v3 = 2 * a, v4 = -a;
    ofs << a << b << v1 << std::endl << v2 << v3 << v4 << std::endl;

    //teste Dreiecksungleichungen
    if (nrm2(v1) <= abs(nrm2(v1)) + abs(nrm2(v2))) {
        ofs << "true, ";
    } else {
        ofs << "false, ";
    }
    if (nrm2(v2) >= abs(abs(nrm2(v1)) - abs(nrm2(v2)))) {
        ofs << "true" << std::endl;
    } else {
        ofs << "false" << std::endl;
    }
}

inline void vec4() {
    using Vector = gsl::Vector;

    std::ofstream ofs = get_output_stream(__func__);
    const Vector c{ 5, 2 };
    const Vector d{ -1, 6 };

    const double n1 = pow(nrm2(c), 2);
    const double n2 = pow(nrm2(d), 2);
    const double cdotd = dot(c, d);
    const double cosphi = cdotd / (nrm2(c) * nrm2(d));

    ofs << c << d;
    ofs << "n1=" << n1 << ","
        << "n2=" << n2 << ","
        << "cdotd=" << cdotd << ","
        << "cos(phi)=" << cosphi << std::endl;
}

gsl::Vector cross_product(const gsl::Vector &v1, const gsl::Vector &v2) {
    gsl::Vector vout(3);
    vout[0] = v1[1] * v2[2] - v1[2] * v2[1];
    vout[1] = v1[0] * v2[2] - v1[2] * v2[0];
    vout[2] = v1[0] * v2[1] - v1[1] * v2[0];
    return vout;
}

inline void vec7() {
    using gsl::Vector;
    std::ofstream ofs = get_output_stream(__func__);

    const gsl::Vector a{ 3, -1, 2 }, b{ 2, 3, -1 };

    //berechne Kreuzprodukt
    const auto c = cross_product(a, b);

    //Ausgabe
    ofs << a << b;
    ofs << "c = a x b=" << c;
}

inline void vec8() {
    using Vector = gsl::Vector;
    std::ofstream ofs = get_output_stream(__func__);
    const Vector r{ 5, -5, 0 }, f{ 2, 3, 0 };
    const auto tau = cross_product(r, f);
    ofs << r << f;
    ofs << "tau = r x f=" << tau;
}

inline void vec9() {
    using gsl::Vector;
    std::ofstream ofs = get_output_stream(__func__);
    const double mass = 100.0_g;
    const double t = 1.0;

    //Geschwindigkeits- und Ortsvektor
    const gsl::Vector v{ 0, 0, -9.81 * t };
    const gsl::Vector r{ 0, 10.0, 30.0 - 4.905 * pow(t, 2) };

    const auto p = mass * v;
    const auto L = cross_product(r, p);
    ofs << r << p << L;
}

inline void vec10() {
    using gsl::Vector;
    std::ofstream ofs = get_output_stream(__func__);

    //erzeuge Nullvektor
    gsl::Vector v1{ 1.0, 2.0, 3.0, 4.0 };
    ofs << v1;
    Vector v2 = apply([](double x) { return sin(x); }, v1);
    ofs << v2;
    Vector v3 = apply([](double x) { return cos(x); }, v1);
    ofs << v3;
    Vector v4 = apply([](double x, double y) { return pow(x, 2) + pow(y, 2); }, v2, v3);
    ofs << v4;

    //gebe die Elemente von v4 mit einem range-based loop aus
    for (const auto &x : v4) {
        ofs << x << ",";
    }
    ofs << std::endl;

    //berechne die Summe der Elemente von v4
    auto sum = std::accumulate(std::begin(v4), std::end(v4), 0);
    ofs << "sum =" << sum << std::endl;
}

inline void vec12() {
    //alle Kräfte werden in einem std::array gespeichert
    std::array<gsl::Vector, 7> forces;
    forces[0] = { 0, -3 };
    forces[1] = { 20, -10 };
    forces[2] = { 1, 20 };
    forces[3] = { 10, 0 };
    forces[4] = { 5, 5 };
    forces[5] = { -10, -10 };
    forces[6] = { 0, 0 };

    //die Summe der Kräfte wird berechnet
    for (size_t idx = 0; idx < 6; idx++) {
        forces[6] += forces[idx];
    }

    //Darstellung der Daten im LaTeX-Format
    const auto [sep, lend] = Output::latex();
    std::ofstream ofs = get_output_stream(__func__, Output::latex);
    ofs << std::fixed << std::setprecision(2);
    for (size_t idx = 0; idx < 2; idx++) {
        idx == 0 ? ofs << "$x$" : ofs << "$y$";
        for (size_t jdx = 0; jdx < 7; jdx++) {
            ofs << " " << sep << forces[jdx][idx];
        }
        ofs << lend;
    }
}

inline void vec13() {
    //Umrechnung von Polarkoordinaten in kartesischen Koordinaten
    auto polar_to_rect = [](double r, double phi) {
        gsl_sf_result x, y;
        gsl_sf_polar_to_rect(r, phi, &x, &y);
        return gsl::Vector({ x.val, y.val });
    };

    //Umrechnung von kartesischen Koordinaten in Polarkoordinaten
    auto rect_to_polar = [](double x, double y) {
        gsl_sf_result r, phi;
        gsl_sf_rect_to_polar(x, y, &r, &phi);
        return gsl::Vector({ r.val, phi.val });
    };

    //die Kräfte werden in einem std::array gespeichert
    std::array<gsl::Vector, 4> forces;
    forces[0] = polar_to_rect(80.0, 40.0_deg);
    forces[1] = polar_to_rect(120.0, 70.0_deg);
    forces[2] = polar_to_rect(150.0, 145.0_deg);
    forces[3] = forces[0] + forces[1] + forces[2]; //die Gesamtkraft

    //die Daten werden im LaTeX-Format gespeichert
    std::ofstream ofs = get_output_stream(__func__, Output::latex);
    ofs << std::setprecision(2) << std::fixed;
    const auto [sep, lend] = Output::latex();
    for (size_t idx = 0; idx < 4; idx++) {
        const auto x = forces[idx][0], y = forces[idx][1];
        const auto polar = rect_to_polar(x, y);
        ofs << idx << sep << x << sep << y << sep //
            << polar[0] << sep << Math::to_degrees(polar[1]) << lend;
    }
}

} // namespace nmx::apps::x029