x000.h

Go to the documentation of this file.

#pragma once

#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>

namespace nmx::apps::x000 {

inline void ex1() {
    std::array v1 = { 1., 2., 3. };
    std::array v2 = { -3., -9., 1. };

    auto normalize = [](auto v) {
        auto vcopy = v;
        double vnorm = std::inner_product(vcopy.begin(), vcopy.end(), vcopy.begin(), 0.0);
        std::transform(vcopy.begin(), vcopy.end(), vcopy.begin(), [vnorm](double x) { //
            return x / vnorm;
        });
        return vcopy;
    };

    auto print = [](auto v) {
        for (auto x : v) {
            std::cout << x << "\t";
        }
        std::cout << std::endl;
    };

    auto v1n = normalize(v1);
    auto v2n = normalize(v2);

    std::cout << std::fixed << std::setprecision(2);
    print(v1n);
    print(v2n);
}

inline void ex2() {
    double x0, v0, a, t1; // input
    double x1, v1, s, vbar; //output
    char cmd = 'y'; // die Schleife soll wiederholt werden
    std::cout << "------------input-------------" << std::endl;
    while (cmd == 'y') {
        //1. Eingabe : Anfangsort
        std::cout << "x0=?\t";
        std::cin >> x0;
        //2. Eingabe : Anfangsgeschwindigkeit
        std::cout << "v0=?\t";
        std::cin >> v0;
        //3. Eingabe : Beschleunigung
        std::cout << "a =?\t";
        std::cin >> a;
        //4. Eingabe : Zeitpunkt
        std::cout << "t1=?\t";
        std::cin >> t1;
        // Die Formeln für:
        x1 = x0 + v0 * t1 + 0.5 * a * pow(t1, 2); //Ort
        v1 = v0 + a * t1; //Geschwindigkeit
        s = x1 - x0; //Strecke
        vbar = s / t1; //Durchschnittsgeschwindigkeit
        //Ausgabe der Ergebnisse
        std::cout << std::fixed << std::setprecision(2);
        std::cout << "------------output-------" << std::endl;
        std::cout << "t1 = " << t1 << "\t"; // std::endl;
        std::cout << "x1 = " << x1 << "\t"; // std::endl;
        std::cout << "v1 = " << v1 << "\t"; // std::endl;
        std::cout << "s  = " << s << "\t"; // std::endl;
        std::cout << "vbar = " << vbar << std::endl;
        //Programm beenden?
        do {
            std::cout << "continue? y[yes] / n[no]" << std::endl;
            std::cin >> cmd;
        } while (cmd != 'y' && cmd != 'n');
    }
}

} // namespace nmx::apps::x000

namespace nmx::apps::x000 {

// lese Benutzereingabe
double read(const char *label) {
    double val;
    std::cout << label << "=?\t";
    std::cin >> val;
    //Fehler wenn val nicht vom Typ double ist
    if (std::cin.fail()) {
        throw std::invalid_argument(label);
    }
    return val;
}

//
using ValuePair = std::pair<std::string, double>;

// schreibe alle Ergebnisse
void write(std::initializer_list<ValuePair> lst) {
    for (auto &[label, val] : lst) {
        std::cout << label << std::setw(6 - static_cast<int>(label.size())) << "=" << val
                  << std::endl;
    }
}

// Eingabe->Berechnung->Ausgabe
void corefn() {
    double x0, v0, a, t1; // input
    double x1, v1, s, vbar; //output
    //1. Eingabe : Anfangsort
    x0 = read("x0");
    //2. Eingabe : Anfangsgeschwindigkeit
    v0 = read("v0");
    //3. Eingabe : Beschleunigung
    a = read("a");
    //4. Eingabe : Zeitpunkt
    t1 = read("t1");
    if (t1 <= 0) {
        throw std::domain_error("time must be >0");
    }
    // Die Formeln für:
    x1 = x0 + v0 * t1 + 0.5 * a * pow(t1, 2); //Ort
    v1 = v0 + a * t1; //Geschwindigkeit
    s = x1 - x0; //Strecke
    vbar = s / t1; //Durchschnittsgeschwindigkeit
    //Ausgabe der Ergebnisse
    std::cout << std::fixed << std::setprecision(2);
    std::cout << "------------output-------" << std::endl;
    write({ { "t1", t1 }, //
            { "x1", x1 },
            { "v1", v1 },
            { "s", s },
            { "vbar", vbar } });
}

// Benutzerschnittstelle
inline void calcui() {
    char cmd = 'y'; // die Schleife soll wiederholt werden
    constexpr auto maxstreamsize = std::numeric_limits<std::streamsize>::max();
    std::cout << "------------input-------------" << std::endl;
    while (cmd == 'y') {
        try {
            corefn();
        } catch (std::domain_error ex1) {
            std::cin.clear();
            //ignoriere all restlichen Eingaben
            std::cin.ignore(maxstreamsize, '\n');
            std::cerr << "input error:" << ex1.what() << std::endl;
        } catch (std::invalid_argument ex2) {
            std::cin.clear();
            //ignoriere all restlichen Eingaben
            std::cin.ignore(maxstreamsize, '\n');
            std::cerr << "input error for:" << ex2.what() << std::endl;
        }
        //Programm beenden?
        do {
            std::cout << "new claculation? y[yes] / n[no]" << std::endl;
            std::cin >> cmd;
        } while (cmd != 'y' && cmd != 'n');
    }
}

} // namespace nmx::apps::x000