xquad.h

Go to the documentation of this file.

#pragma once

#include "xerror.h"
#include <fstream>
#include <gsl/gsl_integration.h>

namespace nmx::gsl {

template<class T>
class BaseIntegral
{
protected:
    T *_workspace = nullptr;
    gsl_function _gslFunction;
    double _result, _error;
    int _errorCode;

    template<class FN>
    BaseIntegral(FN &fn)
        : _gslFunction{ nullptr, nullptr }
        , _result(0)
        , _error(0) {
        // Definition der gsl-Funktion. Es werden das Funktionsargument
        // und ein zusätzlicher Parameter übergeben
        _gslFunction.function = [](double x, void *params) {
            // der zusätzliche Parameter enthält einen Zeiger auf
            // die Funktion fn...
            FN *_obj = static_cast<FN *>(params);
            // ihr wird hier x übergeben, um den Funktionswert zu
            //berechnen
            return (*_obj)(x);
        };
        //hier wird fn registriert
        _gslFunction.params = static_cast<void *>(&fn);
    }

public:
    inline void show_results(std::ofstream &sout, double expected) {
        sout << "result         = " << result() << "\n";
        sout << "exact result   = " << expected << "\n";
        sout << "estimated error= " << error() << "\n";
        sout << "actual error   = " << abs(result() - expected) << "\n";
        sout << "intervals      = " << intervals() << "\n";
    }

    inline double result() const { return _result; }

    inline double error() const { return _error; }

    inline size_t intervals() const { return _workspace->size; }
}; //BaseIntegral

class Integral : public BaseIntegral<gsl_integration_workspace>
{
public:
    template<class FN>
    inline Integral(FN &fn, size_t size = 1000)
        : BaseIntegral(fn) {
        _workspace = gsl_integration_workspace_alloc(size);
    }

    Integral(const Integral &i) = delete;

    Integral &operator=(const Integral &i) = delete;

    ~Integral() {
        if (_workspace != nullptr) {
            gsl_integration_workspace_free(_workspace);
        }
    }

    inline auto qng(double xmin, double xmax, double epsabs = 1e-9, double epsrel = 1e-9) {
        size_t nofFunEvals;
        // clang-format off
        _errorCode =  gsl_integration_qng(&_gslFunction, xmin, xmax,
                                   epsabs,epsrel,&_result,
                                   &_error,&nofFunEvals);
        // clang-format on
        return std::make_pair(_errorCode, nofFunEvals);
    }

    inline int qag(double xmin, double xmax, int key, double epsabs = 1e-9, double epsrel = 1e-9) {
        Check::error_if_not(nmx_msg, key >= 1 && key <= 6);
        // clang-format off
        _errorCode = gsl_integration_qag(&_gslFunction, xmin, xmax,
                                   epsabs, epsrel, _workspace->limit,
                                   key, _workspace, &_result, &_error);
        // clang-format on
        return _errorCode;
    }

    inline int qags(double xmin, double xmax, double epsabs = 1e-9, double epsrel = 1e-9) {
        // clang-format off
        _errorCode = gsl_integration_qags(&_gslFunction, xmin, xmax,
                                    epsabs, epsrel,_workspace->limit,
                                    _workspace,&_result, &_error);
        // clang-format on
        return _errorCode;
    }

    inline int qagi(double epsabs = 1e-9, double epsrel = 1e-9) {
        // clang-format off
        _errorCode = gsl_integration_qagi(&_gslFunction, epsabs,
                                    epsrel,_workspace->limit,_workspace,
                                    &_result, &_error);
        // clang-format on
        return _errorCode;
    }

    inline int qagiu(double xmin, double epsabs = 0, double epsrel = 1e-9) {
        // clang-format off
        _errorCode = gsl_integration_qagiu(&_gslFunction, xmin,
                                     epsabs, epsrel,
                                     _workspace->limit, _workspace,
                                     &_result, &_error);
        // clang-format on
        return _errorCode;
    }

    inline int qagil(double xmax, double epsabs = 1e-9, double epsrel = 1e-9) {
        // clang-format off
        _errorCode = gsl_integration_qagil(&_gslFunction, xmax,
                                     epsabs, epsrel,
                                     _workspace->limit,_workspace,
                                     &_result,&_error);
        // clang-format on
        return _errorCode;
    }
}; //Integral

class CQUADIntegral : public BaseIntegral<gsl_integration_cquad_workspace>
{
private:
    size_t _nFunctionEvals; //Anzahl der Funktionsaufrufe
public:
    template<class FN>
    CQUADIntegral(FN &fn, size_t dim = 100)
        : BaseIntegral(fn) {
        _workspace = gsl_integration_cquad_workspace_alloc(dim);
        //Überprüfung der minimalen Anzahl der Intervalle
        Check::error_if_not(nmx_msg, dim >= 3);
    }

    ~CQUADIntegral() {
        if (_workspace != nullptr) {
            gsl_integration_cquad_workspace_free(_workspace);
        }
    }

    int apply(double xmin, double xmax, double epsabs = 1e-9, double epsrel = 1e-9) {
        // clang-format off
        _errorCode = gsl_integration_cquad(&_gslFunction, xmin, xmax,
                                     epsabs, epsrel,
                                     _workspace, &_result,
                                     &_error, &_nFunctionEvals);
        // clang-format on
        return _errorCode;
    }
}; //CQUADIntegral

} // namespace nmx::gsl