// @(#)root/mathmore:$Id$
// Authors: L. Moneta, M. Slawinska 10/2007

 /**********************************************************************
  *                                                                    *
  * Copyright (c) 2007 ROOT Foundation,  CERN/PH-SFT                   *
  *                                                                    *
  *                                                                    *
  **********************************************************************/

// Header file for class Integrator
//
//
#ifndef ROOT_Math_Integrator
#define ROOT_Math_Integrator

#ifndef ROOT_Math_AllIntegrationTypes
#include "Math/AllIntegrationTypes.h"
#endif

#ifndef ROOT_Math_IntegratorOptions
#include "Math/IntegratorOptions.h"
#endif

#ifndef ROOT_Math_IFunction
#include "Math/IFunction.h"
#endif

#ifndef ROOT_Math_VirtualIntegrator
#include "Math/VirtualIntegrator.h"
#endif


#include <memory>



/**

@defgroup Integration Numerical Integration

*/



namespace ROOT {
namespace Math {




//____________________________________________________________________________________________
/**

User Class for performing numerical integration of a function in one dimension.
It uses the plug-in manager to load advanced numerical integration algorithms from GSL, which reimplements the
algorithms used in the QUADPACK, a numerical integration package written in Fortran.

Various types of adaptive and non-adaptive integration are supported. These include
integration over infinite and semi-infinite ranges and singular integrals.

The integration type is selected using the Integration::type enumeration
in the class constructor.
The default type is adaptive integration with singularity
(ADAPTIVESINGULAR or QAGS in the QUADPACK convention) applying a Gauss-Kronrod 21-point integration rule.
In the case of ADAPTIVE type, the integration rule can also be specified via the
Integration::GKRule. The default rule is 31 points.

In the case of integration over infinite and semi-infinite ranges, the type used is always
ADAPTIVESINGULAR applying a transformation from the original interval into (0,1).

The ADAPTIVESINGULAR type is the most sophicticated type. When performances are
important, it is then recommened to use the NONADAPTIVE type in case of smooth functions or
 ADAPTIVE with a lower Gauss-Kronrod rule.

For detailed description on GSL integration algorithms see the
<A HREF="http://www.gnu.org/software/gsl/manual/gsl-ref_16.html#SEC248">GSL Manual</A>.


  @ingroup Integration

*/


class IntegratorOneDim {

public:

   typedef IntegrationOneDim::Type Type;   // for the enumerations defining the types

    // constructors


    /**
        Constructor of one dimensional Integrator, default type is adaptive

       @param type   integration type (adaptive, non-adaptive, etc..)
       @param absTol desired absolute Error
       @param relTol desired relative Error
       @param size maximum number of sub-intervals
       @param rule  Gauss-Kronrod integration rule (only for GSL kADAPTIVE type)

       Possible type values are : kGAUSS (simple Gauss method), kADAPTIVE (from GSL), kADAPTIVESINGULAR (from GSL), kNONADAPTIVE (from GSL)
       Possible rule values are kGAUS15 (rule = 1), kGAUS21( rule = 2), kGAUS31(rule =3), kGAUS41 (rule=4), kGAUS51 (rule =5), kGAUS61(rule =6)
       lower rules are indicated for singular functions while higher for smooth functions to get better accuracies

       NOTE: When the default values are passed, the values used are taken from the default defined in ROOT::Math::IntegratorOneDimOptions
    */
    explicit
    IntegratorOneDim(IntegrationOneDim::Type type = IntegrationOneDim::kDEFAULT, double absTol = 0, double relTol = 0, unsigned int size = 0, unsigned int rule = 0) :
       fIntegrator(0), fFunc(0)
   {
      fIntegrator = CreateIntegrator(type, absTol, relTol, size, rule);
   }

