x033.h

Go to the documentation of this file.

#pragma once
#include "xdata.h"
#include "xinterpolation.h"
#include "xmath.h"
#include <cmath>
#include <gsl/gsl_errno.h>
#include <gsl/gsl_spline.h>
#include <iostream>

namespace nmx::apps::x033 {

inline void ex1() {
    //Anzahl der Daten
    constexpr size_t N = 10;
    // Felder mit diskreten Daten
    double xi, yi, x[N], y[N];

    for (size_t i = 0; i < N; i++) {
        x[i] = i + 0.5 * sin(i);
        y[i] = i + cos(i * i);
    }

    //gsl Objekte Initialisierung
    gsl_interp_accel *acc = gsl_interp_accel_alloc();
    const gsl_interp_type *t = gsl_interp_cspline;
    gsl_spline *spline = gsl_spline_alloc(t, N);

    //Verbindung gsl-Objekte mit diskreten Daten
    gsl_spline_init(spline, x, y, N);

    //berechne Werte
    for (xi = x[0]; xi < x[9]; xi += 0.01) {
        yi = gsl_spline_eval(spline, xi, acc);
        std::cout << xi << "," << yi << std::endl;
    }

    //Speicherfreigabe
    gsl_spline_free(spline);
    gsl_interp_accel_free(acc);
}

inline void ex2() {
    //Anzahl der Daten
    size_t N = 4;

    // es muss y[0]=y[3] gelten damit
    // gsl_interp_cspline_periodic eingesetzt werden kann
    double x[4] = { 0.00, 0.10, 0.27, 0.30 };
    double y[4] = { 0.15, 0.70, -0.10, 0.15 };

    //Initialisierung von gsl Objekten
    gsl_interp_accel *acc = gsl_interp_accel_alloc();
    const gsl_interp_type *t = gsl_interp_cspline_periodic;
    gsl_spline *spline = gsl_spline_alloc(t, N);

    //Verbindung gsl-Objekte mit diskreten Daten
    gsl_spline_init(spline, x, y, N);

    //berechne Werte
    for (size_t i = 0; i <= 100; i++) {
        double xi = (1 - i / 100.0) * x[0] + (i / 100.0) * x[N - 1];
        double yi = gsl_spline_eval(spline, xi, acc);
        std::cout << xi << "," << yi << std::endl;
    }

    //Speicherfreigabe
    gsl_spline_free(spline);
    gsl_interp_accel_free(acc);
}

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

inline void interp1() {
    using Data = Data<4>;
    //Datenobjekt
    Data data;

    //Datenreihe
    std::vector<double> xvalues, yvalues;

    //erstelle diskrete Daten
    auto fn = [](double x) { return sin(x); };

    //berechne diskrete Werte
    double dx = 0.4 * Math::PI;
    for (double x = 0; x <= 2 * Math::PI; x += dx) {
        xvalues.push_back(x);
        yvalues.push_back(fn(x));
        std::cout << x << "," << fn(x) << std::endl;
    }

    //lineare Interpolation
    gsl::Interpolation linear(gsl_interp_linear, xvalues, yvalues);

    //spline Interpolation
    gsl::Interpolation spline(gsl_interp_cspline, xvalues, yvalues);

    //berechne interpolierte Werte
    dx = 0.3 * Math::PI;
    for (double x = dx; x < 2 * Math::PI; x += dx) {
        data += { x, linear.eval(x), spline.eval(x), fn(x) };
    }

    //Ausgabe
    std::ofstream ofsplot = get_output_stream(__func__, Output::plot);
    data.save(ofsplot, Output::plot);
    std::ofstream ofstable = get_output_stream(__func__, Output::latex);
    ofstable << std::setprecision(4);

    //LaTeX-Tabelle enthält eine Auswahl der berechneten Werte
    const auto view = data.select_total_rows(4);
    view.save(ofstable, Output::latex);
}

inline void interp2() {
    using Data = Data<7>;
    Data data; // Datenobjekt
    //Ort
    auto x = [](double t) { return -0.75 * pow(t, 2) + 3 * t + 1; };
    //Geschwindigkeit
    auto xdot = [](double t) { return -1.5 * t + 3; };
    //Beschleunigung
    auto xddot = [](double t) {
        (void) t;
        return -1.5;
    };
    //diskrete Werte werden erzeugt
    std::vector<double> tvalues, xvalues;
    for (double t = 0; t < 4; t += 0.1) {
        tvalues.push_back(t);
        xvalues.push_back(x(t));
    }

    gsl::Interpolation interpfn{ gsl_interp_cspline, tvalues, xvalues };
    //fülle Datenobjekt mit interpolierten und exakten Daten
    for (auto t : { 0.32, 1.75, 2.22, 3.18 }) {
        data += { t,
                  x(t),
                  xdot(t),
                  xddot(t),
                  interpfn.eval(t),
                  interpfn.deriv(t),
                  interpfn.deriv2(t) };
    }
    //Ausgabe
    std::ofstream ofs = get_output_stream(__func__, Output::latex);
    ofs << std::setprecision(4);
    data.save(ofs, Output::latex);
}

} // namespace nmx::apps::x033