/usr/include/root/Math/VirtualIntegrator.h is in libroot-math-mathcore-dev 5.34.14-1build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 | // @(#)root/mathcore:$Id$
// Author: Magdalena Slawinska 10/2007
/**********************************************************************
* *
* Copyright (c) 2007 LCG ROOT Math Team, CERN/PH-SFT *
* *
* *
**********************************************************************/
// Header file for class Minimizer
#ifndef ROOT_Math_VirtualIntegrator
#define ROOT_Math_VirtualIntegrator
#ifndef ROOT_Math_IFunctionfwd
#include "Math/IFunctionfwd.h"
#endif
#ifndef ROOT_Math_Error
#include "Math/Error.h"
#endif
#ifndef ROOT_Math_IntegratorOptions
#include "Math/IntegratorOptions.h"
#endif
#include <vector>
namespace ROOT {
namespace Math {
//___________________________________________________________________
/**
Abstract class for all numerical integration methods (1D and multi-dim)
Interface defining the common methods for the
numerical integrator classes of one and multi dimensions
The derived class VirtualIntegratorOneDim defines the methods
for one-dimensional integration.
The derived class VirtualIntegratorMultiDim defines the method for
multi-dimensional integration.
The concrete classes for one dimension (e.g. GSLIntegrator) or
multi-dimension (e.g. GSLMCIntegrator) can be created using the
plug-in manager.
Users should not use directly this class but the concrete classes ROOT::Math::IntegratorOneDim or
ROOT::Math::IntegratorMultiDim
@ingroup Integration
*/
class VirtualIntegrator{
public:
// destructor: no operation
virtual ~VirtualIntegrator() {}
/**
set the desired relative Error
*/
virtual void SetRelTolerance(double ) = 0;
/**
set the desired absolute Error
*/
virtual void SetAbsTolerance(double ) = 0;
/**
return the Result of the last Integral calculation
*/
virtual double Result() const = 0;
/**
return the estimate of the absolute Error of the last Integral calculation
*/
virtual double Error() const = 0;
/**
return the Error Status of the last Integral calculation
*/
virtual int Status() const = 0;
/**
return number of function evaluations in calculating the integral
(if integrator do not implement this function returns -1)
*/
virtual int NEval() const { return -1; }
};
//___________________________________________________________________
/**
Interface (abstract) class for 1D numerical integration
It must be implemented by the concrate Integrator classes like
ROOT::Math::GSLIntegrator.
Plug-in's exist in ROOT to be able to instantiate the derived classes via the
plug-in manager.
Users should not use directly this class but the concrete classes ROOT::Math::IntegratorOneDim.
@ingroup Integration
*/
class VirtualIntegratorOneDim : public VirtualIntegrator {
public:
/// destructor: no operation
virtual ~VirtualIntegratorOneDim() {}
/// evaluate integral
virtual double Integral(double a, double b) = 0;
/// set integration function
virtual void SetFunction(const IGenFunction &) = 0;
/// evaluate un-defined integral (between -inf, + inf)
virtual double Integral() = 0;
/// evaluate integral over the (a, +inf)
virtual double IntegralUp(double a) = 0;
/// evaluate integral over the (-inf, b)
virtual double IntegralLow(double b) = 0;
/// evaluate integral with singular points
virtual double Integral( const std::vector<double> & pts) = 0;
/// evaluate Cauchy integral
virtual double IntegralCauchy(double a, double b, double c) = 0;
/// get the option used for the integration
/// must be implemented by derived class
virtual ROOT::Math::IntegratorOneDimOptions Options() const = 0;
// return type of integrator
virtual ROOT::Math::IntegrationOneDim::Type Type() const {
return Options().IntegratorType();
}
/// set the options
/// (should be re-implemented by derived classes -if more options than tolerance exist
virtual void SetOptions(const ROOT::Math::IntegratorOneDimOptions & opt) {
SetRelTolerance(opt.RelTolerance() );
SetAbsTolerance(opt.AbsTolerance() );
}
};
//___________________________________________________________________
/**
Interface (abstract) class for multi numerical integration
It must be implemented by the concrete Integrator classes like
ROOT::Math::GSLMCIntegrator.
Plug-in's exist in ROOT to be able to instantiate the derived classes via the
plug-in manager.
Users should not use directly this class but the concrete classes ROOT::Math::IntegratorMultiDim.
@ingroup Integration
*/
class VirtualIntegratorMultiDim : public VirtualIntegrator {
public:
/// destructor: no operation
virtual ~VirtualIntegratorMultiDim() {}
/// evaluate multi-dim integral
virtual double Integral(const double*, const double*) = 0;
/// setting a multi-dim function
virtual void SetFunction(const IMultiGenFunction &) = 0;
/// get the option used for the integration
/// impelement by derived class otherwise return default ones
virtual ROOT::Math::IntegratorMultiDimOptions Options() const = 0;
// return type of integrator
virtual ROOT::Math::IntegrationMultiDim::Type Type() const {
return Options().IntegratorType();
}
/// set the options (if needed must be re-implemented by derived classes)
virtual void SetOptions(const ROOT::Math::IntegratorMultiDimOptions & opt) {
SetRelTolerance(opt.RelTolerance() );
SetAbsTolerance(opt.AbsTolerance() );
}
};
}//namespace Math
}//namespace ROOT
#endif /* ROOT_Math_VirtualIntegrator */
|