x008.h

Go to the documentation of this file.

#pragma once

#include "xdefs.h"
#include "xmath.h"
#include <algorithm>
#include <array>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <optional>
#include <vector>

namespace nmx::apps::x008 {

inline void ex1() {
    //Synonym für std::vector
    using Array = std::vector<double>;
    //Winkelgeschwindigkeit und Radius
    const double omega = 0.5;
    const double R = 1.0;
    //Felder speichern
    //Radius, Bahngeschwindigkeit, Zentripetalbeschleunigung
    Array radii, velocities, accelerations;
    //Berechnung der Werte
    for (double r = 0.1; r < R; r += 0.2) {
        //Radius wird hinzugefügt
        radii.push_back(r);
        //berechne Bahngeschwindigkeit
        const double v = omega * r;
        //Wert wird hinzugefügt
        velocities.push_back(v);
        //berechne Zentripetalbeschleunigung
        const double a = pow(v, 2) / r;
        //Wert wird hinzugefügt
        accelerations.push_back(a);
    }
    // Ausgabe der Daten Trennzeichen ,
    for (size_t idx = 0; idx < radii.size(); idx++) {
        std::cout << radii[idx] << "," //
                  << velocities[idx] << "," //
                  << accelerations[idx] << std::endl; //
    }
    std::cout << "-------------------------------" << std::endl;
    // Ausgabe der Daten Trennzeichen ;
    for (size_t idx = 0; idx < radii.size(); idx++) {
        std::cout << radii[idx] << ";" //
                  << velocities[idx] << ";" //
                  << accelerations[idx] << std::endl; //
    }
}

inline void ex2() {
    using Array = std::vector<double>;
    const double omega = 0.5;
    const double R = 1.0;

    //Radius, Bahngeschwindigkeit, Zentripetalbeschleunigung
    Array radii, velocities, accelerations;

    //Rotationsgeschwindigkeit wird den lambda-Funktionen übergeben
    auto v = [omega](double r) { return omega * r; };
    auto a = [omega](double r) { return pow(omega, 2) * r; };

    //Funktion zur Ausgabe der drei Felder als Tabelle,
    //wenn nichts anderes angegeben, wird  ein Komma als
    //Trennzeichen benutzt
    auto print = [](const auto &v1,
                    const auto &v2, //
                    const auto &v3,
                    char sep = ',') {
        for (size_t idx = 0; idx < v1.size(); idx++) {
            std::cout << v1[idx] << sep //
                      << v2[idx] << sep //
                      << v3[idx] << std::endl;
        }
    };

    //Berechnung der Werte
    for (double r = 0.1; r < R; r += 0.2) {
        radii.push_back(r);
        velocities.push_back(v(r));
        accelerations.push_back(a(r));
    }

    //Ausgabe der berechneten Werte
    print(radii, velocities, accelerations);
    print(radii, velocities, accelerations, ';');
}

inline void ex3() {
    using Array = std::vector<double>;
    const double omega = 0.5;

    //Radius, Bahngeschwindigkeit, Zentripetalbeschleunigung
    Array radii, velocities, accelerations;
    //Startwert für anonyme lambda-Funktion
    double startval = -0.1;
    //generiere ein Feld mit fünf Werten beginnend mit 0.1
    std::generate_n(std::back_inserter(radii), 5, [&startval]() { //
        return startval += 0.2;
    });

    //Rotationsgeschwindigkeit wird den lambda-Funktionen übergeben
    auto v = [omega](double r) { return omega * r; };
    auto a = [omega](double r) { return pow(omega, 2) * r; };

    //fülle Feld mit den Werten für die Bahngeschwindigkeit
    std::transform(radii.begin(), radii.end(), std::back_inserter(velocities), v);

    //fülle Feld mit den Werten für die Zentripetalbeschleunigung
    std::transform(radii.begin(), radii.end(), std::back_inserter(accelerations), a);

    // variadische Funktion zur Ausgabe von beliebig vielen Feldern
    // als Tabelle, erstes Argument ist das Trennzeichen,
    //es folgen beliebig viele Felder
    auto print = [](char sep, const auto &v1, const auto &... v) {
        for (size_t idx = 0; idx < v1.size(); idx++) {
            std::cout << v1[idx];
            ((std::cout << sep << v[idx]), ...);
            std::cout << std::endl;
        }
    };

    //Ausgabe der berechneten Werte
    print(',', radii, velocities, accelerations);
    print(';', radii, velocities, accelerations);
}

inline void ex4() {
    //Tabelle als Feld von Feldern mit vier Spalten
    using Table = std::vector<std::array<double, 4>>;
    Table table;

    //Umlaufzeiten
    const double T1 = 20;
    const double T2 = 15;
    //Winkelgeschwindigkeiten
    const auto omega1 = 2 * Math::PI / T1;
    const auto omega2 = 2 * Math::PI / T2;

    //Erzeuge Daten
    for (double t = 0; t < T1; t += 0.001) {
        const double phi1 = omega1 * t;
        const double phi2 = omega2 * t;
        //Compiler ermittelt die Länge des Arrays
        //und den Datentypen der Elemente
        std::array vals = { t, phi1, phi2, phi2 - phi1 };
        table.push_back(vals);
    }

    //Formel für den exakten Wert (lambda-Funktion)
    auto exactfn = [omega1, omega2](double deltaphi) {
        return deltaphi / (omega2 - omega1); //
    };

    std::cout << std::fixed << std::setprecision(3);

    //starte Suche für Winkeldifferenzen
    for (auto n : { 10, 30, 60, 90 }) {
        //Umwandlung in rad
        const auto angle = Math::to_radians(n);
        double epsilon = 1e-6;
        Table::iterator fidx;
        do {
            // Vergleiche ob der Eintrag mit Index 3 (Winkeldifferenz)
            // in der Tabellenreihe mit der gesuchten Winkeldifferenz
            // übereinstimmt
            auto pfn = [angle, &epsilon](const auto &a) { //
                return std::abs(a[3] - angle) <= epsilon;
            };

            fidx = std::find_if(table.begin(), table.end(), pfn);
            if (fidx != table.end()) {
                //Suche war erfolgreich!
                break;
            }
        } while ((epsilon *= 10) < 1e-2);

        if (fidx != table.end()) { //prüfe ob der Wert gültig ist
            // Index, Zeit (Suche), Winkeldifferenz,  Zeit (exakt)
            auto row = (*fidx);
            std::cout << std::distance(table.begin(), fidx) //
                      << std::setw(8) << row[0] //
                      << std::setw(8) << Math::to_degrees(row[3]) //
                      << std::setw(8) << exactfn(angle) << std::endl;
        } else {
            //Wert wurde nicht gefunden
            std::cout << "time not found for angle:" //
                      << Math::to_degrees(angle) << std::endl;
        }
    }
}
inline void ex5() {
    //reserviere Speicher für 20 double Zahlen
    std::vector<double> v1(20);

    //fülle Vektor mit Zahlen 0,1,2,.... (insgesamt 20 Elemente)
    std::iota(std::begin(v1), std::end(v1), 0);

    //initialisiere zweiten Vektor
    std::vector<double> v2;

    //kopiere alle Elemente aus v1 mit x > 6
    //in den Zielvektor v2
    //lambda-Funktion wird direkt übergeben
    std::copy_if(std::begin(v1), //
                 std::end(v1),
                 std::back_inserter(v2),
                 [](double x) { return x > 6; });

    //lambda Hilfsfunktion, wird in Variable gespeichert
    auto print = [](double x) { std::cout << x << ","; };

    //schreibe jedes Element von v1 in die Standardausgabe
    std::for_each(std::begin(v1), std::end(v1), print);
    std::cout << std::endl;
    //schreibe jedes Element von v1 in die Standardausgabe
    std::for_each(std::begin(v2), std::end(v2), print);
    std::cout << std::endl;

    const double xmin = 10, xmax = 16;
    //finde Position des ersten Elements aus v1, das > xmin ist
    //lambda-Funktion wird direkt übergeben
    auto itr1 = std::find_if(std::begin(v1),
                             std::end(v1), //
                             [xmin](auto x) { return x > xmin; });
    //finde Position des ersten Elements aus v1, das > xmax ist
    //lambda-Funktion wird direkt übergeben
    auto itr2 = std::find_if(std::begin(v1),
                             std::end(v1), //
                             [xmax](auto x) { return x > xmax; });
    //gebe Zahlen zwischen itr1 (zeigt auf 11) und itr2 (zeigt auf 17)
    std::for_each(itr1, itr2, print);
}
} // namespace nmx::apps::x008