   /**
       Constructor of one dimensional Integrator passing a function interface

       @param f      integration function (1D interface). It is copied inside
       @param type   integration type (adaptive, non-adaptive, etc..)
       @param absTol desired absolute Error
       @param relTol desired relative Error
       @param size maximum number of sub-intervals
       @param rule Gauss-Kronrod integration rule (only for GSL ADAPTIVE type)

       NOTE: When the default values are passed, the values used are taken from the default defined in ROOT::Math::IntegratorOneDimOptions
    */
   explicit
   IntegratorOneDim(const IGenFunction &f, IntegrationOneDim::Type type = IntegrationOneDim::kDEFAULT, double absTol = 0, double relTol = 0, unsigned int size = 0, int rule = 0) :
      fIntegrator(0), fFunc(0)
   {
      fIntegrator = CreateIntegrator(type, absTol, relTol, size, rule);
      SetFunction(f,true);
   }

   /**
        Template Constructor of one dimensional Integrator passing a generic function object

       @param f      integration function (any C++ callable object implementing operator()(double x)
       @param type   integration type (adaptive, non-adaptive, etc..)
       @param absTol desired absolute Error
       @param relTol desired relative Error
       @param size maximum number of sub-intervals
       @param rule Gauss-Kronrod integration rule (only for GSL ADAPTIVE type)
    */

   template<class Function>
   explicit
   IntegratorOneDim(Function & f, IntegrationOneDim::Type type = IntegrationOneDim::kDEFAULT, double absTol = 0, double relTol = 0, unsigned int size = 0, int rule = 0) :
      fIntegrator(0), fFunc(0)
   {
      fIntegrator = CreateIntegrator(type, absTol, relTol, size, rule);
      SetFunction(f);
   }

   /// destructor (will delete contained pointers)
   virtual ~IntegratorOneDim() {
      if (fIntegrator) delete fIntegrator;
      if (fFunc) delete fFunc;
   }

   // disable copy constructur and assignment operator

private:
   IntegratorOneDim(const IntegratorOneDim &) : fIntegrator(0), fFunc(0) {}
   IntegratorOneDim & operator=(const IntegratorOneDim &) { return *this; }

public:


   // template methods for generic functors

   /**
      method to set the a generic integration function
      @param f integration function. The function type must implement the assigment operator, <em>  double  operator() (  double  x ) </em>

   */


   template<class Function>
   inline void SetFunction(Function & f);

   /**
       set one dimensional function for 1D integration
    */
   void SetFunction  (const IGenFunction &f, bool copy = false) {
      if (!fIntegrator) return;
      if (copy) {
         if (fFunc) delete fFunc; 
         fFunc = f.Clone();
         fIntegrator->SetFunction(*fFunc);
         return;
      }
      fIntegrator->SetFunction(f);
   }


   /**
      Set integration function from a multi-dim function type.
      Can be used in case of having 1D function implementing the generic interface
       @param f      integration function
       @param icoord index of coordinate on which the integration is performed
       @param x  array of the passed variables values. In case of dim=1 a 0 can be passed
   */
   void SetFunction(const IMultiGenFunction &f, unsigned int icoord , const double * x );

    // integration methods using a function

    /**
       evaluate the Integral of a function f over the defined interval (a,b)
       @param f integration function. The function type must be a C++ callable object implementing operator()(double x)
       @param a lower value of the integration interval
       @param b upper value of the integration interval
    */
   template<class Function>
   double Integral(Function & f, double a, double b);


    /**
       evaluate the Integral of a function f over the defined interval (a,b)
       @param f integration function. The function type must implement the mathlib::IGenFunction interface
       @param a lower value of the integration interval
       @param b upper value of the integration interval
    */
   double Integral(const IGenFunction & f, double a, double b) {
     SetFunction(f,false);
      return Integral(a,b);
   }


    /**
      evaluate the Integral of a function f over the infinite interval (-inf,+inf)
       @param f integration function. The function type must be a C++ callable object implementing operator()(double x)
    */
//    template<class Function>
//    double Integral(const Function & f);

