x034.h

Go to the documentation of this file.

#pragma once

#include <gsl/gsl_errno.h>
#include <gsl/gsl_math.h>
#include <gsl/gsl_roots.h>

#include "xoutput.h"
#include "xroot.h"

namespace nmx::apps::x034 {

struct quadratic_params {
    double a, b, c;
};

double quadratic_fn(double x, void *params) {
    //Konvertierung des void-Zeigers, die Koeffizienten des Polynoms
    //werden über diesen Parameter festgelegt
    struct quadratic_params *p = static_cast<quadratic_params *>(params);
    //Koeffizienten a x^2 + b x + c
    double a = p->a;
    double b = p->b;
    double c = p->c;
    return (a * x + b) * x + c;
}

double quadratic_deriv(double x, void *params) {
    //Konvertierung des void-Zeigers, die Koeffizienten des Polynoms
    //werden über diesen Parameter festgelegt
    struct quadratic_params *p = static_cast<quadratic_params *>(params);
    //Koeffizienten a x^2 + b x + c
    double a = p->a;
    double b = p->b;
    return 2.0 * a * x + b;
}

void quadratic_fdf(double x, void *params, double *y, double *dy) {
    //Konvertierung des void-Zeigers, die Koeffizienten des Polynoms
    //werden über diesen Parameter festgelegt
    struct quadratic_params *p = static_cast<quadratic_params *>(params);
    //Koeffizienten a x^2 + b x + c
    double a = p->a;
    double b = p->b;
    double c = p->c;
    *y = (a * x + b) * x + c;
    *dy = 2.0 * a * x + b;
}

inline void ex1() {
    // Definition der Funktion, für welche die Nullstelle gesucht wird
    //Polynomkoeffizienten
    quadratic_params params = { 1.0, 0.0, -5.0 };
    //gsl-Funktion
    gsl_function F;
    F.function = &quadratic_fn;
    F.params = &params;

    //**Teil 2
    // Initialisierung der gsl_Routinen
    // Anfangsintervall
    double x_lo = 0.0, x_hi = 5.0;
    //Bisektionsalgorithmus
    const gsl_root_fsolver_type *T = gsl_root_fsolver_bisection;
    //Routine zur Nullstellensuche
    gsl_root_fsolver *s;
    s = gsl_root_fsolver_alloc(T);
    //registriere Funktion
    gsl_root_fsolver_set(s, &F, x_lo, x_hi);

    //**Teil 3
    //Iteration
    printf("using %s method\n", gsl_root_fsolver_name(s));
    printf("%5s [%9s, %9s] %9s %10s %9s\n", "iter", "lower", "upper", "root", "err", "err(est)");

    double r = 0, r_expected = sqrt(5.0);
    int status;
    int iter = 0, max_iter = 100;
    do {
        //Zähler damit keine Endlosschleife entsteht
        iter++;
        //Iterationschritt
        status = gsl_root_fsolver_iterate(s);
        r = gsl_root_fsolver_root(s);
        //neue Grenzen für das Intervall
        x_lo = gsl_root_fsolver_x_lower(s);
        x_hi = gsl_root_fsolver_x_upper(s);
        //ist das Intervall klein genug?
        status = gsl_root_test_interval(x_lo, x_hi, 0, 0.001);

        if (status == GSL_SUCCESS) {
            printf("Converged:\n");
        }

        printf("%5d [%.7f, %.7f] %.7f %+.7f %.7f\n",
               iter,
               x_lo,
               x_hi,
               r,
               r - r_expected,
               x_hi - x_lo);
    } while (status == GSL_CONTINUE && iter < max_iter);

    //**Teil 4
    //Speicherfreigabe
    gsl_root_fsolver_free(s);
}

inline void ex2() {
    //Definition der Funktion, für welche die Nullstelle gesucht
    //wird,Ableitung der Funktion,kombinierter Aufruf Funktion
    // und Ableitung
    quadratic_params params = { 1.0, 0.0, -5.0 };
    gsl_function_fdf FDF;
    FDF.f = &quadratic_fn;
    FDF.df = &quadratic_deriv;
    FDF.fdf = &quadratic_fdf;
    FDF.params = &params;

    //**Teil 2
    //Initialisierung der gsl_Routinen  Anfangsintervall
    double x0, x = 5.0, r_expected = sqrt(5.0);
    //Newton-Algorithmus
    const gsl_root_fdfsolver_type *T = gsl_root_fdfsolver_newton;
    //Routine zur Nullstellensuche
    gsl_root_fdfsolver *s;
    s = gsl_root_fdfsolver_alloc(T);
    //registriere Funktion und ihre Ableitung
    gsl_root_fdfsolver_set(s, &FDF, x);

    //**Teil 3
    //Iteration
    int status;
    int iter = 0, max_iter = 100;
    printf("using %s method\n", gsl_root_fdfsolver_name(s));
    printf("%-5s %10s %10s %10s\n", "iter", "root", "err", "err(est)");
    do {
        //Zähler damit keine Endlosschleife entsteht
        iter++;
        //Iterationschritt
        status = gsl_root_fdfsolver_iterate(s);
        x0 = x;
        x = gsl_root_fdfsolver_root(s);
        //ist Nullstelle gefunden?
        status = gsl_root_test_delta(x, x0, 0, 1e-3);

        if (status == GSL_SUCCESS)
            printf("Converged:\n");

        printf("%5d %10.7f %+10.7f %10.7f\n", iter, x, x - r_expected, x - x0);
    } while (status == GSL_CONTINUE && iter < max_iter);

    //**Teil 4
    //Speicherfreigabe
    gsl_root_fdfsolver_free(s);
}

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

template<class T>
inline void show_results(std::ofstream &ofs, const T &obj, double expected) {
    ofs << "method used :" << obj.method_used() << std::endl;
    if (obj.converged()) {
        ofs << "success\n";
        ofs << "t:" << obj.result() << std::endl;
        ofs << "t (exact):" << expected << std::endl;
        ofs << "error:" << abs(obj.result() - expected) << std::endl;
    } else {
        ofs << "failed" << std::endl;
    }
}

inline void root1() {
    //Suche Nullstelle dieser Funktion
    auto function = [](double x) { return pow(x, 2) - 5; };

    // öffne Ausgabestrom
    std::ofstream ofs = get_output_stream(__func__);
    ofs << std::fixed << std::setprecision(7);

    //Zeichne Iterationsschritte auf
    auto monitor = [&ofs](size_t i,
                          double xmin, //
                          double xmax,
                          double result) {
        ofs << i << "\t" << xmin << "\t" //
            << xmax << "\t" << result << std::endl;
    };

    //gsl-Klasse zur Nullstellenberechnung
    gsl::RootBracketing rootFinder{ function };
    ofs << "iter\txmin\txmax\terror\n";
    rootFinder.apply(0, 5, monitor, 0, 0.001);

    //Ausgabe
    show_results(ofs, rootFinder, std::sqrt(5));
}

inline void root2() {
    auto function = [](double x) { return pow(x, 2) - 5; };
    std::ofstream ofs = get_output_stream(__func__);
    ofs << std::fixed << std::setprecision(7);
    auto monitor = [&ofs](size_t i, double xmin, double xmax, double result) {
        ofs << i << "\t" << xmin << "\t" << xmax << "\t" << result << std::endl;
    };

    gsl::RootBracketing rootFinder{ function, gsl_root_fsolver_brent };
    ofs << "iter\txmin\txmax\terror\n";
    rootFinder.apply(0, 5, monitor, 0, 0.001);
    ofs << "method used     :" << rootFinder.method_used() << std::endl;
    show_results(ofs, rootFinder, std::sqrt(5));
}

inline void root3() {
    //Bewegungsparameter
    const double d = 100;
    const double m1 = 1, m2 = 2;
    const double f1 = 10, f2 = 15;
    const double a1 = f1 / m1;
    const double a2 = f2 / m2;

    //Suche Nullstelle dieser Funktion
    auto fn = [d, a1, a2](double t) {
        const auto x1 = 0.5 * a1 * pow(t, 2);
        const auto x2 = d - 0.5 * a2 * pow(t, 2);
        return (x1 - x2);
    };

    //Ausgabestrom
    std::ofstream ofs = get_output_stream(__func__);
    ofs << std::fixed << std::setprecision(7);

    //gsl-Klasse
    gsl::RootBracketing rootFinder{ fn, gsl_root_fsolver_brent };
    rootFinder.apply(0, 100, 0, 1e-6);

    //Ergebnisse
    const auto expected = sqrt(2 * d / (a1 + a2));
    show_results(ofs, rootFinder, expected);
}

inline void root4() {
    //Funktion und ihre Ableitung
    struct MyFN {
        inline double f(double x) const { return pow(x, 2) - 5; }
        inline double df(double x) const { return 2 * x; }
    } myFN;

    //Ausgabestrom
    std::ofstream ofs = get_output_stream(__func__);
    ofs << std::setprecision(6) << std::fixed;

    //zeichne Schritte auf
    auto monitor = [&ofs](size_t itr, double x0, double x) {
        ofs << itr << "\t" << x << "\t" << x - x0 //
            << "\t" << x - sqrt(5) << std::endl;
    };

    //löse die Gleichung
    gsl::FDFSolver rootFinder{ myFN };
    rootFinder.apply(5, monitor);

    //zeige Iterationsschritte und Ergebnis
    show_results(ofs, rootFinder, std::sqrt(5));
}

} // namespace nmx::apps::x034