EIC code displayed by LXR master/​include/​NumA/​integration/​one_dimension/​DExpIntegrator1D.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-06-02 08:48:22

 #ifndef DEXP_INTEGRATOR_1D_H
 #define DEXP_INTEGRATOR_1D_H
 
 /**
  * @file DExpIntegrator1D.h
  * @author Bryan BERTHOU (SPhN / CEA Saclay)
  * @author Daniele Binosi (ECT*)
  * @date December 15, 2015
  * @version 1.0
  *
  */
 
 #include <vector>
 
 #include "Integrator1D.h"
 
 class FunctionType1D;
 
 namespace NumA {
 
 /**
  * @class DExpIntegrator1D
  * @brief This is an implementation of the double exponential rule.
  *
  * The functions being integrated are required to be smooth (no discontinuities in the function or any of its
  * derivatives), with no infinities in the middle of the integration interval
  * (but it does allow functions that become infinite at the ends of the integration interval).
  *
  * The method is based on the observation that the trapezoid rule converges extremely fast for functions
  * that go to zero like exp(-exp(t)). In practice, it implements a change of variables to implement this property
  * in the function to be integrated.
  *
  * The change of variable is x = tanh( pi sinh(t) /2) which transforms an integral over [-1, 1]
  * into an integral with integrand suited to the double exponential rule. The transformed integral is infinite,
  * but one can truncate the domain of integration to [-3, 3].
  *
  * The limit '3' is chosen for two reasons:
  *
  * 1. The transformed x values are equal to 1 for 12 or more significant figures;
  * 2. The smallest weights are 12 orders of magnitude smaller than the largest weights (setting
  * the cutoff larger than 3 would not have a significant impact on the integral value
  * unless there is a strong singularity at one of the end points).
  *
  * The change of variables x(t) is an odd function, whereas its derivative w(t) is even;
  * thus in the cpp file we will store only positive values of nodes and weights.
  *
  * The integration first applies the trapezoid rule to [-3, 3] in steps of size 1, subsequently cutting the step size
  * in half each time, and comparing the results. The routine stops when subsequent iterations are close
  * enough together or the maximum integration points have been used. Notice that by cutting h in half,
  * the previous integral can be reused; we only need evaluate the integrand at the newly added points.
  *
  * As we assume that values at the ends of the interval hardly matter due to the rapid decay of the integrand
  * we don't treat the end points differently.
  *
  * See Integrator1D documentation for an example.
  */
 class DExpIntegrator1D: public Integrator1D {
 public:
     /**
      * Default constructor.
      */
     DExpIntegrator1D();
 
     /**
      * Default destructor.
      */
     virtual ~DExpIntegrator1D();
 
     DExpIntegrator1D* clone() const;
 
     virtual double integrate(FunctionType1D* pFunction, double a, double b,
             std::vector<double> &parameters);
 
 protected:
     /**
      * Copy constructor.
      * Called by clone().
      * @param other DExpIntegrator1D object to copy.
      */
     DExpIntegrator1D(const DExpIntegrator1D &other);
 
 private:
 
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
     double m_errorEstimate; ///< Absolute error estimate.
     int m_numFunctionEvaluations; ///< Number of evaluations.
     std::vector<double> m_nodes; ///< Nodes of the quadrature.
     std::vector<double> m_weights; ///< Weights of the quadrature.
     std::vector<int> m_offsets;
 };
 
 } // namespace NumA
 
 #endif /* DEXP_INTEGRATOR_1D_H */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team