   /**
      evaluate the Integral of a function f over the infinite interval (-inf,+inf)
      @param f integration function. The function type must implement the mathlib::IGenFunction interface
   */
   double Integral(const IGenFunction & f) {
      SetFunction(f,false);
      return Integral();
   }


    /**
      evaluate the Integral of a function f over the semi-infinite interval (a,+inf)
      @param f integration function. The function type must be a C++ callable object implementing operator()(double x)
      @param a lower value of the integration interval
    */
//    template<class Function>
//    double IntegralUp(Function & f, double a);

   /**
      evaluate the Integral of a function f over the semi-infinite interval (a,+inf)
      @param f integration function. The function type must implement the mathlib::IGenFunction interface
      @param a lower value of the integration interval

   */
   double IntegralUp(const IGenFunction & f, double a ) {
     SetFunction(f,false);
      return IntegralUp(a);
   }

    /**
      evaluate the Integral of a function f over the over the semi-infinite interval (-inf,b)
      @param f integration function. The function type must be a C++ callable object implementing operator()(double x)
      @param b upper value of the integration interval
    */
//    template<class Function>
//    double IntegralLow(Function & f, double b);

   /**
      evaluate the Integral of a function f over the over the semi-infinite interval (-inf,b)
      @param f integration function. The function type must implement the mathlib::IGenFunction interface
      @param b upper value of the integration interval
   */
   double IntegralLow(const IGenFunction & f, double b ) {
     SetFunction(f,false);
      return IntegralLow(b);
   }

   /**
      evaluate the Integral of a function f with known singular points over the defined Integral (a,b)
      @param f integration function. The function type must be a C++ callable object implementing operator()(double x)
      @param pts vector containing both the function singular points and the lower/upper edges of the interval. The vector must have as first element the lower edge of the integration Integral ( \a a) and last element the upper value.

   */
   template<class Function>
   double Integral(Function & f, const std::vector<double> & pts );

   /**
      evaluate the Integral of a function f with known singular points over the defined Integral (a,b)
      @param f integration function. The function type must implement the mathlib::IGenFunction interface
      @param pts vector containing both the function singular points and the lower/upper edges of the interval. The vector must have as first element the lower edge of the integration Integral ( \a a) and last element the upper value.

   */
   double Integral(const IGenFunction & f, const std::vector<double> & pts ) {
     SetFunction(f,false);
      return Integral(pts);
   }

   /**
      evaluate the Cauchy principal value of the integral of  a function f over the defined interval (a,b) with a singularity at c
      @param f integration function. The function type must be a C++ callable object implementing operator()(double x)
      @param a lower value of the integration interval
      @param b upper value of the integration interval
      @param c position of singularity

   */
   template<class Function>
   double IntegralCauchy(Function & f, double a, double b, double c);

   /**
      evaluate the Cauchy principal value of the integral of  a function f over the defined interval (a,b) with a singularity at c
       @param f integration function. The function type must implement the mathlib::IGenFunction interface
       @param a lower value of the integration interval
       @param b upper value of the integration interval
       @param c position of singularity

   */
   double IntegralCauchy(const IGenFunction & f, double a, double b, double c) {
     SetFunction(f,false);
      return IntegralCauchy(a,b,c);
   }



   // integration method using cached function

   /**
      evaluate the Integral over the defined interval (a,b) using the function previously set with Integrator::SetFunction method
      @param a lower value of the integration interval
      @param b upper value of the integration interval
   */

   double Integral(double a, double b) {
      return fIntegrator == 0 ? 0 : fIntegrator->Integral(a,b);
   }


   /**
      evaluate the Integral over the infinite interval (-inf,+inf) using the function previously set with Integrator::SetFunction method.
   */

   double Integral( ) {
      return fIntegrator == 0 ? 0 : fIntegrator->Integral();
   }

