xroot.h

Go to the documentation of this file.

#pragma once

#include "xerror.h"
#include <gsl/gsl_errno.h>
#include <gsl/gsl_roots.h>
#include <optional>

namespace nmx::gsl {

class RootBracketing
{
private:
    //gsl interne Struktur
    const gsl_root_fsolver_type *_solver_type = nullptr;
    //legt Algorithmus fest
    gsl_root_fsolver *_solver = nullptr;

    //Intervallgrenzen
    double _xmin, _xmax;

    //mögliche Nullstelle nach jedem Iterationsschritt
    double _currentRoot;

    //Ergebnis hat noch keinen gültigen Wert
    std::optional<double> _result;

    // Status der Iteration
    int _status = GSL_CONTINUE;

    //suche Nullstelle für diese Funktion (gsl-Funktion)
    gsl_function F;
    //obere Iterationsgrenze damit keine Endlosschleife entsteht
    size_t MAX_STEPS = 100;

    inline int next_step(double epsabs, double epsrel) {
        //nach jeder Iteration...
        if (gsl_root_fsolver_iterate(_solver) != GSL_SUCCESS) {
            throw std::runtime_error(nmx_msgx(_status));
        }
        //...ermittelte Nullstelle
        _currentRoot = gsl_root_fsolver_root(_solver);
        //untere Grenze des Intervalls
        _xmin = gsl_root_fsolver_x_lower(_solver);
        //obere Grenze des Intervalls
        _xmax = gsl_root_fsolver_x_upper(_solver);
        // ist die Bedingung
        //|xmin-xmax| < eposabs + epsrel min(|xmin|,|xmax|)
        //erfüllt?
        _status = gsl_root_test_interval(_xmin, _xmax, epsabs, epsrel);
        return _status;
    }

public:
    template<class T>
    RootBracketing(T &pobj, const gsl_root_fsolver_type *type = gsl_root_fsolver_bisection)
        : _solver_type{ type } {
        //gsl -Routine zur Lösung der Gleichung wird initialisiert
        _solver = gsl_root_fsolver_alloc(_solver_type);
        //definiere eine gsl-konforme Funktion
        //zusätzlicher Parameter zeigt auf pobj
        F.params = &pobj;
        //sie ruft intern pobj auf und übergibt x
        F.function = [](double x, void *params) -> double {
            auto *myFn = static_cast<T *>(params);
            return (*myFn)(x);
        };
    }

    ~RootBracketing() {
        if (_solver != nullptr) {
            gsl_root_fsolver_free(_solver);
        }
    }

    inline bool converged() const { return _status == GSL_SUCCESS; }

    inline auto xminmax() const { return std::make_pair(_xmin, _xmax); }

    inline const char *method_used() const { //
        return gsl_root_fsolver_name(_solver);
    }

    template<class FN>
    auto apply(double xmin, double xmax, FN fn, double epsabs, double epsrel) {
        _xmin = xmin;
        _xmax = xmax;
        gsl_root_fsolver_set(_solver, &F, _xmin, _xmax);
        for (size_t i = 1; i <= MAX_STEPS && _status == GSL_CONTINUE; ++i) {
            next_step(epsabs, epsrel);
            if (_status == GSL_SUCCESS) {
                _result = _currentRoot;
            }
            fn(i, _xmin, _xmax, _currentRoot);
        }
        return _result;
    }

    inline auto apply(double xmin, double xmax, double epsabs, double epsrel) {
        _xmin = xmin;
        _xmax = xmax;
        gsl_root_fsolver_set(_solver, &F, _xmin, _xmax);
        for (size_t i = 1; i <= MAX_STEPS && _status == GSL_CONTINUE; ++i) {
            next_step(epsabs, epsrel);
            if (_status == GSL_SUCCESS) {
                _result = _currentRoot;
            }
        }
        return _result;
    }

    inline double result() const {
        //teste Status der Variablen (für die Nullstelle)
        Check::error_if(nmx_msg, !_result);
        return *_result;
    }
}; //RootBracketing

class FDFSolver
{
private:
    //gsl interne Struktur
    const gsl_root_fdfsolver_type *_solverType;
    //Algorithmus
    gsl_root_fdfsolver *_solver = nullptr;
    //suche Nullstelle für diese Funktion (gsl-Funktion)
    gsl_function_fdf FDF;
    //x_(i+1),x_i
    double _xnew, _xold;
    //Status der Iteration
    int _status;
    //Anzahl der Iterationen
    size_t _iteration = 0;
    //gefundene Nullstelle
    std::optional<double> _foundRoot;

public:
    size_t MAX_STEPS = 100;

private:
    inline void next_step(double epsabs, double epsrel) {
        _iteration++;
        _status = gsl_root_fdfsolver_iterate(_solver);
        //speichere zuletzt bekannte Nullstelle
        _xold = _xnew;
        //berechne neue Nullstelle
        _xnew = gsl_root_fdfsolver_root(_solver);
        //teste Konvergenz
        _status = gsl_root_test_delta(_xnew, _xold, epsabs, epsrel);

        if (_status == GSL_SUCCESS) {
            _foundRoot = _xnew;
        }
    }

public:
    template<typename T>
    FDFSolver(T &obj, const gsl_root_fdfsolver_type *type = gsl_root_fdfsolver_newton) {
        _solverType = type;
        _solver = gsl_root_fdfsolver_alloc(_solverType);
        //verbinde obj mit gsl
        FDF.params = &obj;
        //Funktion
        FDF.f = [](double x, void *params) { //
            return static_cast<T *>(params)->f(x);
        };
        //Ableitung
        FDF.df = [](double x, void *params) { //
            return static_cast<T *>(params)->df(x);
        };
        //Funktion und Ableitung in einem Aufruf
        FDF.fdf = [](double x, void *params, double *f, double *df) {
            T *obj = static_cast<T *>(params);
            *f = obj->f(x);
            *df = obj->df(x);
        };
    }

    inline ~FDFSolver() {
        if (_solver != nullptr) {
            gsl_root_fdfsolver_free(_solver);
        }
    }

    inline const char *method_used() const { //
        return gsl_root_fdfsolver_name(_solver);
    }

    inline bool converged() const { return _status == GSL_SUCCESS; }

    inline double result() const {
        //teste Status der Variablen (für die Nullstelle)
        Check::error_if(nmx_msg, !_foundRoot);
        return *_foundRoot;
    }

    inline auto apply(double startval, double epsabs = 0, double epsrel = 1e-3) {
        _xnew = startval;
        gsl_root_fdfsolver_set(_solver, &FDF, _xnew);
        do {
            next_step(epsabs, epsrel);
        } while (_status == GSL_CONTINUE && _iteration < MAX_STEPS);

        return _foundRoot;
    }

    template<class FN>
    auto apply(double startval, FN fn, double epsabs = 0, double epsrel = 1e-3) {
        _xnew = startval;
        gsl_root_fdfsolver_set(_solver, &FDF, _xnew);
        do {
            next_step(epsabs, epsrel);
            fn(_iteration, _xold, _xnew);

        } while (_status == GSL_CONTINUE && _iteration < MAX_STEPS);

        return _foundRoot;
    }
}; //FDFSolver

} // namespace nmx::gsl