Logo ROOT  
Reference Guide
IntegratorOptions.cxx
Go to the documentation of this file.
1// @(#)root/mathcore:$Id$
2// Author: L. Moneta Fri Aug 15 2008
3
4/**********************************************************************
5 * *
6 * Copyright (c) 2008 LCG ROOT Math Team, CERN/PH-SFT *
7 * *
8 * *
9 **********************************************************************/
10
12#include "Math/Integrator.h"
14#include "Math/GenAlgoOptions.h"
15
16#include "RConfigure.h"
17
18#include <algorithm>
19#include <functional>
20#include <ctype.h> // need to use c version of tolower defined here
21
22#include <map>
23
24namespace ROOT {
25
26namespace Math {
27
28 // eventually could take values from /etc/system.rootrc
29
30namespace IntegOneDim {
31
32#ifdef R__HAS_MATHMORE
34#else
36#endif
37 static double gDefaultAbsTolerance = 1.E-09;
38 static double gDefaultRelTolerance = 1.E-09;
39 static unsigned int gDefaultWKSize = 1000;
40 static unsigned int gDefaultNPointsLegendre = 10;
41 static unsigned int gDefaultNPointsGSLAdaptive = 3; // corresponds to 31 points
43
44
45}
46
47namespace IntegMultiDim {
48
50 // by default do not use absolute tolerance in AdaptiveIntegration multidim.
51 // If an absolute tolerance is given integration of shar peaks often failed
52 static double gDefaultAbsTolerance = 0.0;
53 static double gDefaultRelTolerance = 1.E-09;
54 static unsigned int gDefaultWKSize = 100000;
55 static unsigned int gDefaultNCalls = 100000;
56
57
58}
59
60
61// some utility functions
62
63namespace IntegOptionsUtil {
64
65
66 // traits for the specific methods 1D - ND
67 template<class OptionType>
68 struct OptionTrait {
69 static int N() { return 0; }
70 static int N(const OptionType & ) { return 0; }
71 static const char * DescriptionOfN() {return 0; }
72 };
73 template<>
76 static int N() { return OptType::DefaultNPoints(); }
77 static int N(const OptType & opt) { return opt.NPoints(); }
78 static const char * DescriptionOfN() {return "Rule (Npoints)";}
79 };
80 template<>
83 static int N() { return OptType::DefaultNCalls(); }
84 static int N(const OptType & opt) { return opt.NCalls(); }
85 static const char * DescriptionOfN() {return "(max) function calls";}
86 };
87
88
89 //print option values (not the default ones)
90 template <class OptionType>
91 void Print(std::ostream & os,const OptionType & opt) {
92 //print all the options
93 os << std::setw(25) << "Integrator Type" << " : " << std::setw(15) << opt.Integrator() << std::endl;
94 os << std::setw(25) << "Absolute tolerance" << " : " << std::setw(15) << opt.AbsTolerance() << std::endl;
95 os << std::setw(25) << "Relative tolerance" << " : " << std::setw(15) << opt.RelTolerance() << std::endl;
96 os << std::setw(25) << "Workspace size" << " : " << std::setw(15) << opt.WKSize() << std::endl;
98 os << std::setw(25) << OPT::DescriptionOfN() << " : " << std::setw(15) << OPT::N(opt) << std::endl;
99 if (opt.ExtraOptions()) {
100 os << opt.Integrator() << " specific options :" << std::endl;
101 opt.ExtraOptions()->Print(os);
102 }
103 }
104
105
106 /// print default options
107 template <class OptionType>
108 void PrintDefault(const char * name, std::ostream & os) {
109 //print default options
110 std::string integName = (name != 0) ? name : OptionType::DefaultIntegrator();
111 os << "Default options for numerical integrator " << integName << " : " << std::endl;
112 os << std::setw(25) << "Absolute tolerance" << " : " << std::setw(15) << OptionType::DefaultAbsTolerance() << std::endl;
113 os << std::setw(25) << "Relative tolerance" << " : " <<std::setw(15) << OptionType::DefaultRelTolerance() << std::endl;
114 os << std::setw(25) << "Workspace size" << " : " << std::setw(15) << OptionType::DefaultWKSize() << std::endl;
116 os << std::setw(25) << OPT::DescriptionOfN() << " : " << std::setw(15) << OPT::N() << std::endl;
117 IOptions * opts = GenAlgoOptions::FindDefault(integName.c_str());
118 if (opts) opts->Print(os);
119 }
120
121}
122
123
124/// constructor (protected) to avoid user creating this class
126 fIntegType(-1),
127 fWKSize(0), fNCalls(0),
128 fAbsTolerance(0), fRelTolerance(0),
129 fExtraOptions(0)
130{}
131
133 // copy constructor
134 (*this) = opt;
135}
136
138 // assignment operator
139 if (this == &opt) return *this; // self assignment
140 fWKSize = opt.fWKSize;
141 fNCalls = opt.fNCalls;
145
146// std::cout << " copy options for " << fIntegName << std::endl;
147// std::cout << fExtraOptions << std::endl;
148// if (fExtraOptions) fExtraOptions->Print(std::cout);
149
150// std::cout << opt.fExtraOptions << std::endl;
151// if (opt.fExtraOptions) (opt.fExtraOptions)->Print(std::cout);
152
153
154
155 ClearExtra();
156 if (opt.fExtraOptions) fExtraOptions = (opt.fExtraOptions)->Clone();
157 return *this;
158}
159
160
162 // delete extra options
163 if (fExtraOptions) delete fExtraOptions;
164 fExtraOptions = 0;
165}
166
168 // delete extra options
169 ClearExtra();
170 fExtraOptions = opt.Clone();
171}
172
173
174
175// one dim specific methods
176
177// implementation of non-static methods
178
181{
187
188 fExtraOptions = opts; // N.B. ownership of pointer is given to the class !
189
190 // check the default options if opts = 0
191 if (!fExtraOptions) {
192 std::string igname = DefaultIntegrator();
193 IOptions * gopts = FindDefault( igname.c_str() );
194 if (gopts) fExtraOptions = gopts->Clone();
195 }
196}
197
199 // set the default 1D integrator
200 if (!algo) return;
202}
203
206}
207
208void IntegratorOneDimOptions::Print(std::ostream & os) const {
209 //print all the options
210 IntegOptionsUtil::Print(os, *this);
211}
212
213// one dim integrator options: implementation for static methods
214
215/// print default options
216void IntegratorOneDimOptions::PrintDefault(const char * name, std::ostream & os) {
217 //print default options
218 IntegOptionsUtil::PrintDefault<IntegratorOneDimOptions>(name,os);
219}
220
221
222
224 // set the default 1D integrator
225 if (!algo) return;
227 if (type == IntegrationOneDim::kDEFAULT) return; // this is possible only when invalid name was specified
233}
234
235
237 // return default integrator name
239}
240
242 // return default integrator type (enum)
244}
245
246
248 // set the default tolerance
250}
252 // set the default tolerance
254}
255
257 // set the default workspace size
259}
261 // set the default number of points for the integration rule
263}
264
265
270
271
273 // create default extra options for the given algorithm type
274 return GenAlgoOptions::Default(algo);
275}
276
278 // find extra options for the given algorithm type
279 return GenAlgoOptions::FindDefault(algo);
280}
281
282//////////////////////////////////////////////////////
283//Multi-dim integration options implementation
284/////////////////////////////////////////////////////////
285
288{
294
295 fExtraOptions = opts; // N.B. ownership of pointer is given to the class !
296
297 // check the default options if opts = 0
298 if (!fExtraOptions) {
299 IOptions * gopts = FindDefault( DefaultIntegrator().c_str() );
300 if (gopts) fExtraOptions = gopts->Clone();
301 }
302}
303
305 // set the default integrator
306 if (!algo) return;
308}
309
312}
313
314void IntegratorMultiDimOptions::Print(std::ostream & os) const {
315 //print all the options
316 IntegOptionsUtil::Print(os, *this);
317}
318
319// multi dim integrator options: implementation for static methods
320
321/// print default options
322void IntegratorMultiDimOptions::PrintDefault(const char * name, std::ostream & os) {
323 //print default options
324 IntegOptionsUtil::PrintDefault<IntegratorMultiDimOptions>(name,os);
325}
326
327
329 // set the default integrator
330 if (!algo) return;
331 // check if type is correct
333 if (type == IntegrationMultiDim::kDEFAULT) return; // this is possible only when invalid name was specified
335}
336
337
339 // return default integrator name
341}
342
344 // return default integrator type (enum)
346}
347
348
350 // set the default tolerance
352}
353
355 // set the default tolerance
357}
358
360 // set the default workspace size
362}
364 // set the default (max) function calls
366}
367
368
373
374
376 // create default extra options for the given algorithm type
377 return GenAlgoOptions::Default(algo);
378}
379
381 // create default extra options for the given algorithm type
382 return GenAlgoOptions::FindDefault(algo);
383}
384
385
386} // end namespace Math
387
388} // end namespace ROOT
389
#define OPT
Definition: Match.cxx:38
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
#define N
int type
Definition: TGX11.cxx:121
Base class for Numerical integration options common in 1D and multi-dimension This is an internal cla...
int fIntegType
Integrator type (value converted from enum)
BaseIntegratorOptions()
protected constructor to avoid user creating this class
ROOT::Math::IOptions * fExtraOptions
void SetExtraOptions(const IOptions &opt)
set extra options (in this case pointer is cloned)
double fAbsTolerance
absolute tolerance
double fRelTolerance
relative tolerance
BaseIntegratorOptions & operator=(const BaseIntegratorOptions &opt)
assignment operators
unsigned int fNCalls
(max) function calls
unsigned int fWKSize
workspace size
static IOptions & Default(const char *algoname)
static IOptions * FindDefault(const char *algoname)
Generic interface for defining configuration options of a numerical algorithm.
Definition: IOptions.h:31
virtual IOptions * Clone() const =0
virtual void Print(std::ostream &=std::cout) const
print options
Definition: IOptions.h:99
Numerical multi dimensional integration options.
static void SetDefaultAbsTolerance(double tol)
IntegratorMultiDimOptions(IOptions *extraOpts=0)
constructor using the default options can pass a pointer to extra options (N.B.
static void SetDefaultWKSize(unsigned int size)
static void SetDefaultIntegrator(const char *name)
void Print(std::ostream &os=std::cout) const
print all the options
static void SetDefaultNCalls(unsigned int ncall)
static ROOT::Math::IOptions * FindDefault(const char *name)
find specific options - return 0 if not existing
void SetIntegrator(const char *name)
set multi-dim integrator name
static IntegrationMultiDim::Type DefaultIntegratorType()
static ROOT::Math::IOptions & Default(const char *name)
retrieve specific options
static void SetDefaultRelTolerance(double tol)
static void PrintDefault(const char *name=0, std::ostream &os=std::cout)
print only the specified default options
unsigned int NCalls() const
maximum number of function calls
std::string Integrator() const
name of multi-dim integrator
static std::string GetName(IntegrationMultiDim::Type)
static function to get a string from the enumeration
Definition: Integrator.cxx:90
static IntegrationMultiDim::Type GetType(const char *name)
static function to get the enumeration from a string
Definition: Integrator.cxx:78
Numerical one dimensional integration options.
static void SetDefaultNPoints(unsigned int n)
static void SetDefaultAbsTolerance(double tol)
void Print(std::ostream &os=std::cout) const
print all the options
void SetIntegrator(const char *name)
set 1D integrator name
static void SetDefaultRelTolerance(double tol)
std::string Integrator() const
name of 1D integrator
static void SetDefaultIntegrator(const char *name)
static void PrintDefault(const char *name=0, std::ostream &os=std::cout)
print only the specified default options
IntegratorOneDimOptions(IOptions *extraOpts=0)
constructor using the default options can pass a pointer to extra options (N.B.
static ROOT::Math::IOptions & Default(const char *name)
retrieve specific options - if not existing create a IOptions
static void SetDefaultWKSize(unsigned int size)
static IntegrationOneDim::Type DefaultIntegratorType()
static ROOT::Math::IOptions * FindDefault(const char *name)
find specific options - return 0 if not existing
unsigned int NPoints() const
Number of points used by current integration rule.
static std::string GetName(IntegrationOneDim::Type)
static function to get a string from the enumeration
Definition: Integrator.cxx:66
static IntegrationOneDim::Type GetType(const char *name)
static function to get the enumeration from a string
Definition: Integrator.cxx:53
Type
enumeration specifying the integration types.
@ kADAPTIVESINGULAR
default adaptive integration type which can be used in the case of the presence of singularities.
@ kLEGENDRE
Gauss-Legendre integration.
@ kADAPTIVE
to be used for general functions without singularities
@ kGAUSS
simple Gauss integration method with fixed rule
@ kDEFAULT
default type specifiend in the static options
Type
enumeration specifying the integration types.
@ kADAPTIVE
adaptive multi-dimensional integration
@ kDEFAULT
default type specified in the static option
const Int_t n
Definition: legend1.C:16
Namespace for new Math classes and functions.
static unsigned int gDefaultNCalls
static unsigned int gDefaultWKSize
static double gDefaultAbsTolerance
static unsigned int gDefaultWKSize
static unsigned int gDefaultNPoints
static unsigned int gDefaultNPointsGSLAdaptive
static double gDefaultRelTolerance
static unsigned int gDefaultNPointsLegendre
void PrintDefault(const char *name, std::ostream &os)
print default options
void Print(std::ostream &os, const OptionType &opt)
static const std::string name("name")
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
Definition: RNumpyDS.hxx:30