   /**
      evaluate the Integral of a function f over the semi-infinite interval (a,+inf) using the function previously set with Integrator::SetFunction method.
      @param a lower value of the integration interval
   */
   double IntegralUp(double a ) {
      return fIntegrator == 0 ? 0 : fIntegrator->IntegralUp(a);
   }

   /**
      evaluate the Integral of a function f over the over the semi-infinite interval (-inf,b) using the function previously set with Integrator::SetFunction method.
      @param b upper value of the integration interval
   */
   double IntegralLow( double b ) {
      return fIntegrator == 0 ? 0 : fIntegrator->IntegralLow(b);
   }
   /**
       define operator() for IntegralLow
    */
   double operator() (double x) {
      return IntegralLow(x);
   }


   /**
      evaluate the Integral over the defined interval (a,b) using the function previously set with Integrator::SetFunction method. The function has known singular points.
      @param pts vector containing both the function singular points and the lower/upper edges of the interval. The vector must have as first element the lower edge of the integration Integral ( \a a) and last element the upper value.

   */
   double Integral( const std::vector<double> & pts) {
      return fIntegrator == 0 ? 0 : fIntegrator->Integral(pts);
   }

   /**
      evaluate the Cauchy principal value of the integral of  a function f over the defined interval (a,b) with a singularity at c

   */
   double IntegralCauchy(double a, double b, double c) {
      return fIntegrator == 0 ? 0 : fIntegrator->IntegralCauchy(a,b,c);
   }

   /**
      return  the Result of the last Integral calculation
   */
   double Result() const { return fIntegrator == 0 ? 0 : fIntegrator->Result(); }

   /**
      return the estimate of the absolute Error of the last Integral calculation
   */
   double Error() const { return fIntegrator == 0 ? 0 : fIntegrator->Error(); }

   /**
      return the Error Status of the last Integral calculation
   */
   int Status() const { return fIntegrator == 0 ? -1 : fIntegrator->Status(); }

   /**
      return number of function evaluations in calculating the integral
      (if integrator do not implement this function returns -1)
   */
   int NEval() const { return fIntegrator == 0 ? -1 : fIntegrator->NEval(); }


   // setter for control Parameters  (getters are not needed so far )

   /**
      set the desired relative Error
   */
   void SetRelTolerance(double relTolerance) { if (fIntegrator) fIntegrator->SetRelTolerance(relTolerance); }


   /**
      set the desired absolute Error
   */
   void SetAbsTolerance(double absTolerance) { if (fIntegrator) fIntegrator->SetAbsTolerance(absTolerance); }

   /**
      return a pointer to integrator object
   */
   VirtualIntegratorOneDim * GetIntegrator() { return fIntegrator; }

   /**
       set the options
   */
   void SetOptions(const ROOT::Math::IntegratorOneDimOptions & opt) { if (fIntegrator) fIntegrator->SetOptions(opt); }

   /**
       retrieve the options
   */
   ROOT::Math::IntegratorOneDimOptions Options() const { return (fIntegrator) ? fIntegrator->Options() : IntegratorOneDimOptions(); }

   /// return name of integrator
   std::string Name() const { return (fIntegrator) ? Options().Integrator() : std::string(""); }

   /// static function to get the enumeration from a string
   static IntegrationOneDim::Type GetType(const char * name);

   /// static function to get a string from the enumeration
   static std::string GetName(IntegrationOneDim::Type);


protected:

   VirtualIntegratorOneDim * CreateIntegrator(IntegrationOneDim::Type type , double absTol, double relTol, unsigned int size, int rule);

private:

   VirtualIntegratorOneDim * fIntegrator;   // pointer to integrator interface class
   IGenFunction            * fFunc;         // pointer to owned function

};


   typedef IntegratorOneDim Integrator;


} // namespace Math
} // namespace ROOT


#ifndef __CINT__


#ifndef ROOT_Math_WrappedFunction
#include "Math/WrappedFunction.h"
#endif

