The Gaudi Framework  v30r3 (a5ef0a68)
GaudiGSLMathDict.cpp
Go to the documentation of this file.
1 // Do NOT change. Changes will be lost next time file is generated
2 
3 #define R__DICTIONARY_FILENAME GaudiGSLMathDict
4 
5 /*******************************************************************/
6 #include <stddef.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include <assert.h>
11 #define G__DICTIONARY
12 #include "RConfig.h"
13 #include "TClass.h"
14 #include "TDictAttributeMap.h"
15 #include "TInterpreter.h"
16 #include "TROOT.h"
17 #include "TBuffer.h"
18 #include "TMemberInspector.h"
19 #include "TInterpreter.h"
20 #include "TVirtualMutex.h"
21 #include "TError.h"
22 
23 #ifndef G__ROOT
24 #define G__ROOT
25 #endif
26 
27 #include "RtypesImp.h"
28 #include "TIsAProxy.h"
29 #include "TFileMergeInfo.h"
30 #include <algorithm>
31 #include "TCollectionProxyInfo.h"
32 /*******************************************************************/
33 
34 #include "TDataMember.h"
35 
36 // Since CINT ignores the std namespace, we need to do so in this file.
37 namespace std {} using namespace std;
38 
39 // Header files passed as explicit arguments
40 #include "/builds/gaudi/Gaudi/GaudiGSL/dict/GaudiGSLMath.h"
41 
42 // Header files passed via #pragma extra_include
43 
44 namespace Genfun {
45  namespace GaudiMathImplementation {
46  namespace ROOT {
47  inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
48  static TClass *GenfuncLcLGaudiMathImplementation_Dictionary();
49 
50  // Function generating the singleton type initializer
51  inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
52  {
53  static ::ROOT::TGenericClassInfo
54  instance("Genfun::GaudiMathImplementation", 0 /*version*/, "GaudiMath/FunAdapters.h", 42,
55  ::ROOT::Internal::DefineBehavior((void*)0,(void*)0),
56  &GenfuncLcLGaudiMathImplementation_Dictionary, 0);
57  return &instance;
58  }
59  // Insure that the inline function is _not_ optimized away by the compiler
60  ::ROOT::TGenericClassInfo *(*_R__UNIQUE_DICT_(InitFunctionKeeper))() = &GenerateInitInstance;
61  // Static variable to force the class initialization
62  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_DICT_(Init));
63 
64  // Dictionary for non-ClassDef classes
65  static TClass *GenfuncLcLGaudiMathImplementation_Dictionary() {
66  return GenerateInitInstance()->GetClass();
67  }
68 
69  }
70 }
71 }
72 
73 namespace GaudiMath {
74  namespace Integration {
75  namespace ROOT {
76  inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
77  static TClass *GaudiMathcLcLIntegration_Dictionary();
78 
79  // Function generating the singleton type initializer
80  inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
81  {
82  static ::ROOT::TGenericClassInfo
83  instance("GaudiMath::Integration", 0 /*version*/, "GaudiMath/Integration.h", 17,
84  ::ROOT::Internal::DefineBehavior((void*)0,(void*)0),
85  &GaudiMathcLcLIntegration_Dictionary, 0);
86  return &instance;
87  }
88  // Insure that the inline function is _not_ optimized away by the compiler
89  ::ROOT::TGenericClassInfo *(*_R__UNIQUE_DICT_(InitFunctionKeeper))() = &GenerateInitInstance;
90  // Static variable to force the class initialization
91  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_DICT_(Init));
92 
93  // Dictionary for non-ClassDef classes
94  static TClass *GaudiMathcLcLIntegration_Dictionary() {
95  return GenerateInitInstance()->GetClass();
96  }
97 
98  }
99 }
100 }
101 
102 namespace GaudiMath {
103  namespace Interpolation {
104  namespace ROOT {
105  inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
106  static TClass *GaudiMathcLcLInterpolation_Dictionary();
107 
108  // Function generating the singleton type initializer
109  inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
110  {
111  static ::ROOT::TGenericClassInfo
112  instance("GaudiMath::Interpolation", 0 /*version*/, "GaudiMath/Interpolation.h", 13,
113  ::ROOT::Internal::DefineBehavior((void*)0,(void*)0),
114  &GaudiMathcLcLInterpolation_Dictionary, 0);
115  return &instance;
116  }
117  // Insure that the inline function is _not_ optimized away by the compiler
118  ::ROOT::TGenericClassInfo *(*_R__UNIQUE_DICT_(InitFunctionKeeper))() = &GenerateInitInstance;
119  // Static variable to force the class initialization
120  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_DICT_(Init));
121 
122  // Dictionary for non-ClassDef classes
123  static TClass *GaudiMathcLcLInterpolation_Dictionary() {
124  return GenerateInitInstance()->GetClass();
125  }
126 
127  }
128 }
129 }
130 
131 namespace Genfun {
132  namespace GaudiMathImplementation {
133  namespace details {
134  namespace ROOT {
135  inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
136  static TClass *GenfuncLcLGaudiMathImplementationcLcLdetails_Dictionary();
137 
138  // Function generating the singleton type initializer
139  inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
140  {
141  static ::ROOT::TGenericClassInfo
142  instance("Genfun::GaudiMathImplementation::details", 0 /*version*/, "GaudiMath/Splines.h", 39,
143  ::ROOT::Internal::DefineBehavior((void*)0,(void*)0),
144  &GenfuncLcLGaudiMathImplementationcLcLdetails_Dictionary, 0);
145  return &instance;
146  }
147  // Insure that the inline function is _not_ optimized away by the compiler
148  ::ROOT::TGenericClassInfo *(*_R__UNIQUE_DICT_(InitFunctionKeeper))() = &GenerateInitInstance;
149  // Static variable to force the class initialization
150  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_DICT_(Init));
151 
152  // Dictionary for non-ClassDef classes
153  static TClass *GenfuncLcLGaudiMathImplementationcLcLdetails_Dictionary() {
154  return GenerateInitInstance()->GetClass();
155  }
156 
157  }
158 }
159 }
160 }
161 
162 namespace ROOT {
163  static TClass *GenfuncLcLGaudiMathImplementationcLcLAdapterIFunction_Dictionary();
164  static void GenfuncLcLGaudiMathImplementationcLcLAdapterIFunction_TClassManip(TClass*);
165  static void delete_GenfuncLcLGaudiMathImplementationcLcLAdapterIFunction(void *p);
166  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLAdapterIFunction(void *p);
167  static void destruct_GenfuncLcLGaudiMathImplementationcLcLAdapterIFunction(void *p);
168 
169  // Function generating the singleton type initializer
170  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::AdapterIFunction*)
171  {
172  ::Genfun::GaudiMathImplementation::AdapterIFunction *ptr = 0;
173  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::AdapterIFunction));
174  static ::ROOT::TGenericClassInfo
175  instance("Genfun::GaudiMathImplementation::AdapterIFunction", "GaudiMath/FunAdapters.h", 53,
176  typeid(::Genfun::GaudiMathImplementation::AdapterIFunction), ::ROOT::Internal::DefineBehavior(ptr, ptr),
177  &GenfuncLcLGaudiMathImplementationcLcLAdapterIFunction_Dictionary, isa_proxy, 4,
178  sizeof(::Genfun::GaudiMathImplementation::AdapterIFunction) );
179  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLAdapterIFunction);
180  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLAdapterIFunction);
181  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLAdapterIFunction);
182  return &instance;
183  }
184  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::AdapterIFunction*)
185  {
186  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::AdapterIFunction*)0);
187  }
188  // Static variable to force the class initialization
189  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::AdapterIFunction*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
190 
191  // Dictionary for non-ClassDef classes
192  static TClass *GenfuncLcLGaudiMathImplementationcLcLAdapterIFunction_Dictionary() {
193  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::AdapterIFunction*)0x0)->GetClass();
194  GenfuncLcLGaudiMathImplementationcLcLAdapterIFunction_TClassManip(theClass);
195  return theClass;
196  }
197 
198  static void GenfuncLcLGaudiMathImplementationcLcLAdapterIFunction_TClassManip(TClass* ){
199  }
200 
201 } // end of namespace ROOT
202 
203 namespace ROOT {
204  static TClass *GenfuncLcLGaudiMathImplementationcLcLAdapter2DoubleFunction_Dictionary();
205  static void GenfuncLcLGaudiMathImplementationcLcLAdapter2DoubleFunction_TClassManip(TClass*);
206  static void delete_GenfuncLcLGaudiMathImplementationcLcLAdapter2DoubleFunction(void *p);
207  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLAdapter2DoubleFunction(void *p);
208  static void destruct_GenfuncLcLGaudiMathImplementationcLcLAdapter2DoubleFunction(void *p);
209 
210  // Function generating the singleton type initializer
211  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::Adapter2DoubleFunction*)
212  {
213  ::Genfun::GaudiMathImplementation::Adapter2DoubleFunction *ptr = 0;
214  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::Adapter2DoubleFunction));
215  static ::ROOT::TGenericClassInfo
216  instance("Genfun::GaudiMathImplementation::Adapter2DoubleFunction", "GaudiMath/FunAdapters.h", 111,
217  typeid(::Genfun::GaudiMathImplementation::Adapter2DoubleFunction), ::ROOT::Internal::DefineBehavior(ptr, ptr),
218  &GenfuncLcLGaudiMathImplementationcLcLAdapter2DoubleFunction_Dictionary, isa_proxy, 4,
219  sizeof(::Genfun::GaudiMathImplementation::Adapter2DoubleFunction) );
220  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLAdapter2DoubleFunction);
221  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLAdapter2DoubleFunction);
222  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLAdapter2DoubleFunction);
223  return &instance;
224  }
225  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::Adapter2DoubleFunction*)
226  {
227  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::Adapter2DoubleFunction*)0);
228  }
229  // Static variable to force the class initialization
230  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::Adapter2DoubleFunction*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
231 
232  // Dictionary for non-ClassDef classes
233  static TClass *GenfuncLcLGaudiMathImplementationcLcLAdapter2DoubleFunction_Dictionary() {
234  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::Adapter2DoubleFunction*)0x0)->GetClass();
235  GenfuncLcLGaudiMathImplementationcLcLAdapter2DoubleFunction_TClassManip(theClass);
236  return theClass;
237  }
238 
239  static void GenfuncLcLGaudiMathImplementationcLcLAdapter2DoubleFunction_TClassManip(TClass* ){
240  }
241 
242 } // end of namespace ROOT
243 
244 namespace ROOT {
245  static TClass *GenfuncLcLGaudiMathImplementationcLcLAdapter3DoubleFunction_Dictionary();
246  static void GenfuncLcLGaudiMathImplementationcLcLAdapter3DoubleFunction_TClassManip(TClass*);
247  static void delete_GenfuncLcLGaudiMathImplementationcLcLAdapter3DoubleFunction(void *p);
248  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLAdapter3DoubleFunction(void *p);
249  static void destruct_GenfuncLcLGaudiMathImplementationcLcLAdapter3DoubleFunction(void *p);
250 
251  // Function generating the singleton type initializer
252  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::Adapter3DoubleFunction*)
253  {
254  ::Genfun::GaudiMathImplementation::Adapter3DoubleFunction *ptr = 0;
255  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::Adapter3DoubleFunction));
256  static ::ROOT::TGenericClassInfo
257  instance("Genfun::GaudiMathImplementation::Adapter3DoubleFunction", "GaudiMath/FunAdapters.h", 174,
258  typeid(::Genfun::GaudiMathImplementation::Adapter3DoubleFunction), ::ROOT::Internal::DefineBehavior(ptr, ptr),
259  &GenfuncLcLGaudiMathImplementationcLcLAdapter3DoubleFunction_Dictionary, isa_proxy, 4,
260  sizeof(::Genfun::GaudiMathImplementation::Adapter3DoubleFunction) );
261  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLAdapter3DoubleFunction);
262  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLAdapter3DoubleFunction);
263  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLAdapter3DoubleFunction);
264  return &instance;
265  }
266  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::Adapter3DoubleFunction*)
267  {
268  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::Adapter3DoubleFunction*)0);
269  }
270  // Static variable to force the class initialization
271  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::Adapter3DoubleFunction*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
272 
273  // Dictionary for non-ClassDef classes
274  static TClass *GenfuncLcLGaudiMathImplementationcLcLAdapter3DoubleFunction_Dictionary() {
275  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::Adapter3DoubleFunction*)0x0)->GetClass();
276  GenfuncLcLGaudiMathImplementationcLcLAdapter3DoubleFunction_TClassManip(theClass);
277  return theClass;
278  }
279 
280  static void GenfuncLcLGaudiMathImplementationcLcLAdapter3DoubleFunction_TClassManip(TClass* ){
281  }
282 
283 } // end of namespace ROOT
284 
285 namespace ROOT {
286  static TClass *GenfuncLcLGaudiMathImplementationcLcLSimpleFunction_Dictionary();
287  static void GenfuncLcLGaudiMathImplementationcLcLSimpleFunction_TClassManip(TClass*);
288  static void delete_GenfuncLcLGaudiMathImplementationcLcLSimpleFunction(void *p);
289  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLSimpleFunction(void *p);
290  static void destruct_GenfuncLcLGaudiMathImplementationcLcLSimpleFunction(void *p);
291 
292  // Function generating the singleton type initializer
293  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::SimpleFunction*)
294  {
295  ::Genfun::GaudiMathImplementation::SimpleFunction *ptr = 0;
296  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::SimpleFunction));
297  static ::ROOT::TGenericClassInfo
298  instance("Genfun::GaudiMathImplementation::SimpleFunction", "GaudiMath/FunAdapters.h", 220,
299  typeid(::Genfun::GaudiMathImplementation::SimpleFunction), ::ROOT::Internal::DefineBehavior(ptr, ptr),
300  &GenfuncLcLGaudiMathImplementationcLcLSimpleFunction_Dictionary, isa_proxy, 4,
301  sizeof(::Genfun::GaudiMathImplementation::SimpleFunction) );
302  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLSimpleFunction);
303  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLSimpleFunction);
304  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLSimpleFunction);
305  return &instance;
306  }
307  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::SimpleFunction*)
308  {
309  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::SimpleFunction*)0);
310  }
311  // Static variable to force the class initialization
312  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::SimpleFunction*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
313 
314  // Dictionary for non-ClassDef classes
315  static TClass *GenfuncLcLGaudiMathImplementationcLcLSimpleFunction_Dictionary() {
316  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::SimpleFunction*)0x0)->GetClass();
317  GenfuncLcLGaudiMathImplementationcLcLSimpleFunction_TClassManip(theClass);
318  return theClass;
319  }
320 
321  static void GenfuncLcLGaudiMathImplementationcLcLSimpleFunction_TClassManip(TClass* ){
322  }
323 
324 } // end of namespace ROOT
325 
326 namespace ROOT {
327  static TClass *GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithError_Dictionary();
328  static void GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithError_TClassManip(TClass*);
329  static void delete_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithError(void *p);
330  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithError(void *p);
331  static void destruct_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithError(void *p);
332 
333  // Function generating the singleton type initializer
334  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::GSLFunctionWithError*)
335  {
336  ::Genfun::GaudiMathImplementation::GSLFunctionWithError *ptr = 0;
337  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::GSLFunctionWithError));
338  static ::ROOT::TGenericClassInfo
339  instance("Genfun::GaudiMathImplementation::GSLFunctionWithError", "GaudiMath/GSLFunAdapters.h", 40,
340  typeid(::Genfun::GaudiMathImplementation::GSLFunctionWithError), ::ROOT::Internal::DefineBehavior(ptr, ptr),
341  &GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithError_Dictionary, isa_proxy, 4,
342  sizeof(::Genfun::GaudiMathImplementation::GSLFunctionWithError) );
343  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithError);
344  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithError);
345  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithError);
346  return &instance;
347  }
348  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::GSLFunctionWithError*)
349  {
350  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::GSLFunctionWithError*)0);
351  }
352  // Static variable to force the class initialization
353  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::GSLFunctionWithError*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
354 
355  // Dictionary for non-ClassDef classes
356  static TClass *GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithError_Dictionary() {
357  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::GSLFunctionWithError*)0x0)->GetClass();
358  GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithError_TClassManip(theClass);
359  return theClass;
360  }
361 
362  static void GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithError_TClassManip(TClass* ){
363  }
364 
365 } // end of namespace ROOT
366 
367 namespace ROOT {
368  static TClass *GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithMode_Dictionary();
369  static void GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithMode_TClassManip(TClass*);
370  static void delete_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithMode(void *p);
371  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithMode(void *p);
372  static void destruct_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithMode(void *p);
373 
374  // Function generating the singleton type initializer
375  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::GSLFunctionWithMode*)
376  {
377  ::Genfun::GaudiMathImplementation::GSLFunctionWithMode *ptr = 0;
378  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::GSLFunctionWithMode));
379  static ::ROOT::TGenericClassInfo
380  instance("Genfun::GaudiMathImplementation::GSLFunctionWithMode", "GaudiMath/GSLFunAdapters.h", 81,
381  typeid(::Genfun::GaudiMathImplementation::GSLFunctionWithMode), ::ROOT::Internal::DefineBehavior(ptr, ptr),
382  &GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithMode_Dictionary, isa_proxy, 4,
383  sizeof(::Genfun::GaudiMathImplementation::GSLFunctionWithMode) );
384  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithMode);
385  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithMode);
386  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithMode);
387  return &instance;
388  }
389  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::GSLFunctionWithMode*)
390  {
391  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::GSLFunctionWithMode*)0);
392  }
393  // Static variable to force the class initialization
394  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::GSLFunctionWithMode*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
395 
396  // Dictionary for non-ClassDef classes
397  static TClass *GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithMode_Dictionary() {
398  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::GSLFunctionWithMode*)0x0)->GetClass();
399  GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithMode_TClassManip(theClass);
400  return theClass;
401  }
402 
403  static void GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithMode_TClassManip(TClass* ){
404  }
405 
406 } // end of namespace ROOT
407 
408 namespace ROOT {
409  static TClass *GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithModeAndError_Dictionary();
410  static void GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithModeAndError_TClassManip(TClass*);
411  static void delete_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithModeAndError(void *p);
412  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithModeAndError(void *p);
413  static void destruct_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithModeAndError(void *p);
414 
415  // Function generating the singleton type initializer
416  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError*)
417  {
418  ::Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError *ptr = 0;
419  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError));
420  static ::ROOT::TGenericClassInfo
421  instance("Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError", "GaudiMath/GSLFunAdapters.h", 119,
422  typeid(::Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError), ::ROOT::Internal::DefineBehavior(ptr, ptr),
423  &GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithModeAndError_Dictionary, isa_proxy, 4,
424  sizeof(::Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError) );
425  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithModeAndError);
426  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithModeAndError);
427  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithModeAndError);
428  return &instance;
429  }
430  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError*)
431  {
432  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError*)0);
433  }
434  // Static variable to force the class initialization
435  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
436 
437  // Dictionary for non-ClassDef classes
438  static TClass *GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithModeAndError_Dictionary() {
439  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError*)0x0)->GetClass();
440  GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithModeAndError_TClassManip(theClass);
441  return theClass;
442  }
443 
444  static void GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithModeAndError_TClassManip(TClass* ){
445  }
446 
447 } // end of namespace ROOT
448 
449 namespace ROOT {
450  static TClass *GenfuncLcLGaudiMathImplementationcLcLConstant_Dictionary();
451  static void GenfuncLcLGaudiMathImplementationcLcLConstant_TClassManip(TClass*);
452  static void delete_GenfuncLcLGaudiMathImplementationcLcLConstant(void *p);
453  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLConstant(void *p);
454  static void destruct_GenfuncLcLGaudiMathImplementationcLcLConstant(void *p);
455 
456  // Function generating the singleton type initializer
457  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::Constant*)
458  {
459  ::Genfun::GaudiMathImplementation::Constant *ptr = 0;
460  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::Constant));
461  static ::ROOT::TGenericClassInfo
462  instance("Genfun::GaudiMathImplementation::Constant", "GaudiMath/Constant.h", 31,
463  typeid(::Genfun::GaudiMathImplementation::Constant), ::ROOT::Internal::DefineBehavior(ptr, ptr),
464  &GenfuncLcLGaudiMathImplementationcLcLConstant_Dictionary, isa_proxy, 4,
465  sizeof(::Genfun::GaudiMathImplementation::Constant) );
466  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLConstant);
467  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLConstant);
468  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLConstant);
469  return &instance;
470  }
471  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::Constant*)
472  {
473  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::Constant*)0);
474  }
475  // Static variable to force the class initialization
476  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::Constant*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
477 
478  // Dictionary for non-ClassDef classes
479  static TClass *GenfuncLcLGaudiMathImplementationcLcLConstant_Dictionary() {
480  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::Constant*)0x0)->GetClass();
481  GenfuncLcLGaudiMathImplementationcLcLConstant_TClassManip(theClass);
482  return theClass;
483  }
484 
485  static void GenfuncLcLGaudiMathImplementationcLcLConstant_TClassManip(TClass* ){
486  }
487 
488 } // end of namespace ROOT
489 
490 namespace ROOT {
491  static TClass *GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegral_Dictionary();
492  static void GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegral_TClassManip(TClass*);
493  static void delete_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegral(void *p);
494  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegral(void *p);
495  static void destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegral(void *p);
496 
497  // Function generating the singleton type initializer
498  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral*)
499  {
500  ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral *ptr = 0;
501  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral));
502  static ::ROOT::TGenericClassInfo
503  instance("Genfun::GaudiMathImplementation::NumericalDefiniteIntegral", "GaudiMath/NumericalDefiniteIntegral.h", 80,
504  typeid(::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral), ::ROOT::Internal::DefineBehavior(ptr, ptr),
505  &GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegral_Dictionary, isa_proxy, 4,
506  sizeof(::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral) );
507  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegral);
508  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegral);
509  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegral);
510  return &instance;
511  }
512  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral*)
513  {
514  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral*)0);
515  }
516  // Static variable to force the class initialization
517  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
518 
519  // Dictionary for non-ClassDef classes
520  static TClass *GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegral_Dictionary() {
521  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral*)0x0)->GetClass();
522  GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegral_TClassManip(theClass);
523  return theClass;
524  }
525 
526  static void GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegral_TClassManip(TClass* ){
527  }
528 
529 } // end of namespace ROOT
530 
531 namespace ROOT {
532  static TClass *GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace_Dictionary();
533  static void GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace_TClassManip(TClass*);
534  static void *new_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace(void *p = 0);
535  static void *newArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace(Long_t size, void *p);
536  static void delete_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace(void *p);
537  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace(void *p);
538  static void destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace(void *p);
539 
540  // Function generating the singleton type initializer
541  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace*)
542  {
543  ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace *ptr = 0;
544  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace));
545  static ::ROOT::TGenericClassInfo
546  instance("Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace", "GaudiMath/NumericalDefiniteIntegral.h", 83,
547  typeid(::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace), ::ROOT::Internal::DefineBehavior(ptr, ptr),
548  &GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace_Dictionary, isa_proxy, 4,
549  sizeof(::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace) );
550  instance.SetNew(&new_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace);
551  instance.SetNewArray(&newArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace);
552  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace);
553  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace);
554  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace);
555  return &instance;
556  }
557  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace*)
558  {
559  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace*)0);
560  }
561  // Static variable to force the class initialization
562  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
563 
564  // Dictionary for non-ClassDef classes
565  static TClass *GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace_Dictionary() {
566  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace*)0x0)->GetClass();
567  GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace_TClassManip(theClass);
568  return theClass;
569  }
570 
571  static void GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace_TClassManip(TClass* ){
572  }
573 
574 } // end of namespace ROOT
575 
576 namespace ROOT {
577  static TClass *GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter_Dictionary();
578  static void GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter_TClassManip(TClass*);
579  static void *new_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter(void *p = 0);
580  static void *newArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter(Long_t size, void *p);
581  static void delete_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter(void *p);
582  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter(void *p);
583  static void destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter(void *p);
584 
585  // Function generating the singleton type initializer
586  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter*)
587  {
588  ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter *ptr = 0;
589  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter));
590  static ::ROOT::TGenericClassInfo
591  instance("Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter", "GaudiMath/NumericalDefiniteIntegral.h", 345,
592  typeid(::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter), ::ROOT::Internal::DefineBehavior(ptr, ptr),
593  &GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter_Dictionary, isa_proxy, 4,
594  sizeof(::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter) );
595  instance.SetNew(&new_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter);
596  instance.SetNewArray(&newArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter);
597  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter);
598  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter);
599  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter);
600  return &instance;
601  }
602  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter*)
603  {
604  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter*)0);
605  }
606  // Static variable to force the class initialization
607  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
608 
609  // Dictionary for non-ClassDef classes
610  static TClass *GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter_Dictionary() {
611  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter*)0x0)->GetClass();
612  GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter_TClassManip(theClass);
613  return theClass;
614  }
615 
616  static void GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter_TClassManip(TClass* ){
617  }
618 
619 } // end of namespace ROOT
620 
621 namespace ROOT {
622  static TClass *GenfuncLcLGaudiMathImplementationcLcLNumericalDerivative_Dictionary();
623  static void GenfuncLcLGaudiMathImplementationcLcLNumericalDerivative_TClassManip(TClass*);
624  static void delete_GenfuncLcLGaudiMathImplementationcLcLNumericalDerivative(void *p);
625  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDerivative(void *p);
626  static void destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalDerivative(void *p);
627 
628  // Function generating the singleton type initializer
629  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::NumericalDerivative*)
630  {
631  ::Genfun::GaudiMathImplementation::NumericalDerivative *ptr = 0;
632  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::NumericalDerivative));
633  static ::ROOT::TGenericClassInfo
634  instance("Genfun::GaudiMathImplementation::NumericalDerivative", "GaudiMath/NumericalDerivative.h", 44,
635  typeid(::Genfun::GaudiMathImplementation::NumericalDerivative), ::ROOT::Internal::DefineBehavior(ptr, ptr),
636  &GenfuncLcLGaudiMathImplementationcLcLNumericalDerivative_Dictionary, isa_proxy, 4,
637  sizeof(::Genfun::GaudiMathImplementation::NumericalDerivative) );
638  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLNumericalDerivative);
639  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDerivative);
640  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalDerivative);
641  return &instance;
642  }
643  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::NumericalDerivative*)
644  {
645  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::NumericalDerivative*)0);
646  }
647  // Static variable to force the class initialization
648  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::NumericalDerivative*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
649 
650  // Dictionary for non-ClassDef classes
651  static TClass *GenfuncLcLGaudiMathImplementationcLcLNumericalDerivative_Dictionary() {
652  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::NumericalDerivative*)0x0)->GetClass();
653  GenfuncLcLGaudiMathImplementationcLcLNumericalDerivative_TClassManip(theClass);
654  return theClass;
655  }
656 
657  static void GenfuncLcLGaudiMathImplementationcLcLNumericalDerivative_TClassManip(TClass* ){
658  }
659 
660 } // end of namespace ROOT
661 
662 namespace ROOT {
663  static TClass *GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegral_Dictionary();
664  static void GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegral_TClassManip(TClass*);
665  static void delete_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegral(void *p);
666  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegral(void *p);
667  static void destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegral(void *p);
668 
669  // Function generating the singleton type initializer
670  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral*)
671  {
672  ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral *ptr = 0;
673  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral));
674  static ::ROOT::TGenericClassInfo
675  instance("Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral", "GaudiMath/NumericalIndefiniteIntegral.h", 83,
676  typeid(::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral), ::ROOT::Internal::DefineBehavior(ptr, ptr),
677  &GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegral_Dictionary, isa_proxy, 4,
678  sizeof(::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral) );
679  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegral);
680  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegral);
681  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegral);
682  return &instance;
683  }
684  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral*)
685  {
686  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral*)0);
687  }
688  // Static variable to force the class initialization
689  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
690 
691  // Dictionary for non-ClassDef classes
692  static TClass *GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegral_Dictionary() {
693  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral*)0x0)->GetClass();
694  GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegral_TClassManip(theClass);
695  return theClass;
696  }
697 
698  static void GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegral_TClassManip(TClass* ){
699  }
700 
701 } // end of namespace ROOT
702 
703 namespace ROOT {
704  static TClass *GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace_Dictionary();
705  static void GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace_TClassManip(TClass*);
706  static void *new_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace(void *p = 0);
707  static void *newArray_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace(Long_t size, void *p);
708  static void delete_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace(void *p);
709  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace(void *p);
710  static void destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace(void *p);
711 
712  // Function generating the singleton type initializer
713  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace*)
714  {
715  ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace *ptr = 0;
716  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace));
717  static ::ROOT::TGenericClassInfo
718  instance("Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace", "GaudiMath/NumericalIndefiniteIntegral.h", 86,
719  typeid(::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace), ::ROOT::Internal::DefineBehavior(ptr, ptr),
720  &GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace_Dictionary, isa_proxy, 4,
721  sizeof(::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace) );
722  instance.SetNew(&new_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace);
723  instance.SetNewArray(&newArray_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace);
724  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace);
725  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace);
726  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace);
727  return &instance;
728  }
729  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace*)
730  {
731  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace*)0);
732  }
733  // Static variable to force the class initialization
734  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
735 
736  // Dictionary for non-ClassDef classes
737  static TClass *GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace_Dictionary() {
738  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace*)0x0)->GetClass();
739  GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace_TClassManip(theClass);
740  return theClass;
741  }
742 
743  static void GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace_TClassManip(TClass* ){
744  }
745 
746 } // end of namespace ROOT
747 
748 namespace ROOT {
749  static TClass *GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter_Dictionary();
750  static void GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter_TClassManip(TClass*);
751  static void *new_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter(void *p = 0);
752  static void *newArray_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter(Long_t size, void *p);
753  static void delete_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter(void *p);
754  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter(void *p);
755  static void destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter(void *p);
756 
757  // Function generating the singleton type initializer
758  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter*)
759  {
760  ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter *ptr = 0;
761  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter));
762  static ::ROOT::TGenericClassInfo
763  instance("Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter", "GaudiMath/NumericalIndefiniteIntegral.h", 332,
764  typeid(::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter), ::ROOT::Internal::DefineBehavior(ptr, ptr),
765  &GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter_Dictionary, isa_proxy, 4,
766  sizeof(::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter) );
767  instance.SetNew(&new_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter);
768  instance.SetNewArray(&newArray_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter);
769  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter);
770  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter);
771  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter);
772  return &instance;
773  }
774  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter*)
775  {
776  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter*)0);
777  }
778  // Static variable to force the class initialization
779  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
780 
781  // Dictionary for non-ClassDef classes
782  static TClass *GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter_Dictionary() {
783  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter*)0x0)->GetClass();
784  GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter_TClassManip(theClass);
785  return theClass;
786  }
787 
788  static void GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter_TClassManip(TClass* ){
789  }
790 
791 } // end of namespace ROOT
792 
793 namespace ROOT {
794  static TClass *GenfuncLcLGaudiMathImplementationcLcLSplineBase_Dictionary();
795  static void GenfuncLcLGaudiMathImplementationcLcLSplineBase_TClassManip(TClass*);
796  static void delete_GenfuncLcLGaudiMathImplementationcLcLSplineBase(void *p);
797  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLSplineBase(void *p);
798  static void destruct_GenfuncLcLGaudiMathImplementationcLcLSplineBase(void *p);
799 
800  // Function generating the singleton type initializer
801  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::SplineBase*)
802  {
803  ::Genfun::GaudiMathImplementation::SplineBase *ptr = 0;
804  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::SplineBase));
805  static ::ROOT::TGenericClassInfo
806  instance("Genfun::GaudiMathImplementation::SplineBase", "GaudiMath/Splines.h", 53,
807  typeid(::Genfun::GaudiMathImplementation::SplineBase), ::ROOT::Internal::DefineBehavior(ptr, ptr),
808  &GenfuncLcLGaudiMathImplementationcLcLSplineBase_Dictionary, isa_proxy, 4,
809  sizeof(::Genfun::GaudiMathImplementation::SplineBase) );
810  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLSplineBase);
811  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLSplineBase);
812  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLSplineBase);
813  return &instance;
814  }
815  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::SplineBase*)
816  {
817  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::SplineBase*)0);
818  }
819  // Static variable to force the class initialization
820  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::SplineBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
821 
822  // Dictionary for non-ClassDef classes
823  static TClass *GenfuncLcLGaudiMathImplementationcLcLSplineBase_Dictionary() {
824  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::SplineBase*)0x0)->GetClass();
825  GenfuncLcLGaudiMathImplementationcLcLSplineBase_TClassManip(theClass);
826  return theClass;
827  }
828 
829  static void GenfuncLcLGaudiMathImplementationcLcLSplineBase_TClassManip(TClass* ){
830  }
831 
832 } // end of namespace ROOT
833 
834 namespace ROOT {
835  static TClass *GenfuncLcLGaudiMathImplementationcLcLGSLSpline_Dictionary();
836  static void GenfuncLcLGaudiMathImplementationcLcLGSLSpline_TClassManip(TClass*);
837  static void delete_GenfuncLcLGaudiMathImplementationcLcLGSLSpline(void *p);
838  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLSpline(void *p);
839  static void destruct_GenfuncLcLGaudiMathImplementationcLcLGSLSpline(void *p);
840 
841  // Function generating the singleton type initializer
842  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::GSLSpline*)
843  {
844  ::Genfun::GaudiMathImplementation::GSLSpline *ptr = 0;
845  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::GSLSpline));
846  static ::ROOT::TGenericClassInfo
847  instance("Genfun::GaudiMathImplementation::GSLSpline", "GaudiMath/Splines.h", 143,
848  typeid(::Genfun::GaudiMathImplementation::GSLSpline), ::ROOT::Internal::DefineBehavior(ptr, ptr),
849  &GenfuncLcLGaudiMathImplementationcLcLGSLSpline_Dictionary, isa_proxy, 4,
850  sizeof(::Genfun::GaudiMathImplementation::GSLSpline) );
851  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLGSLSpline);
852  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLSpline);
853  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLGSLSpline);
854  return &instance;
855  }
856  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::GSLSpline*)
857  {
858  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::GSLSpline*)0);
859  }
860  // Static variable to force the class initialization
861  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::GSLSpline*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
862 
863  // Dictionary for non-ClassDef classes
864  static TClass *GenfuncLcLGaudiMathImplementationcLcLGSLSpline_Dictionary() {
865  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::GSLSpline*)0x0)->GetClass();
866  GenfuncLcLGaudiMathImplementationcLcLGSLSpline_TClassManip(theClass);
867  return theClass;
868  }
869 
870  static void GenfuncLcLGaudiMathImplementationcLcLGSLSpline_TClassManip(TClass* ){
871  }
872 
873 } // end of namespace ROOT
874 
875 namespace ROOT {
876  static TClass *GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv_Dictionary();
877  static void GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv_TClassManip(TClass*);
878  static void delete_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv(void *p);
879  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv(void *p);
880  static void destruct_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv(void *p);
881 
882  // Function generating the singleton type initializer
883  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::GSLSplineDeriv*)
884  {
885  ::Genfun::GaudiMathImplementation::GSLSplineDeriv *ptr = 0;
886  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::GSLSplineDeriv));
887  static ::ROOT::TGenericClassInfo
888  instance("Genfun::GaudiMathImplementation::GSLSplineDeriv", "GaudiMath/Splines.h", 268,
889  typeid(::Genfun::GaudiMathImplementation::GSLSplineDeriv), ::ROOT::Internal::DefineBehavior(ptr, ptr),
890  &GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv_Dictionary, isa_proxy, 4,
891  sizeof(::Genfun::GaudiMathImplementation::GSLSplineDeriv) );
892  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv);
893  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv);
894  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv);
895  return &instance;
896  }
897  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::GSLSplineDeriv*)
898  {
899  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::GSLSplineDeriv*)0);
900  }
901  // Static variable to force the class initialization
902  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::GSLSplineDeriv*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
903 
904  // Dictionary for non-ClassDef classes
905  static TClass *GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv_Dictionary() {
906  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::GSLSplineDeriv*)0x0)->GetClass();
907  GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv_TClassManip(theClass);
908  return theClass;
909  }
910 
911  static void GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv_TClassManip(TClass* ){
912  }
913 
914 } // end of namespace ROOT
915 
916 namespace ROOT {
917  static TClass *GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv2_Dictionary();
918  static void GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv2_TClassManip(TClass*);
919  static void delete_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv2(void *p);
920  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv2(void *p);
921  static void destruct_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv2(void *p);
922 
923  // Function generating the singleton type initializer
924  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::GSLSplineDeriv2*)
925  {
926  ::Genfun::GaudiMathImplementation::GSLSplineDeriv2 *ptr = 0;
927  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::GSLSplineDeriv2));
928  static ::ROOT::TGenericClassInfo
929  instance("Genfun::GaudiMathImplementation::GSLSplineDeriv2", "GaudiMath/Splines.h", 400,
930  typeid(::Genfun::GaudiMathImplementation::GSLSplineDeriv2), ::ROOT::Internal::DefineBehavior(ptr, ptr),
931  &GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv2_Dictionary, isa_proxy, 4,
932  sizeof(::Genfun::GaudiMathImplementation::GSLSplineDeriv2) );
933  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv2);
934  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv2);
935  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv2);
936  return &instance;
937  }
938  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::GSLSplineDeriv2*)
939  {
940  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::GSLSplineDeriv2*)0);
941  }
942  // Static variable to force the class initialization
943  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::GSLSplineDeriv2*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
944 
945  // Dictionary for non-ClassDef classes
946  static TClass *GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv2_Dictionary() {
947  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::GSLSplineDeriv2*)0x0)->GetClass();
948  GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv2_TClassManip(theClass);
949  return theClass;
950  }
951 
952  static void GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv2_TClassManip(TClass* ){
953  }
954 
955 } // end of namespace ROOT
956 
957 namespace ROOT {
958  static TClass *GenfuncLcLGaudiMathImplementationcLcLGSLSplineInteg_Dictionary();
959  static void GenfuncLcLGaudiMathImplementationcLcLGSLSplineInteg_TClassManip(TClass*);
960  static void delete_GenfuncLcLGaudiMathImplementationcLcLGSLSplineInteg(void *p);
961  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLSplineInteg(void *p);
962  static void destruct_GenfuncLcLGaudiMathImplementationcLcLGSLSplineInteg(void *p);
963 
964  // Function generating the singleton type initializer
965  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Genfun::GaudiMathImplementation::GSLSplineInteg*)
966  {
967  ::Genfun::GaudiMathImplementation::GSLSplineInteg *ptr = 0;
968  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Genfun::GaudiMathImplementation::GSLSplineInteg));
969  static ::ROOT::TGenericClassInfo
970  instance("Genfun::GaudiMathImplementation::GSLSplineInteg", "GaudiMath/Splines.h", 530,
971  typeid(::Genfun::GaudiMathImplementation::GSLSplineInteg), ::ROOT::Internal::DefineBehavior(ptr, ptr),
972  &GenfuncLcLGaudiMathImplementationcLcLGSLSplineInteg_Dictionary, isa_proxy, 4,
973  sizeof(::Genfun::GaudiMathImplementation::GSLSplineInteg) );
974  instance.SetDelete(&delete_GenfuncLcLGaudiMathImplementationcLcLGSLSplineInteg);
975  instance.SetDeleteArray(&deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLSplineInteg);
976  instance.SetDestructor(&destruct_GenfuncLcLGaudiMathImplementationcLcLGSLSplineInteg);
977  return &instance;
978  }
979  TGenericClassInfo *GenerateInitInstance(const ::Genfun::GaudiMathImplementation::GSLSplineInteg*)
980  {
981  return GenerateInitInstanceLocal((::Genfun::GaudiMathImplementation::GSLSplineInteg*)0);
982  }
983  // Static variable to force the class initialization
984  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::GSLSplineInteg*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
985 
986  // Dictionary for non-ClassDef classes
987  static TClass *GenfuncLcLGaudiMathImplementationcLcLGSLSplineInteg_Dictionary() {
988  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Genfun::GaudiMathImplementation::GSLSplineInteg*)0x0)->GetClass();
989  GenfuncLcLGaudiMathImplementationcLcLGSLSplineInteg_TClassManip(theClass);
990  return theClass;
991  }
992 
993  static void GenfuncLcLGaudiMathImplementationcLcLGSLSplineInteg_TClassManip(TClass* ){
994  }
995 
996 } // end of namespace ROOT
997 
998 namespace ROOT {
999  // Wrapper around operator delete
1000  static void delete_GenfuncLcLGaudiMathImplementationcLcLAdapterIFunction(void *p) {
1001  delete ((::Genfun::GaudiMathImplementation::AdapterIFunction*)p);
1002  }
1003  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLAdapterIFunction(void *p) {
1004  delete [] ((::Genfun::GaudiMathImplementation::AdapterIFunction*)p);
1005  }
1006  static void destruct_GenfuncLcLGaudiMathImplementationcLcLAdapterIFunction(void *p) {
1007  typedef ::Genfun::GaudiMathImplementation::AdapterIFunction current_t;
1008  ((current_t*)p)->~current_t();
1009  }
1010 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::AdapterIFunction
1011 
1012 namespace ROOT {
1013  // Wrapper around operator delete
1014  static void delete_GenfuncLcLGaudiMathImplementationcLcLAdapter2DoubleFunction(void *p) {
1015  delete ((::Genfun::GaudiMathImplementation::Adapter2DoubleFunction*)p);
1016  }
1017  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLAdapter2DoubleFunction(void *p) {
1018  delete [] ((::Genfun::GaudiMathImplementation::Adapter2DoubleFunction*)p);
1019  }
1020  static void destruct_GenfuncLcLGaudiMathImplementationcLcLAdapter2DoubleFunction(void *p) {
1021  typedef ::Genfun::GaudiMathImplementation::Adapter2DoubleFunction current_t;
1022  ((current_t*)p)->~current_t();
1023  }
1024 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::Adapter2DoubleFunction
1025 
1026 namespace ROOT {
1027  // Wrapper around operator delete
1028  static void delete_GenfuncLcLGaudiMathImplementationcLcLAdapter3DoubleFunction(void *p) {
1029  delete ((::Genfun::GaudiMathImplementation::Adapter3DoubleFunction*)p);
1030  }
1031  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLAdapter3DoubleFunction(void *p) {
1032  delete [] ((::Genfun::GaudiMathImplementation::Adapter3DoubleFunction*)p);
1033  }
1034  static void destruct_GenfuncLcLGaudiMathImplementationcLcLAdapter3DoubleFunction(void *p) {
1035  typedef ::Genfun::GaudiMathImplementation::Adapter3DoubleFunction current_t;
1036  ((current_t*)p)->~current_t();
1037  }
1038 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::Adapter3DoubleFunction
1039 
1040 namespace ROOT {
1041  // Wrapper around operator delete
1042  static void delete_GenfuncLcLGaudiMathImplementationcLcLSimpleFunction(void *p) {
1043  delete ((::Genfun::GaudiMathImplementation::SimpleFunction*)p);
1044  }
1045  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLSimpleFunction(void *p) {
1046  delete [] ((::Genfun::GaudiMathImplementation::SimpleFunction*)p);
1047  }
1048  static void destruct_GenfuncLcLGaudiMathImplementationcLcLSimpleFunction(void *p) {
1049  typedef ::Genfun::GaudiMathImplementation::SimpleFunction current_t;
1050  ((current_t*)p)->~current_t();
1051  }
1052 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::SimpleFunction
1053 
1054 namespace ROOT {
1055  // Wrapper around operator delete
1056  static void delete_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithError(void *p) {
1057  delete ((::Genfun::GaudiMathImplementation::GSLFunctionWithError*)p);
1058  }
1059  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithError(void *p) {
1060  delete [] ((::Genfun::GaudiMathImplementation::GSLFunctionWithError*)p);
1061  }
1062  static void destruct_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithError(void *p) {
1063  typedef ::Genfun::GaudiMathImplementation::GSLFunctionWithError current_t;
1064  ((current_t*)p)->~current_t();
1065  }
1066 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::GSLFunctionWithError
1067 
1068 namespace ROOT {
1069  // Wrapper around operator delete
1070  static void delete_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithMode(void *p) {
1071  delete ((::Genfun::GaudiMathImplementation::GSLFunctionWithMode*)p);
1072  }
1073  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithMode(void *p) {
1074  delete [] ((::Genfun::GaudiMathImplementation::GSLFunctionWithMode*)p);
1075  }
1076  static void destruct_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithMode(void *p) {
1077  typedef ::Genfun::GaudiMathImplementation::GSLFunctionWithMode current_t;
1078  ((current_t*)p)->~current_t();
1079  }
1080 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::GSLFunctionWithMode
1081 
1082 namespace ROOT {
1083  // Wrapper around operator delete
1084  static void delete_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithModeAndError(void *p) {
1085  delete ((::Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError*)p);
1086  }
1087  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithModeAndError(void *p) {
1088  delete [] ((::Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError*)p);
1089  }
1090  static void destruct_GenfuncLcLGaudiMathImplementationcLcLGSLFunctionWithModeAndError(void *p) {
1091  typedef ::Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError current_t;
1092  ((current_t*)p)->~current_t();
1093  }
1094 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError
1095 
1096 namespace ROOT {
1097  // Wrapper around operator delete
1098  static void delete_GenfuncLcLGaudiMathImplementationcLcLConstant(void *p) {
1099  delete ((::Genfun::GaudiMathImplementation::Constant*)p);
1100  }
1101  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLConstant(void *p) {
1102  delete [] ((::Genfun::GaudiMathImplementation::Constant*)p);
1103  }
1104  static void destruct_GenfuncLcLGaudiMathImplementationcLcLConstant(void *p) {
1105  typedef ::Genfun::GaudiMathImplementation::Constant current_t;
1106  ((current_t*)p)->~current_t();
1107  }
1108 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::Constant
1109 
1110 namespace ROOT {
1111  // Wrapper around operator delete
1112  static void delete_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegral(void *p) {
1113  delete ((::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral*)p);
1114  }
1115  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegral(void *p) {
1116  delete [] ((::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral*)p);
1117  }
1118  static void destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegral(void *p) {
1119  typedef ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral current_t;
1120  ((current_t*)p)->~current_t();
1121  }
1122 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral
1123 
1124 namespace ROOT {
1125  // Wrappers around operator new
1126  static void *new_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace(void *p) {
1127  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace : new ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace;
1128  }
1129  static void *newArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace(Long_t nElements, void *p) {
1130  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace[nElements] : new ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace[nElements];
1131  }
1132  // Wrapper around operator delete
1133  static void delete_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace(void *p) {
1134  delete ((::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace*)p);
1135  }
1136  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace(void *p) {
1137  delete [] ((::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace*)p);
1138  }
1139  static void destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcL_Workspace(void *p) {
1140  typedef ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace current_t;
1141  ((current_t*)p)->~current_t();
1142  }
1143 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace
1144 
1145 namespace ROOT {
1146  // Wrappers around operator new
1147  static void *new_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter(void *p) {
1148  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter : new ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter;
1149  }
1150  static void *newArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter(Long_t nElements, void *p) {
1151  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter[nElements] : new ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter[nElements];
1152  }
1153  // Wrapper around operator delete
1154  static void delete_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter(void *p) {
1155  delete ((::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter*)p);
1156  }
1157  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter(void *p) {
1158  delete [] ((::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter*)p);
1159  }
1160  static void destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalDefiniteIntegralcLcLgsl_ws_deleter(void *p) {
1161  typedef ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter current_t;
1162  ((current_t*)p)->~current_t();
1163  }
1164 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter
1165 
1166 namespace ROOT {
1167  // Wrapper around operator delete
1168  static void delete_GenfuncLcLGaudiMathImplementationcLcLNumericalDerivative(void *p) {
1169  delete ((::Genfun::GaudiMathImplementation::NumericalDerivative*)p);
1170  }
1171  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalDerivative(void *p) {
1172  delete [] ((::Genfun::GaudiMathImplementation::NumericalDerivative*)p);
1173  }
1174  static void destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalDerivative(void *p) {
1175  typedef ::Genfun::GaudiMathImplementation::NumericalDerivative current_t;
1176  ((current_t*)p)->~current_t();
1177  }
1178 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::NumericalDerivative
1179 
1180 namespace ROOT {
1181  // Wrapper around operator delete
1182  static void delete_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegral(void *p) {
1183  delete ((::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral*)p);
1184  }
1185  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegral(void *p) {
1186  delete [] ((::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral*)p);
1187  }
1188  static void destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegral(void *p) {
1189  typedef ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral current_t;
1190  ((current_t*)p)->~current_t();
1191  }
1192 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral
1193 
1194 namespace ROOT {
1195  // Wrappers around operator new
1196  static void *new_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace(void *p) {
1197  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace : new ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace;
1198  }
1199  static void *newArray_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace(Long_t nElements, void *p) {
1200  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace[nElements] : new ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace[nElements];
1201  }
1202  // Wrapper around operator delete
1203  static void delete_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace(void *p) {
1204  delete ((::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace*)p);
1205  }
1206  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace(void *p) {
1207  delete [] ((::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace*)p);
1208  }
1209  static void destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcL_Workspace(void *p) {
1210  typedef ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace current_t;
1211  ((current_t*)p)->~current_t();
1212  }
1213 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace
1214 
1215 namespace ROOT {
1216  // Wrappers around operator new
1217  static void *new_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter(void *p) {
1218  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter : new ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter;
1219  }
1220  static void *newArray_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter(Long_t nElements, void *p) {
1221  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter[nElements] : new ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter[nElements];
1222  }
1223  // Wrapper around operator delete
1224  static void delete_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter(void *p) {
1225  delete ((::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter*)p);
1226  }
1227  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter(void *p) {
1228  delete [] ((::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter*)p);
1229  }
1230  static void destruct_GenfuncLcLGaudiMathImplementationcLcLNumericalIndefiniteIntegralcLcLgsl_ws_deleter(void *p) {
1231  typedef ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter current_t;
1232  ((current_t*)p)->~current_t();
1233  }
1234 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter
1235 
1236 namespace ROOT {
1237  // Wrapper around operator delete
1238  static void delete_GenfuncLcLGaudiMathImplementationcLcLSplineBase(void *p) {
1239  delete ((::Genfun::GaudiMathImplementation::SplineBase*)p);
1240  }
1241  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLSplineBase(void *p) {
1242  delete [] ((::Genfun::GaudiMathImplementation::SplineBase*)p);
1243  }
1244  static void destruct_GenfuncLcLGaudiMathImplementationcLcLSplineBase(void *p) {
1245  typedef ::Genfun::GaudiMathImplementation::SplineBase current_t;
1246  ((current_t*)p)->~current_t();
1247  }
1248 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::SplineBase
1249 
1250 namespace ROOT {
1251  // Wrapper around operator delete
1252  static void delete_GenfuncLcLGaudiMathImplementationcLcLGSLSpline(void *p) {
1253  delete ((::Genfun::GaudiMathImplementation::GSLSpline*)p);
1254  }
1255  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLSpline(void *p) {
1256  delete [] ((::Genfun::GaudiMathImplementation::GSLSpline*)p);
1257  }
1258  static void destruct_GenfuncLcLGaudiMathImplementationcLcLGSLSpline(void *p) {
1259  typedef ::Genfun::GaudiMathImplementation::GSLSpline current_t;
1260  ((current_t*)p)->~current_t();
1261  }
1262 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::GSLSpline
1263 
1264 namespace ROOT {
1265  // Wrapper around operator delete
1266  static void delete_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv(void *p) {
1267  delete ((::Genfun::GaudiMathImplementation::GSLSplineDeriv*)p);
1268  }
1269  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv(void *p) {
1270  delete [] ((::Genfun::GaudiMathImplementation::GSLSplineDeriv*)p);
1271  }
1272  static void destruct_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv(void *p) {
1273  typedef ::Genfun::GaudiMathImplementation::GSLSplineDeriv current_t;
1274  ((current_t*)p)->~current_t();
1275  }
1276 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::GSLSplineDeriv
1277 
1278 namespace ROOT {
1279  // Wrapper around operator delete
1280  static void delete_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv2(void *p) {
1281  delete ((::Genfun::GaudiMathImplementation::GSLSplineDeriv2*)p);
1282  }
1283  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv2(void *p) {
1284  delete [] ((::Genfun::GaudiMathImplementation::GSLSplineDeriv2*)p);
1285  }
1286  static void destruct_GenfuncLcLGaudiMathImplementationcLcLGSLSplineDeriv2(void *p) {
1287  typedef ::Genfun::GaudiMathImplementation::GSLSplineDeriv2 current_t;
1288  ((current_t*)p)->~current_t();
1289  }
1290 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::GSLSplineDeriv2
1291 
1292 namespace ROOT {
1293  // Wrapper around operator delete
1294  static void delete_GenfuncLcLGaudiMathImplementationcLcLGSLSplineInteg(void *p) {
1295  delete ((::Genfun::GaudiMathImplementation::GSLSplineInteg*)p);
1296  }
1297  static void deleteArray_GenfuncLcLGaudiMathImplementationcLcLGSLSplineInteg(void *p) {
1298  delete [] ((::Genfun::GaudiMathImplementation::GSLSplineInteg*)p);
1299  }
1300  static void destruct_GenfuncLcLGaudiMathImplementationcLcLGSLSplineInteg(void *p) {
1301  typedef ::Genfun::GaudiMathImplementation::GSLSplineInteg current_t;
1302  ((current_t*)p)->~current_t();
1303  }
1304 } // end of namespace ROOT for class ::Genfun::GaudiMathImplementation::GSLSplineInteg
1305 
1306 namespace {
1307  void TriggerDictionaryInitialization_GaudiGSLMathDict_Impl() {
1308  static const char* headers[] = {
1309 0 };
1310  static const char* includePaths[] = {
1311 "/builds/gaudi/Gaudi/GaudiGSL",
1312 "/builds/gaudi/Gaudi/GaudiPluginService",
1313 "/builds/gaudi/Gaudi/GaudiKernel",
1314 "/builds/gaudi/Gaudi/GaudiUtils",
1315 "/builds/gaudi/Gaudi/GaudiAlg",
1316 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/clhep/2.4.0.1/x86_64-centos7-gcc62-opt/include",
1317 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/GSL/2.1/x86_64-centos7-gcc62-opt/include",
1318 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/rangev3/0.3.0/x86_64-centos7-gcc62-opt/include",
1319 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/AIDA/3.2.1/x86_64-centos7-gcc62-opt/src/cpp",
1320 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/tbb/2018_U1/x86_64-centos7-gcc62-opt/include",
1321 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/ROOT/6.12.06/x86_64-centos7-gcc62-opt/include",
1322 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/Boost/1.66.0/x86_64-centos7-gcc62-opt/include",
1323 "/builds/gaudi/Gaudi/build-gcc62/include",
1324 "/cvmfs/sft.cern.ch/lcg/releases/ROOT/6.12.06-51921/x86_64-centos7-gcc62-opt/include",
1325 "/builds/gaudi/Gaudi/build-gcc62/GaudiGSL/",
1326 0
1327  };
1328  static const char* fwdDeclCode = R"DICTFWDDCLS(
1329 #line 1 "GaudiGSLMathDict dictionary forward declarations' payload"
1330 #pragma clang diagnostic ignored "-Wkeyword-compat"
1331 #pragma clang diagnostic ignored "-Wignored-attributes"
1332 #pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
1333 extern int __Cling_Autoloading_Map;
1334 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/FunAdapters.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) AdapterIFunction;}}
1335 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/FunAdapters.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) Adapter2DoubleFunction;}}
1336 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/FunAdapters.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) Adapter3DoubleFunction;}}
1337 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/FunAdapters.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) SimpleFunction;}}
1338 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/GSLFunAdapters.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) GSLFunctionWithError;}}
1339 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/GSLFunAdapters.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) GSLFunctionWithMode;}}
1340 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/GSLFunAdapters.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) GSLFunctionWithModeAndError;}}
1341 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/Constant.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) Constant;}}
1342 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/NumericalDefiniteIntegral.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) NumericalDefiniteIntegral;}}
1343 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/NumericalDerivative.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) NumericalDerivative;}}
1344 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/NumericalIndefiniteIntegral.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) NumericalIndefiniteIntegral;}}
1345 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/Splines.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) SplineBase;}}
1346 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/Splines.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) GSLSpline;}}
1347 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/Splines.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) GSLSplineDeriv;}}
1348 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/Splines.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) GSLSplineDeriv2;}}
1349 namespace Genfun{namespace GaudiMathImplementation{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiMath::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiMath/Splines.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) GSLSplineInteg;}}
1350 namespace Genfun{namespace GaudiMathImplementation{typedef Genfun::GaudiMathImplementation::SimpleFunction GSLFunction __attribute__((annotate("$clingAutoload$GaudiMath/GSLFunAdapters.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}}
1351 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::AdapterIFunction AIDAFunction __attribute__((annotate("$clingAutoload$GaudiMath/Adapters.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1352 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::Adapter2DoubleFunction Function2D __attribute__((annotate("$clingAutoload$GaudiMath/Adapters.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1353 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::Adapter3DoubleFunction Function3D __attribute__((annotate("$clingAutoload$GaudiMath/Adapters.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1354 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::SimpleFunction SimpleFunction __attribute__((annotate("$clingAutoload$GaudiMath/Adapters.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1355 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::GSLFunctionWithMode GSLFunctionWithMode __attribute__((annotate("$clingAutoload$GaudiMath/Adapters.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1356 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::GSLFunctionWithError GSLFunctionWithError __attribute__((annotate("$clingAutoload$GaudiMath/Adapters.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1357 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError GSLFunctionWithModeAndError __attribute__((annotate("$clingAutoload$GaudiMath/Adapters.h"))) __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1358 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::Constant Constant __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1359 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::NumericalDerivative Derivative __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1360 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::SimpleFunction SimpleFun __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1361 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral IndIntegral __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1362 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::NumericalDefiniteIntegral DefIntegral __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1363 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::SplineBase SimpleSpline __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1364 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::GSLSpline Spline __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1365 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::GSLSplineDeriv SplineDeriv __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1366 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::GSLSplineDeriv2 SplineDeriv2 __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1367 namespace GaudiMath{typedef Genfun::GaudiMathImplementation::GSLSplineInteg SplineInteg __attribute__((annotate("$clingAutoload$GaudiMath/GaudiMath.h"))) ;}
1368 )DICTFWDDCLS";
1369  static const char* payloadCode = R"DICTPAYLOAD(
1370 #line 1 "GaudiGSLMathDict dictionary payload"
1371 #ifdef _Instantiations
1372  #undef _Instantiations
1373 #endif
1374 
1375 #ifndef G__VECTOR_HAS_CLASS_ITERATOR
1376  #define G__VECTOR_HAS_CLASS_ITERATOR 1
1377 #endif
1378 #ifndef _Instantiations
1379  #define _Instantiations GaudiGSLMath_Instantiations
1380 #endif
1381 #ifndef _GNU_SOURCE
1382  #define _GNU_SOURCE 1
1383 #endif
1384 #ifndef unix
1385  #define unix 1
1386 #endif
1387 #ifndef f2cFortran
1388  #define f2cFortran 1
1389 #endif
1390 #ifndef linux
1391  #define linux 1
1392 #endif
1393 #ifndef GAUDI_V20_COMPAT
1394  #define GAUDI_V20_COMPAT 1
1395 #endif
1396 #ifndef BOOST_FILESYSTEM_VERSION
1397  #define BOOST_FILESYSTEM_VERSION 3
1398 #endif
1399 #ifndef BOOST_SPIRIT_USE_PHOENIX_V3
1400  #define BOOST_SPIRIT_USE_PHOENIX_V3 1
1401 #endif
1402 #ifndef PACKAGE_NAME
1403  #define PACKAGE_NAME "GaudiGSL"
1404 #endif
1405 #ifndef PACKAGE_VERSION
1406  #define PACKAGE_VERSION "v30r3"
1407 #endif
1408 #ifndef NDEBUG
1409  #define NDEBUG 1
1410 #endif
1411 
1412 #define _BACKWARD_BACKWARD_WARNING_H
1413 #ifndef GAUDIGSL_GAUDIGSLMATH_H
1414 #define GAUDIGSL_GAUDIGSLMATH_H 1
1415 
1416 // ============================================================================
1417 // Include files
1418 // ============================================================================
1419 #include "GaudiGSL/GaudiGSL.h"
1420 #include "GaudiGSL/GslError.h"
1421 #include "GaudiGSL/GslErrorHandlers.h"
1422 #include "GaudiGSL/IEqSolver.h"
1423 #include "GaudiGSL/IFuncMinimum.h"
1424 #include "GaudiGSL/IGslErrorHandler.h"
1425 #include "GaudiGSL/IGslSvc.h"
1426 // ============================================================================
1427 #include "GaudiMath/GaudiMath.h"
1428 // ============================================================================
1429 
1430 #endif // GAUDIGSL_GAUDIGSLMATH_H
1431 
1432 #undef _BACKWARD_BACKWARD_WARNING_H
1433 )DICTPAYLOAD";
1434  static const char* classesHeaders[]={
1435 "", payloadCode, "@",
1436 "GaudiMath::AIDAFunction", payloadCode, "@",
1437 "GaudiMath::Constant", payloadCode, "@",
1438 "GaudiMath::DefIntegral", payloadCode, "@",
1439 "GaudiMath::Derivative", payloadCode, "@",
1440 "GaudiMath::Function2D", payloadCode, "@",
1441 "GaudiMath::Function3D", payloadCode, "@",
1442 "GaudiMath::GSLFunctionWithError", payloadCode, "@",
1443 "GaudiMath::GSLFunctionWithMode", payloadCode, "@",
1444 "GaudiMath::GSLFunctionWithModeAndError", payloadCode, "@",
1445 "GaudiMath::IndIntegral", payloadCode, "@",
1446 "GaudiMath::SimpleFun", payloadCode, "@",
1447 "GaudiMath::SimpleFunction", payloadCode, "@",
1448 "GaudiMath::SimpleSpline", payloadCode, "@",
1449 "GaudiMath::Spline", payloadCode, "@",
1450 "GaudiMath::SplineDeriv", payloadCode, "@",
1451 "GaudiMath::SplineDeriv2", payloadCode, "@",
1452 "GaudiMath::SplineInteg", payloadCode, "@",
1453 "Genfun::GaudiMathImplementation::Adapter2DoubleFunction", payloadCode, "@",
1454 "Genfun::GaudiMathImplementation::Adapter3DoubleFunction", payloadCode, "@",
1455 "Genfun::GaudiMathImplementation::AdapterIFunction", payloadCode, "@",
1456 "Genfun::GaudiMathImplementation::Constant", payloadCode, "@",
1457 "Genfun::GaudiMathImplementation::GSLFunction", payloadCode, "@",
1458 "Genfun::GaudiMathImplementation::GSLFunctionWithError", payloadCode, "@",
1459 "Genfun::GaudiMathImplementation::GSLFunctionWithMode", payloadCode, "@",
1460 "Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError", payloadCode, "@",
1461 "Genfun::GaudiMathImplementation::GSLSpline", payloadCode, "@",
1462 "Genfun::GaudiMathImplementation::GSLSplineDeriv", payloadCode, "@",
1463 "Genfun::GaudiMathImplementation::GSLSplineDeriv2", payloadCode, "@",
1464 "Genfun::GaudiMathImplementation::GSLSplineInteg", payloadCode, "@",
1465 "Genfun::GaudiMathImplementation::NumericalDefiniteIntegral", payloadCode, "@",
1466 "Genfun::GaudiMathImplementation::NumericalDerivative", payloadCode, "@",
1467 "Genfun::GaudiMathImplementation::NumericalDerivative::Type", payloadCode, "@",
1468 "Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral", payloadCode, "@",
1469 "Genfun::GaudiMathImplementation::SimpleFunction", payloadCode, "@",
1470 "Genfun::GaudiMathImplementation::SplineBase", payloadCode, "@",
1471 nullptr};
1472 
1473  static bool isInitialized = false;
1474  if (!isInitialized) {
1475  TROOT::RegisterModule("GaudiGSLMathDict",
1476  headers, includePaths, payloadCode, fwdDeclCode,
1477  TriggerDictionaryInitialization_GaudiGSLMathDict_Impl, {}, classesHeaders);
1478  isInitialized = true;
1479  }
1480  }
1481  static struct DictInit {
1482  DictInit() {
1483  TriggerDictionaryInitialization_GaudiGSLMathDict_Impl();
1484  }
1485  } __TheDictionaryInitializer;
1486 }
1487 void TriggerDictionaryInitialization_GaudiGSLMathDict() {
1488  TriggerDictionaryInitialization_GaudiGSLMathDict_Impl();
1489 }
GaudiMath::GSLFunctionWithMode
Genfun::GaudiMathImplementation::GSLFunctionWithMode GSLFunctionWithMode
Definition: Adapters.h:20
GaudiMath::GSLFunctionWithError
Genfun::GaudiMathImplementation::GSLFunctionWithError GSLFunctionWithError
Definition: Adapters.h:21
Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace
Definition: NumericalDefiniteIntegral.h:83
Genfun::GaudiMathImplementation::Constant
Fixed constant function.
Definition: Constant.h:31
Genfun::GaudiMathImplementation::ROOT::_R__UNIQUE_DICT_
::ROOT::TGenericClassInfo *(*)() _R__UNIQUE_DICT_(InitFunctionKeeper)
Definition: GaudiGSLMathDict.cpp:60
std
STL namespace.
Genfun::GaudiMathImplementation::SimpleFunction
mandatory macro from CLHEP/GenericFunctions
Definition: FunAdapters.h:220
ROOT::R__UseDummy
R__UseDummy(_R__UNIQUE_DICT_(Init))
details::size
constexpr auto size(const C &c) noexcept(noexcept(c.size())) -> decltype(c.size())
Definition: AnyDataWrapper.h:14
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter
Definition: NumericalIndefiniteIntegral.h:332
Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter
Definition: NumericalDefiniteIntegral.h:345
TriggerDictionaryInitialization_GaudiGSLMathDict
void TriggerDictionaryInitialization_GaudiGSLMathDict()
Definition: GaudiGSLMathDict.cpp:1487
Genfun::GaudiMathImplementation::Adapter2DoubleFunction
mandatory macro from CLHEP/GenericFunctions
Definition: FunAdapters.h:111
Genfun::GaudiMathImplementation::GSLFunctionWithMode
mandatory macro from CLHEP/GenericFunctions
Definition: GSLFunAdapters.h:81
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace
Definition: NumericalIndefiniteIntegral.h:86
Genfun::GaudiMathImplementation::NumericalDerivative
Numerical derivative (using GSL adaptive numerical differentiation)
Definition: NumericalDerivative.h:44
Genfun::GaudiMathImplementation::Adapter3DoubleFunction
mandatory macro from CLHEP/GenericFunctions
Definition: FunAdapters.h:174
GaudiMath::GSLFunctionWithModeAndError
Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError GSLFunctionWithModeAndError
Definition: Adapters.h:22
GaudiMath
GaudiMath.h GaudiMath/GaudiMath.h.
Definition: GaudiGSLMathDict.cpp:73
ROOT::GenerateInitInstance
TGenericClassInfo * GenerateInitInstance(const ::Genfun::GaudiMathImplementation::GSLSplineInteg *)
Definition: GaudiGSLMathDict.cpp:979
GaudiMath::SimpleFunction
Genfun::GaudiMathImplementation::SimpleFunction SimpleFunction
Definition: Adapters.h:18
Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError
mandatory macro from CLHEP/GenericFunctions
Definition: GSLFunAdapters.h:119
GaudiMath::Constant
Genfun::GaudiMathImplementation::Constant Constant
Definition: GaudiMath.h:26
Integration
collection of common types for classes NumericalIndefiniteIntegral and NumericalDefiniteIntegral ...
Genfun::GaudiMathImplementation::AdapterIFunction
constructor from the IFunction ( see AIDA/IFunction.h)
Definition: FunAdapters.h:53
Genfun::GaudiMathImplementation::NumericalDefiniteIntegral
This class allows the numerical evaluation of the following functions:
Definition: NumericalDefiniteIntegral.h:80