| The Gaudi Framework v29r1 (5cd95fa2)

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

NumericalIndefiniteIntegral.cpp
Go to the documentation of this file.
1 // ============================================================================
2 // Include
3 // ============================================================================
4 // STD & STL
5 // ============================================================================
6 #include <algorithm>
7 #include <vector>
8 // ============================================================================
9 // GSL
10 // ============================================================================
11 #include "gsl/gsl_errno.h"
12 #include "gsl/gsl_integration.h"
13 // ============================================================================
14 // GaudiMath
15 // ============================================================================
16 #include "GaudiMath/NumericalDerivative.h"
17 #include "GaudiMath/NumericalIndefiniteIntegral.h"
18 // ============================================================================
19 // GaudiKernel
20 // ============================================================================
21 #include "GaudiKernel/GaudiException.h"
22 // ============================================================================
23 // local
24 // ============================================================================
25 #include "Helpers.h"
26 // ============================================================================
27
28 // ============================================================================
33 // ============================================================================
34
35 #ifdef __ICC
36 // disable icc remark #1572: floating-point equality and inequality comparisons are unreliable
37 // The comparison are meant
38 #pragma warning( disable : 1572 )
39 #endif
40 #ifdef WIN32
41 // Disable the warning
42 // C4996: 'std::copy': Function call with parameters that may be unsafe
43 // The parameters are checked
44 #pragma warning( disable : 4996 )
45 #endif
46
47 namespace Genfun
48 {
49 namespace GaudiMathImplementation
50 {
51
52 struct NumericalIndefiniteIntegral::_Function {
53 gsl_function* fn;
54 };
55
56 // ========================================================================
57
58 // ========================================================================
73 // ========================================================================
74 NumericalIndefiniteIntegral::NumericalIndefiniteIntegral( const AbsFunction& function, const size_t index,
75 const double a, const GaudiMath::Integration::Limit limit,
76 const GaudiMath::Integration::Type type,
77 const GaudiMath::Integration::KronrodRule rule,
78 const double epsabs, const double epsrel,
79 const size_t size )
80 : AbsFunction()
81 , m_function( function.clone() )
82 , m_DIM( function.dimensionality() )
83 , m_index( index )
84 , m_a( a )
85 , m_limit( limit )
86 , m_type( type )
87 , m_category( GaudiMath::Integration::Finite )
88 , m_rule( rule )
89 //
90 , m_epsabs( epsabs )
91 , m_epsrel( epsrel )
92 //
93 , m_size( size )
94 , m_argument( function.dimensionality() )
95 {
96 if ( GaudiMath::Integration::Fixed == m_rule ) {
97 m_rule = GaudiMath::Integration::Default;
98 }
99 if ( m_index >= m_DIM ) {
100 Exception( "::constructor: invalid variable index" );
101 }
102 }
103 // ========================================================================
104
115 NumericalIndefiniteIntegral::NumericalIndefiniteIntegral( const AbsFunction& function, const size_t index,
116 const double a, const Points& points,
117 const GaudiMath::Integration::Limit limit,
118 const double epsabs, const double epsrel,
119 const size_t size )
120 : AbsFunction()
121 , m_function( function.clone() )
122 , m_DIM( function.dimensionality() )
123 , m_index( index )
124 , m_a( a )
125 , m_limit( limit )
126 , m_type( GaudiMath::Integration::Other )
127 , m_category( GaudiMath::Integration::Singular )
128 , m_rule( GaudiMath::Integration::Fixed )
129 , m_points( points )
130 , m_epsabs( epsabs )
131 , m_epsrel( epsrel )
132 //
133 , m_size( size )
134 , m_argument( function.dimensionality() )
135 {
136 if ( m_index >= m_DIM ) {
137 Exception( "::constructor: invalid variable index" );
138 }
139 m_points.push_back( a );
140 std::sort( m_points.begin(), m_points.end() );
141 m_points.erase( std::unique( m_points.begin(), m_points.end() ), m_points.end() );
142 }
143
144 // ========================================================================
152 // ========================================================================
153 NumericalIndefiniteIntegral::NumericalIndefiniteIntegral( const AbsFunction& function, const size_t index,
154 const GaudiMath::Integration::Limit limit,
155 const double epsabs, const double epsrel,
156 const size_t size )
157 : AbsFunction()
158 , m_function( function.clone() )
159 , m_DIM( function.dimensionality() )
160 , m_index( index )
161 , m_a( GSL_NEGINF ) // should not be used!
162 , m_limit( limit )
163 , m_type( GaudiMath::Integration::Other )
164 , m_category( GaudiMath::Integration::Infinite )
165 , m_rule( GaudiMath::Integration::Fixed )
166 , m_epsabs( epsabs )
167 , m_epsrel( epsrel )
168 , m_size( size )
169 , m_argument( function.dimensionality() )
170 {
171 if ( m_index >= m_DIM ) {
172 Exception( "::constructor: invalid variable index" );
173 }
174 }
175 // ========================================================================
176
177 // ========================================================================
179 // ========================================================================
180 NumericalIndefiniteIntegral::NumericalIndefiniteIntegral( const NumericalIndefiniteIntegral& right )
181 : AbsFunction()
182 , m_function( right.m_function->clone() )
183 , m_DIM( right.m_DIM )
184 , m_index( right.m_index )
185 , m_a( right.m_a )
186 , m_limit( right.m_limit )
187 , m_type( right.m_type )
188 , m_category( right.m_category )
189 , m_rule( right.m_rule )
190 , m_points( right.m_points )
191 , m_epsabs( right.m_epsabs )
192 , m_epsrel( right.m_epsrel )
193 , m_size( right.m_size )
194 , m_argument( right.m_argument )
195 {
196 }
197 // ========================================================================
198
199 // ========================================================================
200 // throw the exception
201 // ========================================================================
202 StatusCode NumericalIndefiniteIntegral::Exception( const std::string& message, const StatusCode& sc ) const
203 {
204 throw GaudiException( "NumericalIndefiniteIntegral::" + message, "*GaudiMath*", sc );
205 return sc;
206 }
207 // ========================================================================
208
209 // ========================================================================
211 // ========================================================================
212 double NumericalIndefiniteIntegral::operator()( const double argument ) const
213 {
214 // reset the result and the error
215 m_result = GSL_NEGINF;
216 m_error = GSL_POSINF;
217
218 // check the argument
219 if ( 1 != m_DIM ) {
220 Exception( "operator(): invalid argument size " );
221 };
222
223 m_argument[0] = argument;
224 return ( *this )( m_argument );
225 }
226 // ========================================================================
227
228 // ========================================================================
230 // ========================================================================
231 Genfun::Derivative NumericalIndefiniteIntegral::partial( unsigned int idx ) const
232 {
233 if ( idx >= m_DIM ) {
234 Exception( "::partial(i): invalid variable index " );
235 };
236 if ( idx != m_index ) {
237 const AbsFunction& aux = NumericalDerivative( *this, idx );
238 return Genfun::FunctionNoop( &aux );
239 } else if ( GaudiMath::Integration::VariableLowLimit == limit() ) {
240 const AbsFunction& aux = -1 * function();
241 return Genfun::FunctionNoop( &aux );
242 }
243 const AbsFunction& aux = function();
244 return Genfun::FunctionNoop( &aux );
245 }
246
247 // ========================================================================
249 // ========================================================================
250 double NumericalIndefiniteIntegral::operator()( const Argument& argument ) const
251 {
252 // reset the result and the error
253 m_result = GSL_NEGINF;
254 m_error = GSL_POSINF;
255
256 // check the argument
257 if ( argument.dimension() != m_DIM ) {
258 Exception( "operator(): invalid argument size " );
259 };
260
261 // copy the argument
262 for ( size_t i = 0; i < m_DIM; ++i ) {
263 m_argument[i] = argument[i];
264 }
265
266 // create the helper object
267 GSL_Helper helper( *m_function, m_argument, m_index );
268
269 // use GSL to evaluate the numerical derivative
270 gsl_function F;
271 F.function = &GSL_Adaptor;
272 F.params = &helper;
273 _Function F1;
274 F1.fn = &F;
275
276 switch ( category() ) {
277 case GaudiMath::Integration::Infinite:
278 return QAGI( &F1 );
279 case GaudiMath::Integration::Singular:
280 return QAGP( &F1 );
281 case GaudiMath::Integration::Finite:
282 switch ( type() ) {
283 case GaudiMath::Integration::NonAdaptive:
284 return QNG( &F1 );
285 case GaudiMath::Integration::Adaptive:
286 return QAG( &F1 );
287 case GaudiMath::Integration::AdaptiveSingular:
288 return QAGS( &F1 );
289 default:
290 Exception( "::operator(): invalid type " );
291 }
292 break;
293 default:
294 Exception( "::operator(): invalid category " );
295 }
296 return 0;
297 }
298 // ========================================================================
299
300 // ========================================================================
302 // ========================================================================
303 NumericalIndefiniteIntegral::_Workspace* NumericalIndefiniteIntegral::allocate() const
304 {
305 if ( !m_ws ) {
306 m_ws.reset( new _Workspace() );
307 m_ws->ws = gsl_integration_workspace_alloc( size() );
308 if ( !m_ws->ws ) {
309 Exception( "allocate()::invalid workspace" );
310 };
311 }
312 return m_ws.get();
313 }
314 // ========================================================================
315
316 // ========================================================================
317 // adaptive integration on infinite interval
318 // ========================================================================
319 double NumericalIndefiniteIntegral::QAGI( _Function* F ) const
320 {
321 // check the argument
322 if ( !F ) {
323 Exception( "::QAGI: invalid function" );
324 }
325
326 const double x = m_argument[m_index];
327
328 // allocate workspace
329 allocate();
330
331 int ierror = 0;
332 switch ( limit() ) {
333 case GaudiMath::Integration::VariableLowLimit:
334 ierror = gsl_integration_qagiu( F->fn, x, m_epsabs, m_epsrel, size(), ws()->ws, &m_result, &m_error );
335 break;
336 case GaudiMath::Integration::VariableHighLimit:
337 ierror = gsl_integration_qagil( F->fn, x, m_epsabs, m_epsrel, size(), ws()->ws, &m_result, &m_error );
338 break;
339 default:
340 Exception( "::QAGI: invalid mode" );
341 };
342
343 if ( ierror ) {
344 gsl_error( "NumericalIndefiniteIntegral::QAGI", __FILE__, __LINE__, ierror );
345 }
346
347 return m_result;
348 }
349 // ========================================================================
350
351 // ========================================================================
352 // adaptive integration with known singular points
353 // ========================================================================
354 double NumericalIndefiniteIntegral::QAGP( _Function* F ) const
355 {
356 if ( !F ) {
357 Exception( "QAGP::invalid function" );
358 }
359
360 const double x = m_argument[m_index];
361 if ( m_a == x ) {
362 m_result = 0;
363 m_error = 0; // EXACT !
364 return m_result;
365 }
366
367 // no known singular points ?
368 if ( points().empty() ) {
369 return QAGS( F );
370 }
371
372 // integration limits
373 const auto limits = std::minmax( m_a, x );
374
375 // "active" singular points
376 auto lower = std::lower_bound( points().begin(), points().end(), limits.first );
377 auto upper = std::upper_bound( points().begin(), points().end(), limits.second );
378
379 Points pnts;
380 pnts.reserve( std::distance( lower, upper ) );
381 std::copy( lower, upper, std::back_inserter( pnts ) );
382 if ( *lower != limits.first ) {
383 pnts.insert( pnts.begin(), limits.first );
384 }
385 if ( *upper != limits.second ) {
386 pnts.insert( pnts.end(), limits.second );
387 }
388
389 // use GSL
390 int ierror = gsl_integration_qagp( F->fn, pnts.data(), pnts.size(), m_epsabs, m_epsrel, size(), ws()->ws,
391 &m_result, &m_error );
392
393 if ( ierror ) {
394 gsl_error( "NumericalIndefiniteIntegral::QAGI ", __FILE__, __LINE__, ierror );
395 }
396
397 // sign
398 if ( GaudiMath::Integration::VariableHighLimit == limit() && x < m_a ) {
399 m_result *= -1;
400 } else if ( GaudiMath::Integration::VariableLowLimit == limit() && x > m_a ) {
401 m_result *= -1;
402 }
403
404 return m_result;
405 }
406 // ========================================================================
407
408 // ========================================================================
409 // non-adaptive integration
410 // ========================================================================
411 double NumericalIndefiniteIntegral::QNG( _Function* F ) const
412 {
413 if ( !F ) {
414 Exception( "QNG::invalid function" );
415 }
416
417 const double x = m_argument[m_index];
418 if ( m_a == x ) {
419 m_result = 0;
420 m_error = 0; // EXACT !
421 return m_result;
422 }
423
424 // integration limits
425 const double a = std::min( m_a, x );
426 const double b = std::max( m_a, x );
427
428 size_t neval = 0;
429 int ierror = gsl_integration_qng( F->fn, a, b, m_epsabs, m_epsrel, &m_result, &m_error, &neval );
430
431 if ( ierror ) {
432 gsl_error( "NumericalIndefiniteIntegral::QNG ", __FILE__, __LINE__, ierror );
433 }
434
435 // sign
436 if ( GaudiMath::Integration::VariableHighLimit == limit() && x < m_a ) {
437 m_result *= -1;
438 } else if ( GaudiMath::Integration::VariableLowLimit == limit() && x > m_a ) {
439 m_result *= -1;
440 }
441
442 return m_result;
443 }
444
445 // ========================================================================
446 // simple adaptive integration
447 // ========================================================================
448 double NumericalIndefiniteIntegral::QAG( _Function* F ) const
449 {
450 if ( !F ) {
451 Exception( "QAG::invalid function" );
452 }
453
454 const double x = m_argument[m_index];
455 if ( m_a == x ) {
456 m_result = 0;
457 m_error = 0; // EXACT !
458 return m_result;
459 }
460
461 // allocate workspace
462 allocate();
463
464 // integration limits
465 const auto limits = std::minmax( m_a, x );
466
467 int ierror = gsl_integration_qag( F->fn, limits.first, limits.second, m_epsabs, m_epsrel, size(), (int)rule(),
468 ws()->ws, &m_result, &m_error );
469
470 if ( ierror ) {
471 gsl_error( "NumericalIndefiniteIntegral::QAG ", __FILE__, __LINE__, ierror );
472 }
473
474 // sign
475 if ( GaudiMath::Integration::VariableHighLimit == limit() && x < m_a ) {
476 m_result *= -1;
477 } else if ( GaudiMath::Integration::VariableLowLimit == limit() && x > m_a ) {
478 m_result *= -1;
479 }
480
481 return m_result;
482 }
483 // ========================================================================
484
485 // ========================================================================
486 // adaptive integration with singularities
487 // ========================================================================
488 double NumericalIndefiniteIntegral::QAGS( _Function* F ) const
489 {
490 if ( !F ) {
491 Exception( "QAG::invalid function" );
492 }
493
494 const double x = m_argument[m_index];
495 if ( m_a == x ) {
496 m_result = 0;
497 m_error = 0; // EXACT !
498 return m_result;
499 }
500
501 // allocate workspace
502 allocate();
503
504 // integration limits
505 const auto limits = std::minmax( m_a, x );
506
507 int ierror = gsl_integration_qags( F->fn, limits.first, limits.second, m_epsabs, m_epsrel, size(), ws()->ws,
508 &m_result, &m_error );
509
510 if ( ierror ) {
511 gsl_error( "NumericalIndefiniteIntegral::QAGS ", __FILE__, __LINE__, ierror );
512 }
513
514 // sign
515 if ( GaudiMath::Integration::VariableHighLimit == limit() && x < m_a ) {
516 m_result *= -1;
517 } else if ( GaudiMath::Integration::VariableLowLimit == limit() && x > m_a ) {
518 m_result *= -1;
519 }
520
521 return m_result;
522 }
523 // ========================================================================
524 } // end of namespace GaudiMathImplementation
525 } // end of namespace Genfun
526
527 // ============================================================================
528 // The END
529 // ============================================================================
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::partial
Genfun::Derivative partial(unsigned int index) const override
Derivatives.
Definition: NumericalIndefiniteIntegral.cpp:231
std::copy
T copy(T...args)
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_error
double m_error
Definition: NumericalIndefiniteIntegral.h:360
GaudiException
Define general base for Gaudi exception.
Definition: GaudiException.h:22
std::distance
T distance(T...args)
std::minmax
T minmax(T...args)
GaudiMath::Integration::Finite
Definition: Integration.h:26
GaudiMath::Integration::Other
Definition: Integration.h:24
NumericalIndefiniteIntegral.h
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::epsrel
double epsrel() const
relatiove precision
Definition: NumericalIndefiniteIntegral.h:288
GaudiMath::Integration::NonAdaptive
Definition: Integration.h:24
GaudiMath::Integration::Fixed
Definition: Integration.h:29
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::Exception
StatusCode Exception(const std::string &message, const StatusCode &sc=StatusCode::FAILURE) const
Definition: NumericalIndefiniteIntegral.cpp:202
std::upper_bound
T upper_bound(T...args)
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::QAGI
double QAGI(_Function *fun) const
Definition: NumericalIndefiniteIntegral.cpp:319
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_index
size_t m_index
Definition: NumericalIndefiniteIntegral.h:345
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_a
double m_a
Definition: NumericalIndefiniteIntegral.h:347
std::vector::end
T end(T...args)
GaudiMath::Integration::Adaptive
Definition: Integration.h:24
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::limit
GaudiMath::Integration::Limit limit() const
integration limit
Definition: NumericalIndefiniteIntegral.h:299
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::size
size_t size() const
Definition: NumericalIndefiniteIntegral.h:296
GaudiMath::Derivative
Genfun::GaudiMathImplementation::NumericalDerivative Derivative
Definition: GaudiMath.h:27
std::lower_bound
T lower_bound(T...args)
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace::ws
gsl_integration_workspace * ws
Definition: NumericalIndefiniteIntegral.h:86
GaudiMath::Integration::Singular
Definition: Integration.h:26
std::unique
T unique(T...args)
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::category
GaudiMath::Integration::Category category() const
integration category
Definition: NumericalIndefiniteIntegral.h:303
begin
auto begin(reverse_wrapper< T > &w)
Definition: reverse.h:58
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Function::fn
gsl_function * fn
Definition: NumericalIndefiniteIntegral.cpp:53
std::string
STL class.
std::min
T min(T...args)
NumericalDerivative.h
std::vector::push_back
T push_back(T...args)
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_epsabs
double m_epsabs
Definition: NumericalIndefiniteIntegral.h:356
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_size
size_t m_size
Definition: NumericalIndefiniteIntegral.h:362
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::QAGS
double QAGS(_Function *fun) const
Definition: NumericalIndefiniteIntegral.cpp:488
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_DIM
size_t m_DIM
Definition: NumericalIndefiniteIntegral.h:344
std::vector::data
T data(T...args)
GaudiMath::Integration::Infinite
Definition: Integration.h:26
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::rule
GaudiMath::Integration::KronrodRule rule() const
integration rule
Definition: NumericalIndefiniteIntegral.h:305
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Function
Definition: NumericalIndefiniteIntegral.cpp:52
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:28
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::allocate
_Workspace * allocate() const
allocate the integration workspace
Definition: NumericalIndefiniteIntegral.cpp:303
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::operator()
double operator()(double argument) const override
Function value.
Definition: NumericalIndefiniteIntegral.cpp:212
GaudiMath::Integration::Type
Type
type of integration (for finite limits)
Definition: Integration.h:24
GaudiException.h
GaudiMath::Integration::VariableHighLimit
Definition: Integration.h:22
std::vector::erase
T erase(T...args)
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::QNG
double QNG(_Function *fun) const
Definition: NumericalIndefiniteIntegral.cpp:411
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_epsrel
double m_epsrel
Definition: NumericalIndefiniteIntegral.h:357
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace
Definition: NumericalIndefiniteIntegral.h:85
end
auto end(reverse_wrapper< T > &w)
Definition: reverse.h:64
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::epsabs
double epsabs() const
absolute precision
Definition: NumericalIndefiniteIntegral.h:286
Genfun::GaudiMathImplementation::GSL_Adaptor
double GSL_Adaptor(double x, void *params)
Definition: Helpers.cpp:31
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::QAG
double QAG(_Function *fun) const
Definition: NumericalIndefiniteIntegral.cpp:448
GaudiMath::Integration::Default
Definition: Integration.h:36
std::max
T max(T...args)
Genfun::GaudiMathImplementation::NumericalDerivative
Numerical derivative (using GSL adaptive numerical differentiation)
Definition: NumericalDerivative.h:42
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_limit
GaudiMath::Integration::Limit m_limit
Definition: NumericalIndefiniteIntegral.h:349
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_category
GaudiMath::Integration::Category m_category
Definition: NumericalIndefiniteIntegral.h:351
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::dimensionality
unsigned int dimensionality() const override
dimensionality of the problem
Definition: NumericalIndefiniteIntegral.h:265
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::type
GaudiMath::Integration::Type type() const
integration type
Definition: NumericalIndefiniteIntegral.h:301
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_function
std::unique_ptr< const AbsFunction > m_function
Definition: NumericalIndefiniteIntegral.h:343
std::vector::insert
T insert(T...args)
std::vector::size
T size(T...args)
std::vector< double >
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::a
double a() const
integration limit
Definition: NumericalIndefiniteIntegral.h:282
std::vector::begin
T begin(T...args)
Helpers.h
GaudiMath::Integration::AdaptiveSingular
Definition: Integration.h:24
std::back_inserter
T back_inserter(T...args)
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_type
GaudiMath::Integration::Type m_type
Definition: NumericalIndefiniteIntegral.h:350
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::function
const AbsFunction & function() const
accessor to the function itself
Definition: NumericalIndefiniteIntegral.h:280
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_argument
Argument m_argument
Definition: NumericalIndefiniteIntegral.h:365
GaudiMath::Integration::Limit
Limit
how to distinguish variable low and variable high limits
Definition: Integration.h:22
GaudiMath
GaudiMath.h GaudiMath/GaudiMath.h.
Definition: Adapters.h:13
GaudiMath::Integration::KronrodRule
KronrodRule
integration rule
Definition: Integration.h:28
std::sort
T sort(T...args)
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_rule
GaudiMath::Integration::KronrodRule m_rule
Definition: NumericalIndefiniteIntegral.h:352
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_ws
std::unique_ptr< _Workspace, gsl_ws_deleter > m_ws
Definition: NumericalIndefiniteIntegral.h:363
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_result
double m_result
Definition: NumericalIndefiniteIntegral.h:359
Genfun
CLHEP.
Definition: IEqSolver.h:13
GaudiMath::Integration::VariableLowLimit
Definition: Integration.h:22
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::QAGP
double QAGP(_Function *fun) const
Definition: NumericalIndefiniteIntegral.cpp:354
Genfun::GaudiMathImplementation::GSL_Helper
the simple structure to be used for adaption interface Genfun::AbsFunction to gsl_function structure ...
Definition: Helpers.h:25
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::NumericalIndefiniteIntegral
NumericalIndefiniteIntegral()
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral
The simple class for numerical integrations.
Definition: NumericalIndefiniteIntegral.h:82
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::points
const Points & points() const
known singularities
Definition: NumericalIndefiniteIntegral.h:284
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::ws
_Workspace * ws() const
Definition: NumericalIndefiniteIntegral.h:322
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::m_points
Points m_points
Definition: NumericalIndefiniteIntegral.h:354
std::vector::reserve
T reserve(T...args)
Integration
collection of common types for classes NumericalIndefiniteIntegral and NumericalDefiniteIntegral ...