template<class Function>
void ROOT::Math::IntegratorOneDim::SetFunction( Function & f) {
  ::ROOT::Math::WrappedFunction<Function &> wf(f);
  // need to copy the wrapper function, the instance created here will be deleted after SetFunction()
  SetFunction(wf, true);
}

template<class Function>
double ROOT::Math::IntegratorOneDim::Integral(Function & f, double a, double b) {
   ::ROOT::Math::WrappedFunction< Function &> wf(f);
   SetFunction(wf,false); // no copy is needed in this case
   return Integral(a,b);
}

// remove because can create ambiguities

// template<class Function>
// double ROOT::Math::IntegratorOneDim::Integral(const  Function & f) {
//    ROOT::Math::WrappedFunction<const Function &> wf(f);
//    SetFunction(wf,false); // no copy is needed in this case
//    return Integral();
// }

// template<class Function>
// double ROOT::Math::IntegratorOneDim::IntegralLow(Function  & f, double x) {
//    ROOT::Math::WrappedFunction< Function &> wf(f);
//    SetFunction(wf,false); // no copy is needed in this case
//    return IntegralLow(x);
// }

// template<class Function>
// double ROOT::Math::IntegratorOneDim::IntegralUp(Function & f, double x) {
//    ROOT::Math::WrappedFunction<Function &> wf(f);
//    SetFunction(wf,false); // no copy is needed in this case
//    return IntegralUp(x);
// }

template<class Function>
double ROOT::Math::IntegratorOneDim::Integral(Function & f, const std::vector<double> & pts) {
   ::ROOT::Math::WrappedFunction<Function &> wf(f);
   SetFunction(wf,false); // no copy is needed in this case
   return Integral(pts);
}

template<class Function>
double ROOT::Math::IntegratorOneDim::IntegralCauchy(Function & f, double a, double b, double c) {
   ::ROOT::Math::WrappedFunction<Function & > wf(f);
   SetFunction(wf,false); // no copy is needed in this case
   return IntegralCauchy(a,b,c);
}


#endif



#endif /* ROOT_Math_Integrator */
 Integrator.h:1
 Integrator.h:2
 Integrator.h:3
 Integrator.h:4
 Integrator.h:5
 Integrator.h:6
 Integrator.h:7
 Integrator.h:8
 Integrator.h:9
 Integrator.h:10
 Integrator.h:11
 Integrator.h:12
 Integrator.h:13
 Integrator.h:14
 Integrator.h:15
 Integrator.h:16
 Integrator.h:17
 Integrator.h:18
 Integrator.h:19
 Integrator.h:20
 Integrator.h:21
 Integrator.h:22
 Integrator.h:23
 Integrator.h:24
 Integrator.h:25
 Integrator.h:26
 Integrator.h:27
 Integrator.h:28
 Integrator.h:29
 Integrator.h:30
 Integrator.h:31
 Integrator.h:32
 Integrator.h:33
 Integrator.h:34
 Integrator.h:35
 Integrator.h:36
 Integrator.h:37
 Integrator.h:38
 Integrator.h:39
 Integrator.h:40
 Integrator.h:41
 Integrator.h:42
 Integrator.h:43
 Integrator.h:44
 Integrator.h:45
 Integrator.h:46
 Integrator.h:47
 Integrator.h:48
 Integrator.h:49
 Integrator.h:50
 Integrator.h:51
 Integrator.h:52
 Integrator.h:53
 Integrator.h:54
 Integrator.h:55
 Integrator.h:56
 Integrator.h:57
 Integrator.h:58
 Integrator.h:59
 Integrator.h:60
 Integrator.h:61
 Integrator.h:62
 Integrator.h:63
 Integrator.h:64
 Integrator.h:65
 Integrator.h:66
 Integrator.h:67
 Integrator.h:68
 Integrator.h:69
 Integrator.h:70
 Integrator.h:71
 Integrator.h:72
 Integrator.h:73
 Integrator.h:74
 Integrator.h:75
 Integrator.h:76
 Integrator.h:77
 Integrator.h:78
 Integrator.h:79
 Integrator.h:80
 Integrator.h:81
 Integrator.h:82
 Integrator.h:83
 Integrator.h:84
 Integrator.h:85
 Integrator.h:86
 Integrator.h:87
 Integrator.h:88
 Integrator.h:89
 Integrator.h:90
 Integrator.h:91
 Integrator.h:92
 Integrator.h:93
 Integrator.h:94
 Integrator.h:95
 Integrator.h:96
 Integrator.h:97
 Integrator.h:98
 Integrator.h:99
 Integrator.h:100
 Integrator.h:101
 Integrator.h:102
 Integrator.h:103
 Integrator.h:104
 Integrator.h:105
 Integrator.h:106
 Integrator.h:107
 Integrator.h:108
 Integrator.h:109
 Integrator.h:110
 Integrator.h:111
 Integrator.h:112
 Integrator.h:113
 Integrator.h:114
 Integrator.h:115
 Integrator.h:116
 Integrator.h:117
 Integrator.h:118
 Integrator.h:119
 Integrator.h:120
 Integrator.h:121
 Integrator.h:122
 Integrator.h:123
 Integrator.h:124
 Integrator.h:125
 Integrator.h:126
 Integrator.h:127
 Integrator.h:128
 Integrator.h:129
 Integrator.h:130
 Integrator.h:131
 Integrator.h:132
 Integrator.h:133
 Integrator.h:134
 Integrator.h:135
 Integrator.h:136
 Integrator.h:137
 Integrator.h:138
 Integrator.h:139
 Integrator.h:140
 Integrator.h:141
 Integrator.h:142
 Integrator.h:143
 Integrator.h:144
 Integrator.h:145
 Integrator.h:146
 Integrator.h:147
 Integrator.h:148
 Integrator.h:149
 Integrator.h:150
 Integrator.h:151
 Integrator.h:152
 Integrator.h:153
 Integrator.h:154
 Integrator.h:155
 Integrator.h:156
 Integrator.h:157
 Integrator.h:158
 Integrator.h:159
 Integrator.h:160
 Integrator.h:161
 Integrator.h:162
 Integrator.h:163
 Integrator.h:164
 Integrator.h:165
 Integrator.h:166
 Integrator.h:167
 Integrator.h:168
 Integrator.h:169
 Integrator.h:170
 Integrator.h:171
 Integrator.h:172
 Integrator.h:173
 Integrator.h:174
 Integrator.h:175
 Integrator.h:176
 Integrator.h:177
 Integrator.h:178
 Integrator.h:179
 Integrator.h:180
 Integrator.h:181
 Integrator.h:182
 Integrator.h:183
 Integrator.h:184
 Integrator.h:185
 Integrator.h:186
 Integrator.h:187
 Integrator.h:188
 Integrator.h:189
 Integrator.h:190
 Integrator.h:191
 Integrator.h:192
 Integrator.h:193
 Integrator.h:194
 Integrator.h:195
 Integrator.h:196
 Integrator.h:197
 Integrator.h:198
 Integrator.h:199
 Integrator.h:200
 Integrator.h:201
 Integrator.h:202
 Integrator.h:203
 Integrator.h:204
 Integrator.h:205
 Integrator.h:206
 Integrator.h:207
 Integrator.h:208
 Integrator.h:209
 Integrator.h:210
 Integrator.h:211
 Integrator.h:212
 Integrator.h:213
 Integrator.h:214
 Integrator.h:215
 Integrator.h:216
 Integrator.h:217
 Integrator.h:218
 Integrator.h:219
 Integrator.h:220
 Integrator.h:221
 Integrator.h:222
 Integrator.h:223
 Integrator.h:224
 Integrator.h:225
 Integrator.h:226
 Integrator.h:227
 Integrator.h:228
 Integrator.h:229
 Integrator.h:230
 Integrator.h:231
 Integrator.h:232
 Integrator.h:233
 Integrator.h:234
 Integrator.h:235
 Integrator.h:236
 Integrator.h:237
 Integrator.h:238
 Integrator.h:239
 Integrator.h:240
 Integrator.h:241
 Integrator.h:242
 Integrator.h:243
 Integrator.h:244
 Integrator.h:245
 Integrator.h:246
 Integrator.h:247
 Integrator.h:248
 Integrator.h:249
 Integrator.h:250
 Integrator.h:251
 Integrator.h:252
 Integrator.h:253
 Integrator.h:254
 Integrator.h:255
 Integrator.h:256
 Integrator.h:257
 Integrator.h:258
 Integrator.h:259
 Integrator.h:260
 Integrator.h:261
 Integrator.h:262
 Integrator.h:263
 Integrator.h:264
 Integrator.h:265
 Integrator.h:266
 Integrator.h:267
 Integrator.h:268
 Integrator.h:269
 Integrator.h:270
 Integrator.h:271
 Integrator.h:272
 Integrator.h:273
 Integrator.h:274
 Integrator.h:275
 Integrator.h:276
 Integrator.h:277
 Integrator.h:278
 Integrator.h:279
 Integrator.h:280
 Integrator.h:281
 Integrator.h:282
 Integrator.h:283
 Integrator.h:284
 Integrator.h:285
 Integrator.h:286
 Integrator.h:287
 Integrator.h:288
 Integrator.h:289
 Integrator.h:290
 Integrator.h:291
 Integrator.h:292
 Integrator.h:293
 Integrator.h:294
 Integrator.h:295
 Integrator.h:296
 Integrator.h:297
 Integrator.h:298
 Integrator.h:299
 Integrator.h:300
 Integrator.h:301
 Integrator.h:302
 Integrator.h:303
 Integrator.h:304
 Integrator.h:305
 Integrator.h:306
 Integrator.h:307
 Integrator.h:308
 Integrator.h:309
 Integrator.h:310
 Integrator.h:311
 Integrator.h:312
 Integrator.h:313
 Integrator.h:314
 Integrator.h:315
 Integrator.h:316
 Integrator.h:317
 Integrator.h:318
 Integrator.h:319
 Integrator.h:320
 Integrator.h:321
 Integrator.h:322
 Integrator.h:323
 Integrator.h:324
 Integrator.h:325
 Integrator.h:326
 Integrator.h:327
 Integrator.h:328
 Integrator.h:329
 Integrator.h:330
 Integrator.h:331
 Integrator.h:332
 Integrator.h:333
 Integrator.h:334
 Integrator.h:335
 Integrator.h:336
 Integrator.h:337
 Integrator.h:338
 Integrator.h:339
 Integrator.h:340
 Integrator.h:341
 Integrator.h:342
 Integrator.h:343
 Integrator.h:344
 Integrator.h:345
 Integrator.h:346
 Integrator.h:347
 Integrator.h:348
 Integrator.h:349
 Integrator.h:350
 Integrator.h:351
 Integrator.h:352
 Integrator.h:353
 Integrator.h:354
 Integrator.h:355
 Integrator.h:356
 Integrator.h:357
 Integrator.h:358
 Integrator.h:359
 Integrator.h:360
 Integrator.h:361
 Integrator.h:362
 Integrator.h:363
 Integrator.h:364
 Integrator.h:365
 Integrator.h:366
 Integrator.h:367
 Integrator.h:368
 Integrator.h:369
 Integrator.h:370
 Integrator.h:371
 Integrator.h:372
 Integrator.h:373
 Integrator.h:374
 Integrator.h:375
 Integrator.h:376
 Integrator.h:377
 Integrator.h:378
 Integrator.h:379
 Integrator.h:380
 Integrator.h:381
 Integrator.h:382
 Integrator.h:383
 Integrator.h:384
 Integrator.h:385
 Integrator.h:386
 Integrator.h:387
 Integrator.h:388
 Integrator.h:389
 Integrator.h:390
 Integrator.h:391
 Integrator.h:392
 Integrator.h:393
 Integrator.h:394
 Integrator.h:395
 Integrator.h:396
 Integrator.h:397
 Integrator.h:398
 Integrator.h:399
 Integrator.h:400
 Integrator.h:401
 Integrator.h:402
 Integrator.h:403
 Integrator.h:404
 Integrator.h:405
 Integrator.h:406
 Integrator.h:407
 Integrator.h:408
 Integrator.h:409
 Integrator.h:410
 Integrator.h:411
 Integrator.h:412
 Integrator.h:413
 Integrator.h:414
 Integrator.h:415
 Integrator.h:416
 Integrator.h:417
 Integrator.h:418
 Integrator.h:419
 Integrator.h:420
 Integrator.h:421
 Integrator.h:422
 Integrator.h:423
 Integrator.h:424
 Integrator.h:425
 Integrator.h:426
 Integrator.h:427
 Integrator.h:428
 Integrator.h:429
 Integrator.h:430
 Integrator.h:431
 Integrator.h:432
 Integrator.h:433
 Integrator.h:434
 Integrator.h:435
 Integrator.h:436
 Integrator.h:437
 Integrator.h:438
 Integrator.h:439
 Integrator.h:440
 Integrator.h:441
 Integrator.h:442
 Integrator.h:443
 Integrator.h:444
 Integrator.h:445
 Integrator.h:446
 Integrator.h:447
 Integrator.h:448
 Integrator.h:449
 Integrator.h:450
 Integrator.h:451
 Integrator.h:452
 Integrator.h:453
 Integrator.h:454
 Integrator.h:455
 Integrator.h:456
 Integrator.h:457
 Integrator.h:458
 Integrator.h:459
 Integrator.h:460
 Integrator.h:461
 Integrator.h:462
 Integrator.h:463
 Integrator.h:464
 Integrator.h:465
 Integrator.h:466
 Integrator.h:467
 Integrator.h:468
 Integrator.h:469
 Integrator.h:470
 Integrator.h:471
 Integrator.h:472
 Integrator.h:473
 Integrator.h:474
 Integrator.h:475
 Integrator.h:476
 Integrator.h:477
 Integrator.h:478
 Integrator.h:479
 Integrator.h:480
 Integrator.h:481
 Integrator.h:482
 Integrator.h:483
 Integrator.h:484
 Integrator.h:485
 Integrator.h:486
 Integrator.h:487
 Integrator.h:488
 Integrator.h:489
 Integrator.h:490
 Integrator.h:491
 Integrator.h:492
 Integrator.h:493
 Integrator.h:494
 Integrator.h:495
 Integrator.h:496
 Integrator.h:497
 Integrator.h:498
 Integrator.h:499
 Integrator.h:500
 Integrator.h:501
 Integrator.h:502
 Integrator.h:503
 Integrator.h:504
 Integrator.h:505
 Integrator.h:506
 Integrator.h:507
 Integrator.h:508
 Integrator.h:509
 Integrator.h:510
 Integrator.h:511
 Integrator.h:512
 Integrator.h:513
 Integrator.h:514
 Integrator.h:515
 Integrator.h:516
 Integrator.h:517
 Integrator.h:518
 Integrator.h:519
 Integrator.h:520
 Integrator.h:521
 Integrator.h:522
 Integrator.h:523
 Integrator.h:524
 Integrator.h:525
 Integrator.h:526
 Integrator.h:527
 Integrator.h:528
 Integrator.h:529
 Integrator.h:530
 Integrator.h:531
 Integrator.h:532
 Integrator.h:533
 Integrator.h:534