00001
00002
00003
00004
00005
00006
00007 #define R__DICTIONARY_FILENAME tmvadIsrcdIG__TMVA4
00008 #include "RConfig.h"
00009 #if !defined(R__ACCESS_IN_SYMBOL)
00010
00011 #define private public
00012 #define protected public
00013 #endif
00014
00015
00016 namespace std {} using namespace std;
00017 #include "G__TMVA4.h"
00018
00019 #include "TCollectionProxyInfo.h"
00020 #include "TClass.h"
00021 #include "TBuffer.h"
00022 #include "TMemberInspector.h"
00023 #include "TError.h"
00024
00025 #ifndef G__ROOT
00026 #define G__ROOT
00027 #endif
00028
00029 #include "RtypesImp.h"
00030 #include "TIsAProxy.h"
00031
00032
00033
00034 namespace ROOT {
00035 namespace Shadow {
00036 namespace TMVA {
00037
00038 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00039 typedef ::TMVA::Types Types;
00040 #else
00041 class Types {
00042 public:
00043
00044 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00045 typedef ::TMVA::Types::EMVA EMVA;
00046 #else
00047 enum EMVA {
00048 };
00049 #endif
00050
00051 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00052 typedef ::TMVA::Types::EVariableTransform EVariableTransform;
00053 #else
00054 enum EVariableTransform {
00055 };
00056 #endif
00057
00058 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00059 typedef ::TMVA::Types::EAnalysisType EAnalysisType;
00060 #else
00061 enum EAnalysisType {
00062 };
00063 #endif
00064
00065 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00066 typedef ::TMVA::Types::ESBType ESBType;
00067 #else
00068 enum ESBType {
00069 };
00070 #endif
00071
00072 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00073 typedef ::TMVA::Types::ETreeType ETreeType;
00074 #else
00075 enum ETreeType {
00076 };
00077 #endif
00078
00079 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00080 typedef ::TMVA::Types::EBoostStage EBoostStage;
00081 #else
00082 enum EBoostStage {
00083 };
00084 #endif
00085
00086 map< ::TString, ::TMVA::Types::EMVA > fStr2type;
00087 ::TMVA::MsgLogger* fLogger;
00088 };
00089 #endif
00090 }
00091 }
00092 }
00093
00094
00095 namespace TMVA {
00096 namespace ROOT {
00097 inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
00098 static void TMVA_Dictionary();
00099
00100
00101 inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
00102 {
00103 static ::ROOT::TGenericClassInfo
00104 instance("TMVA", 0 , "./include/TMVA/VariableNormalizeTransform.h", 47,
00105 ::ROOT::DefineBehavior((void*)0,(void*)0),
00106 &TMVA_Dictionary, 0);
00107 return &instance;
00108 }
00109
00110 ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;
00111
00112 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));
00113
00114
00115 static void TMVA_Dictionary() {
00116 GenerateInitInstance()->GetClass();
00117 }
00118
00119 }
00120 }
00121
00122 namespace ROOT {
00123 void TMVAcLcLTNeuron_ShowMembers(void *obj, TMemberInspector &R__insp);
00124 static void *new_TMVAcLcLTNeuron(void *p = 0);
00125 static void *newArray_TMVAcLcLTNeuron(Long_t size, void *p);
00126 static void delete_TMVAcLcLTNeuron(void *p);
00127 static void deleteArray_TMVAcLcLTNeuron(void *p);
00128 static void destruct_TMVAcLcLTNeuron(void *p);
00129
00130
00131 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::TNeuron*)
00132 {
00133 ::TMVA::TNeuron *ptr = 0;
00134 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::TNeuron >(0);
00135 static ::ROOT::TGenericClassInfo
00136 instance("TMVA::TNeuron", ::TMVA::TNeuron::Class_Version(), "./include/TMVA/TNeuron.h", 61,
00137 typeid(::TMVA::TNeuron), DefineBehavior(ptr, ptr),
00138 &::TMVA::TNeuron::Dictionary, isa_proxy, 4,
00139 sizeof(::TMVA::TNeuron) );
00140 instance.SetNew(&new_TMVAcLcLTNeuron);
00141 instance.SetNewArray(&newArray_TMVAcLcLTNeuron);
00142 instance.SetDelete(&delete_TMVAcLcLTNeuron);
00143 instance.SetDeleteArray(&deleteArray_TMVAcLcLTNeuron);
00144 instance.SetDestructor(&destruct_TMVAcLcLTNeuron);
00145 return &instance;
00146 }
00147 TGenericClassInfo *GenerateInitInstance(const ::TMVA::TNeuron*)
00148 {
00149 return GenerateInitInstanceLocal((::TMVA::TNeuron*)0);
00150 }
00151
00152 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::TNeuron*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00153 }
00154
00155 namespace ROOT {
00156 void TMVAcLcLMsgLogger_ShowMembers(void *obj, TMemberInspector &R__insp);
00157 static void *new_TMVAcLcLMsgLogger(void *p = 0);
00158 static void *newArray_TMVAcLcLMsgLogger(Long_t size, void *p);
00159 static void delete_TMVAcLcLMsgLogger(void *p);
00160 static void deleteArray_TMVAcLcLMsgLogger(void *p);
00161 static void destruct_TMVAcLcLMsgLogger(void *p);
00162
00163
00164 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::MsgLogger*)
00165 {
00166 ::TMVA::MsgLogger *ptr = 0;
00167 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::MsgLogger >(0);
00168 static ::ROOT::TGenericClassInfo
00169 instance("TMVA::MsgLogger", ::TMVA::MsgLogger::Class_Version(), "include/TMVA/MsgLogger.h", 55,
00170 typeid(::TMVA::MsgLogger), DefineBehavior(ptr, ptr),
00171 &::TMVA::MsgLogger::Dictionary, isa_proxy, 4,
00172 sizeof(::TMVA::MsgLogger) );
00173 instance.SetNew(&new_TMVAcLcLMsgLogger);
00174 instance.SetNewArray(&newArray_TMVAcLcLMsgLogger);
00175 instance.SetDelete(&delete_TMVAcLcLMsgLogger);
00176 instance.SetDeleteArray(&deleteArray_TMVAcLcLMsgLogger);
00177 instance.SetDestructor(&destruct_TMVAcLcLMsgLogger);
00178 return &instance;
00179 }
00180 TGenericClassInfo *GenerateInitInstance(const ::TMVA::MsgLogger*)
00181 {
00182 return GenerateInitInstanceLocal((::TMVA::MsgLogger*)0);
00183 }
00184
00185 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::MsgLogger*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00186 }
00187
00188 namespace ROOT {
00189 void TMVAcLcLTSynapse_ShowMembers(void *obj, TMemberInspector &R__insp);
00190 static void *new_TMVAcLcLTSynapse(void *p = 0);
00191 static void *newArray_TMVAcLcLTSynapse(Long_t size, void *p);
00192 static void delete_TMVAcLcLTSynapse(void *p);
00193 static void deleteArray_TMVAcLcLTSynapse(void *p);
00194 static void destruct_TMVAcLcLTSynapse(void *p);
00195
00196
00197 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::TSynapse*)
00198 {
00199 ::TMVA::TSynapse *ptr = 0;
00200 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::TSynapse >(0);
00201 static ::ROOT::TGenericClassInfo
00202 instance("TMVA::TSynapse", ::TMVA::TSynapse::Class_Version(), "include/TMVA/TSynapse.h", 48,
00203 typeid(::TMVA::TSynapse), DefineBehavior(ptr, ptr),
00204 &::TMVA::TSynapse::Dictionary, isa_proxy, 4,
00205 sizeof(::TMVA::TSynapse) );
00206 instance.SetNew(&new_TMVAcLcLTSynapse);
00207 instance.SetNewArray(&newArray_TMVAcLcLTSynapse);
00208 instance.SetDelete(&delete_TMVAcLcLTSynapse);
00209 instance.SetDeleteArray(&deleteArray_TMVAcLcLTSynapse);
00210 instance.SetDestructor(&destruct_TMVAcLcLTSynapse);
00211 return &instance;
00212 }
00213 TGenericClassInfo *GenerateInitInstance(const ::TMVA::TSynapse*)
00214 {
00215 return GenerateInitInstanceLocal((::TMVA::TSynapse*)0);
00216 }
00217
00218 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::TSynapse*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00219 }
00220
00221 namespace ROOT {
00222 void TMVAcLcLTActivation_ShowMembers(void *obj, TMemberInspector &R__insp);
00223 static void delete_TMVAcLcLTActivation(void *p);
00224 static void deleteArray_TMVAcLcLTActivation(void *p);
00225 static void destruct_TMVAcLcLTActivation(void *p);
00226
00227
00228 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::TActivation*)
00229 {
00230 ::TMVA::TActivation *ptr = 0;
00231 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::TActivation >(0);
00232 static ::ROOT::TGenericClassInfo
00233 instance("TMVA::TActivation", ::TMVA::TActivation::Class_Version(), "include/TMVA/TActivation.h", 46,
00234 typeid(::TMVA::TActivation), DefineBehavior(ptr, ptr),
00235 &::TMVA::TActivation::Dictionary, isa_proxy, 4,
00236 sizeof(::TMVA::TActivation) );
00237 instance.SetDelete(&delete_TMVAcLcLTActivation);
00238 instance.SetDeleteArray(&deleteArray_TMVAcLcLTActivation);
00239 instance.SetDestructor(&destruct_TMVAcLcLTActivation);
00240 return &instance;
00241 }
00242 TGenericClassInfo *GenerateInitInstance(const ::TMVA::TActivation*)
00243 {
00244 return GenerateInitInstanceLocal((::TMVA::TActivation*)0);
00245 }
00246
00247 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::TActivation*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00248 }
00249
00250 namespace ROOT {
00251 void TMVAcLcLTypes_ShowMembers(void *obj, TMemberInspector &R__insp);
00252 static void TMVAcLcLTypes_Dictionary();
00253 static void delete_TMVAcLcLTypes(void *p);
00254 static void deleteArray_TMVAcLcLTypes(void *p);
00255 static void destruct_TMVAcLcLTypes(void *p);
00256
00257
00258 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::Types*)
00259 {
00260
00261 R__ASSERT(sizeof(::TMVA::Types) == sizeof(::ROOT::Shadow::TMVA::Types));
00262 ::TMVA::Types *ptr = 0;
00263 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMVA::Types),0);
00264 static ::ROOT::TGenericClassInfo
00265 instance("TMVA::Types", "include/TMVA/Types.h", 68,
00266 typeid(::TMVA::Types), DefineBehavior(ptr, ptr),
00267 &TMVAcLcLTypes_ShowMembers, &TMVAcLcLTypes_Dictionary, isa_proxy, 4,
00268 sizeof(::TMVA::Types) );
00269 instance.SetDelete(&delete_TMVAcLcLTypes);
00270 instance.SetDeleteArray(&deleteArray_TMVAcLcLTypes);
00271 instance.SetDestructor(&destruct_TMVAcLcLTypes);
00272 return &instance;
00273 }
00274 TGenericClassInfo *GenerateInitInstance(const ::TMVA::Types*)
00275 {
00276 return GenerateInitInstanceLocal((::TMVA::Types*)0);
00277 }
00278
00279 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::Types*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00280
00281
00282 static void TMVAcLcLTypes_Dictionary() {
00283 ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Types*)0x0)->GetClass();
00284 }
00285
00286 }
00287
00288 namespace ROOT {
00289 void TMVAcLcLTNeuronInput_ShowMembers(void *obj, TMemberInspector &R__insp);
00290 static void delete_TMVAcLcLTNeuronInput(void *p);
00291 static void deleteArray_TMVAcLcLTNeuronInput(void *p);
00292 static void destruct_TMVAcLcLTNeuronInput(void *p);
00293
00294
00295 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::TNeuronInput*)
00296 {
00297 ::TMVA::TNeuronInput *ptr = 0;
00298 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::TNeuronInput >(0);
00299 static ::ROOT::TGenericClassInfo
00300 instance("TMVA::TNeuronInput", ::TMVA::TNeuronInput::Class_Version(), "include/TMVA/TNeuronInput.h", 46,
00301 typeid(::TMVA::TNeuronInput), DefineBehavior(ptr, ptr),
00302 &::TMVA::TNeuronInput::Dictionary, isa_proxy, 4,
00303 sizeof(::TMVA::TNeuronInput) );
00304 instance.SetDelete(&delete_TMVAcLcLTNeuronInput);
00305 instance.SetDeleteArray(&deleteArray_TMVAcLcLTNeuronInput);
00306 instance.SetDestructor(&destruct_TMVAcLcLTNeuronInput);
00307 return &instance;
00308 }
00309 TGenericClassInfo *GenerateInitInstance(const ::TMVA::TNeuronInput*)
00310 {
00311 return GenerateInitInstanceLocal((::TMVA::TNeuronInput*)0);
00312 }
00313
00314 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::TNeuronInput*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00315 }
00316
00317 namespace ROOT {
00318 void TMVAcLcLTActivationChooser_ShowMembers(void *obj, TMemberInspector &R__insp);
00319 static void *new_TMVAcLcLTActivationChooser(void *p = 0);
00320 static void *newArray_TMVAcLcLTActivationChooser(Long_t size, void *p);
00321 static void delete_TMVAcLcLTActivationChooser(void *p);
00322 static void deleteArray_TMVAcLcLTActivationChooser(void *p);
00323 static void destruct_TMVAcLcLTActivationChooser(void *p);
00324
00325
00326 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::TActivationChooser*)
00327 {
00328 ::TMVA::TActivationChooser *ptr = 0;
00329 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::TActivationChooser >(0);
00330 static ::ROOT::TGenericClassInfo
00331 instance("TMVA::TActivationChooser", ::TMVA::TActivationChooser::Class_Version(), "./include/TMVA/TActivationChooser.h", 46,
00332 typeid(::TMVA::TActivationChooser), DefineBehavior(ptr, ptr),
00333 &::TMVA::TActivationChooser::Dictionary, isa_proxy, 4,
00334 sizeof(::TMVA::TActivationChooser) );
00335 instance.SetNew(&new_TMVAcLcLTActivationChooser);
00336 instance.SetNewArray(&newArray_TMVAcLcLTActivationChooser);
00337 instance.SetDelete(&delete_TMVAcLcLTActivationChooser);
00338 instance.SetDeleteArray(&deleteArray_TMVAcLcLTActivationChooser);
00339 instance.SetDestructor(&destruct_TMVAcLcLTActivationChooser);
00340 return &instance;
00341 }
00342 TGenericClassInfo *GenerateInitInstance(const ::TMVA::TActivationChooser*)
00343 {
00344 return GenerateInitInstanceLocal((::TMVA::TActivationChooser*)0);
00345 }
00346
00347 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::TActivationChooser*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00348 }
00349
00350 namespace ROOT {
00351 void TMVAcLcLTActivationSigmoid_ShowMembers(void *obj, TMemberInspector &R__insp);
00352 static void *new_TMVAcLcLTActivationSigmoid(void *p = 0);
00353 static void *newArray_TMVAcLcLTActivationSigmoid(Long_t size, void *p);
00354 static void delete_TMVAcLcLTActivationSigmoid(void *p);
00355 static void deleteArray_TMVAcLcLTActivationSigmoid(void *p);
00356 static void destruct_TMVAcLcLTActivationSigmoid(void *p);
00357
00358
00359 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::TActivationSigmoid*)
00360 {
00361 ::TMVA::TActivationSigmoid *ptr = 0;
00362 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::TActivationSigmoid >(0);
00363 static ::ROOT::TGenericClassInfo
00364 instance("TMVA::TActivationSigmoid", ::TMVA::TActivationSigmoid::Class_Version(), "./include/TMVA/TActivationSigmoid.h", 48,
00365 typeid(::TMVA::TActivationSigmoid), DefineBehavior(ptr, ptr),
00366 &::TMVA::TActivationSigmoid::Dictionary, isa_proxy, 4,
00367 sizeof(::TMVA::TActivationSigmoid) );
00368 instance.SetNew(&new_TMVAcLcLTActivationSigmoid);
00369 instance.SetNewArray(&newArray_TMVAcLcLTActivationSigmoid);
00370 instance.SetDelete(&delete_TMVAcLcLTActivationSigmoid);
00371 instance.SetDeleteArray(&deleteArray_TMVAcLcLTActivationSigmoid);
00372 instance.SetDestructor(&destruct_TMVAcLcLTActivationSigmoid);
00373 return &instance;
00374 }
00375 TGenericClassInfo *GenerateInitInstance(const ::TMVA::TActivationSigmoid*)
00376 {
00377 return GenerateInitInstanceLocal((::TMVA::TActivationSigmoid*)0);
00378 }
00379
00380 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::TActivationSigmoid*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00381 }
00382
00383 namespace ROOT {
00384 void TMVAcLcLTActivationIdentity_ShowMembers(void *obj, TMemberInspector &R__insp);
00385 static void *new_TMVAcLcLTActivationIdentity(void *p = 0);
00386 static void *newArray_TMVAcLcLTActivationIdentity(Long_t size, void *p);
00387 static void delete_TMVAcLcLTActivationIdentity(void *p);
00388 static void deleteArray_TMVAcLcLTActivationIdentity(void *p);
00389 static void destruct_TMVAcLcLTActivationIdentity(void *p);
00390
00391
00392 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::TActivationIdentity*)
00393 {
00394 ::TMVA::TActivationIdentity *ptr = 0;
00395 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::TActivationIdentity >(0);
00396 static ::ROOT::TGenericClassInfo
00397 instance("TMVA::TActivationIdentity", ::TMVA::TActivationIdentity::Class_Version(), "./include/TMVA/TActivationIdentity.h", 48,
00398 typeid(::TMVA::TActivationIdentity), DefineBehavior(ptr, ptr),
00399 &::TMVA::TActivationIdentity::Dictionary, isa_proxy, 4,
00400 sizeof(::TMVA::TActivationIdentity) );
00401 instance.SetNew(&new_TMVAcLcLTActivationIdentity);
00402 instance.SetNewArray(&newArray_TMVAcLcLTActivationIdentity);
00403 instance.SetDelete(&delete_TMVAcLcLTActivationIdentity);
00404 instance.SetDeleteArray(&deleteArray_TMVAcLcLTActivationIdentity);
00405 instance.SetDestructor(&destruct_TMVAcLcLTActivationIdentity);
00406 return &instance;
00407 }
00408 TGenericClassInfo *GenerateInitInstance(const ::TMVA::TActivationIdentity*)
00409 {
00410 return GenerateInitInstanceLocal((::TMVA::TActivationIdentity*)0);
00411 }
00412
00413 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::TActivationIdentity*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00414 }
00415
00416 namespace ROOT {
00417 void TMVAcLcLTActivationTanh_ShowMembers(void *obj, TMemberInspector &R__insp);
00418 static void *new_TMVAcLcLTActivationTanh(void *p = 0);
00419 static void *newArray_TMVAcLcLTActivationTanh(Long_t size, void *p);
00420 static void delete_TMVAcLcLTActivationTanh(void *p);
00421 static void deleteArray_TMVAcLcLTActivationTanh(void *p);
00422 static void destruct_TMVAcLcLTActivationTanh(void *p);
00423
00424
00425 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::TActivationTanh*)
00426 {
00427 ::TMVA::TActivationTanh *ptr = 0;
00428 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::TActivationTanh >(0);
00429 static ::ROOT::TGenericClassInfo
00430 instance("TMVA::TActivationTanh", ::TMVA::TActivationTanh::Class_Version(), "./include/TMVA/TActivationTanh.h", 48,
00431 typeid(::TMVA::TActivationTanh), DefineBehavior(ptr, ptr),
00432 &::TMVA::TActivationTanh::Dictionary, isa_proxy, 4,
00433 sizeof(::TMVA::TActivationTanh) );
00434 instance.SetNew(&new_TMVAcLcLTActivationTanh);
00435 instance.SetNewArray(&newArray_TMVAcLcLTActivationTanh);
00436 instance.SetDelete(&delete_TMVAcLcLTActivationTanh);
00437 instance.SetDeleteArray(&deleteArray_TMVAcLcLTActivationTanh);
00438 instance.SetDestructor(&destruct_TMVAcLcLTActivationTanh);
00439 return &instance;
00440 }
00441 TGenericClassInfo *GenerateInitInstance(const ::TMVA::TActivationTanh*)
00442 {
00443 return GenerateInitInstanceLocal((::TMVA::TActivationTanh*)0);
00444 }
00445
00446 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::TActivationTanh*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00447 }
00448
00449 namespace ROOT {
00450 void TMVAcLcLTActivationRadial_ShowMembers(void *obj, TMemberInspector &R__insp);
00451 static void *new_TMVAcLcLTActivationRadial(void *p = 0);
00452 static void *newArray_TMVAcLcLTActivationRadial(Long_t size, void *p);
00453 static void delete_TMVAcLcLTActivationRadial(void *p);
00454 static void deleteArray_TMVAcLcLTActivationRadial(void *p);
00455 static void destruct_TMVAcLcLTActivationRadial(void *p);
00456
00457
00458 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::TActivationRadial*)
00459 {
00460 ::TMVA::TActivationRadial *ptr = 0;
00461 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::TActivationRadial >(0);
00462 static ::ROOT::TGenericClassInfo
00463 instance("TMVA::TActivationRadial", ::TMVA::TActivationRadial::Class_Version(), "./include/TMVA/TActivationRadial.h", 48,
00464 typeid(::TMVA::TActivationRadial), DefineBehavior(ptr, ptr),
00465 &::TMVA::TActivationRadial::Dictionary, isa_proxy, 4,
00466 sizeof(::TMVA::TActivationRadial) );
00467 instance.SetNew(&new_TMVAcLcLTActivationRadial);
00468 instance.SetNewArray(&newArray_TMVAcLcLTActivationRadial);
00469 instance.SetDelete(&delete_TMVAcLcLTActivationRadial);
00470 instance.SetDeleteArray(&deleteArray_TMVAcLcLTActivationRadial);
00471 instance.SetDestructor(&destruct_TMVAcLcLTActivationRadial);
00472 return &instance;
00473 }
00474 TGenericClassInfo *GenerateInitInstance(const ::TMVA::TActivationRadial*)
00475 {
00476 return GenerateInitInstanceLocal((::TMVA::TActivationRadial*)0);
00477 }
00478
00479 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::TActivationRadial*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00480 }
00481
00482 namespace ROOT {
00483 void TMVAcLcLTNeuronInputSum_ShowMembers(void *obj, TMemberInspector &R__insp);
00484 static void *new_TMVAcLcLTNeuronInputSum(void *p = 0);
00485 static void *newArray_TMVAcLcLTNeuronInputSum(Long_t size, void *p);
00486 static void delete_TMVAcLcLTNeuronInputSum(void *p);
00487 static void deleteArray_TMVAcLcLTNeuronInputSum(void *p);
00488 static void destruct_TMVAcLcLTNeuronInputSum(void *p);
00489
00490
00491 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::TNeuronInputSum*)
00492 {
00493 ::TMVA::TNeuronInputSum *ptr = 0;
00494 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::TNeuronInputSum >(0);
00495 static ::ROOT::TGenericClassInfo
00496 instance("TMVA::TNeuronInputSum", ::TMVA::TNeuronInputSum::Class_Version(), "./include/TMVA/TNeuronInputSum.h", 52,
00497 typeid(::TMVA::TNeuronInputSum), DefineBehavior(ptr, ptr),
00498 &::TMVA::TNeuronInputSum::Dictionary, isa_proxy, 4,
00499 sizeof(::TMVA::TNeuronInputSum) );
00500 instance.SetNew(&new_TMVAcLcLTNeuronInputSum);
00501 instance.SetNewArray(&newArray_TMVAcLcLTNeuronInputSum);
00502 instance.SetDelete(&delete_TMVAcLcLTNeuronInputSum);
00503 instance.SetDeleteArray(&deleteArray_TMVAcLcLTNeuronInputSum);
00504 instance.SetDestructor(&destruct_TMVAcLcLTNeuronInputSum);
00505 return &instance;
00506 }
00507 TGenericClassInfo *GenerateInitInstance(const ::TMVA::TNeuronInputSum*)
00508 {
00509 return GenerateInitInstanceLocal((::TMVA::TNeuronInputSum*)0);
00510 }
00511
00512 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::TNeuronInputSum*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00513 }
00514
00515 namespace ROOT {
00516 void TMVAcLcLTNeuronInputSqSum_ShowMembers(void *obj, TMemberInspector &R__insp);
00517 static void *new_TMVAcLcLTNeuronInputSqSum(void *p = 0);
00518 static void *newArray_TMVAcLcLTNeuronInputSqSum(Long_t size, void *p);
00519 static void delete_TMVAcLcLTNeuronInputSqSum(void *p);
00520 static void deleteArray_TMVAcLcLTNeuronInputSqSum(void *p);
00521 static void destruct_TMVAcLcLTNeuronInputSqSum(void *p);
00522
00523
00524 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::TNeuronInputSqSum*)
00525 {
00526 ::TMVA::TNeuronInputSqSum *ptr = 0;
00527 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::TNeuronInputSqSum >(0);
00528 static ::ROOT::TGenericClassInfo
00529 instance("TMVA::TNeuronInputSqSum", ::TMVA::TNeuronInputSqSum::Class_Version(), "./include/TMVA/TNeuronInputSqSum.h", 54,
00530 typeid(::TMVA::TNeuronInputSqSum), DefineBehavior(ptr, ptr),
00531 &::TMVA::TNeuronInputSqSum::Dictionary, isa_proxy, 4,
00532 sizeof(::TMVA::TNeuronInputSqSum) );
00533 instance.SetNew(&new_TMVAcLcLTNeuronInputSqSum);
00534 instance.SetNewArray(&newArray_TMVAcLcLTNeuronInputSqSum);
00535 instance.SetDelete(&delete_TMVAcLcLTNeuronInputSqSum);
00536 instance.SetDeleteArray(&deleteArray_TMVAcLcLTNeuronInputSqSum);
00537 instance.SetDestructor(&destruct_TMVAcLcLTNeuronInputSqSum);
00538 return &instance;
00539 }
00540 TGenericClassInfo *GenerateInitInstance(const ::TMVA::TNeuronInputSqSum*)
00541 {
00542 return GenerateInitInstanceLocal((::TMVA::TNeuronInputSqSum*)0);
00543 }
00544
00545 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::TNeuronInputSqSum*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00546 }
00547
00548 namespace ROOT {
00549 void TMVAcLcLTNeuronInputAbs_ShowMembers(void *obj, TMemberInspector &R__insp);
00550 static void *new_TMVAcLcLTNeuronInputAbs(void *p = 0);
00551 static void *newArray_TMVAcLcLTNeuronInputAbs(Long_t size, void *p);
00552 static void delete_TMVAcLcLTNeuronInputAbs(void *p);
00553 static void deleteArray_TMVAcLcLTNeuronInputAbs(void *p);
00554 static void destruct_TMVAcLcLTNeuronInputAbs(void *p);
00555
00556
00557 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::TNeuronInputAbs*)
00558 {
00559 ::TMVA::TNeuronInputAbs *ptr = 0;
00560 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::TNeuronInputAbs >(0);
00561 static ::ROOT::TGenericClassInfo
00562 instance("TMVA::TNeuronInputAbs", ::TMVA::TNeuronInputAbs::Class_Version(), "./include/TMVA/TNeuronInputAbs.h", 70,
00563 typeid(::TMVA::TNeuronInputAbs), DefineBehavior(ptr, ptr),
00564 &::TMVA::TNeuronInputAbs::Dictionary, isa_proxy, 4,
00565 sizeof(::TMVA::TNeuronInputAbs) );
00566 instance.SetNew(&new_TMVAcLcLTNeuronInputAbs);
00567 instance.SetNewArray(&newArray_TMVAcLcLTNeuronInputAbs);
00568 instance.SetDelete(&delete_TMVAcLcLTNeuronInputAbs);
00569 instance.SetDeleteArray(&deleteArray_TMVAcLcLTNeuronInputAbs);
00570 instance.SetDestructor(&destruct_TMVAcLcLTNeuronInputAbs);
00571 return &instance;
00572 }
00573 TGenericClassInfo *GenerateInitInstance(const ::TMVA::TNeuronInputAbs*)
00574 {
00575 return GenerateInitInstanceLocal((::TMVA::TNeuronInputAbs*)0);
00576 }
00577
00578 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::TNeuronInputAbs*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00579 }
00580
00581 namespace ROOT {
00582 void TMVAcLcLTNeuronInputChooser_ShowMembers(void *obj, TMemberInspector &R__insp);
00583 static void *new_TMVAcLcLTNeuronInputChooser(void *p = 0);
00584 static void *newArray_TMVAcLcLTNeuronInputChooser(Long_t size, void *p);
00585 static void delete_TMVAcLcLTNeuronInputChooser(void *p);
00586 static void deleteArray_TMVAcLcLTNeuronInputChooser(void *p);
00587 static void destruct_TMVAcLcLTNeuronInputChooser(void *p);
00588
00589
00590 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::TNeuronInputChooser*)
00591 {
00592 ::TMVA::TNeuronInputChooser *ptr = 0;
00593 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::TNeuronInputChooser >(0);
00594 static ::ROOT::TGenericClassInfo
00595 instance("TMVA::TNeuronInputChooser", ::TMVA::TNeuronInputChooser::Class_Version(), "./include/TMVA/TNeuronInputChooser.h", 66,
00596 typeid(::TMVA::TNeuronInputChooser), DefineBehavior(ptr, ptr),
00597 &::TMVA::TNeuronInputChooser::Dictionary, isa_proxy, 4,
00598 sizeof(::TMVA::TNeuronInputChooser) );
00599 instance.SetNew(&new_TMVAcLcLTNeuronInputChooser);
00600 instance.SetNewArray(&newArray_TMVAcLcLTNeuronInputChooser);
00601 instance.SetDelete(&delete_TMVAcLcLTNeuronInputChooser);
00602 instance.SetDeleteArray(&deleteArray_TMVAcLcLTNeuronInputChooser);
00603 instance.SetDestructor(&destruct_TMVAcLcLTNeuronInputChooser);
00604 return &instance;
00605 }
00606 TGenericClassInfo *GenerateInitInstance(const ::TMVA::TNeuronInputChooser*)
00607 {
00608 return GenerateInitInstanceLocal((::TMVA::TNeuronInputChooser*)0);
00609 }
00610
00611 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::TNeuronInputChooser*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00612 }
00613
00614 namespace ROOT {
00615 void TMVAcLcLRanking_ShowMembers(void *obj, TMemberInspector &R__insp);
00616 static void *new_TMVAcLcLRanking(void *p = 0);
00617 static void *newArray_TMVAcLcLRanking(Long_t size, void *p);
00618 static void delete_TMVAcLcLRanking(void *p);
00619 static void deleteArray_TMVAcLcLRanking(void *p);
00620 static void destruct_TMVAcLcLRanking(void *p);
00621
00622
00623 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::Ranking*)
00624 {
00625 ::TMVA::Ranking *ptr = 0;
00626 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::Ranking >(0);
00627 static ::ROOT::TGenericClassInfo
00628 instance("TMVA::Ranking", ::TMVA::Ranking::Class_Version(), "./include/TMVA/Ranking.h", 50,
00629 typeid(::TMVA::Ranking), DefineBehavior(ptr, ptr),
00630 &::TMVA::Ranking::Dictionary, isa_proxy, 4,
00631 sizeof(::TMVA::Ranking) );
00632 instance.SetNew(&new_TMVAcLcLRanking);
00633 instance.SetNewArray(&newArray_TMVAcLcLRanking);
00634 instance.SetDelete(&delete_TMVAcLcLRanking);
00635 instance.SetDeleteArray(&deleteArray_TMVAcLcLRanking);
00636 instance.SetDestructor(&destruct_TMVAcLcLRanking);
00637 return &instance;
00638 }
00639 TGenericClassInfo *GenerateInitInstance(const ::TMVA::Ranking*)
00640 {
00641 return GenerateInitInstanceLocal((::TMVA::Ranking*)0);
00642 }
00643
00644 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::Ranking*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00645 }
00646
00647 namespace ROOT {
00648 void TMVAcLcLRuleFit_ShowMembers(void *obj, TMemberInspector &R__insp);
00649 static void *new_TMVAcLcLRuleFit(void *p = 0);
00650 static void *newArray_TMVAcLcLRuleFit(Long_t size, void *p);
00651 static void delete_TMVAcLcLRuleFit(void *p);
00652 static void deleteArray_TMVAcLcLRuleFit(void *p);
00653 static void destruct_TMVAcLcLRuleFit(void *p);
00654
00655
00656 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::RuleFit*)
00657 {
00658 ::TMVA::RuleFit *ptr = 0;
00659 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::RuleFit >(0);
00660 static ::ROOT::TGenericClassInfo
00661 instance("TMVA::RuleFit", ::TMVA::RuleFit::Class_Version(), "./include/TMVA/RuleFit.h", 52,
00662 typeid(::TMVA::RuleFit), DefineBehavior(ptr, ptr),
00663 &::TMVA::RuleFit::Dictionary, isa_proxy, 4,
00664 sizeof(::TMVA::RuleFit) );
00665 instance.SetNew(&new_TMVAcLcLRuleFit);
00666 instance.SetNewArray(&newArray_TMVAcLcLRuleFit);
00667 instance.SetDelete(&delete_TMVAcLcLRuleFit);
00668 instance.SetDeleteArray(&deleteArray_TMVAcLcLRuleFit);
00669 instance.SetDestructor(&destruct_TMVAcLcLRuleFit);
00670 return &instance;
00671 }
00672 TGenericClassInfo *GenerateInitInstance(const ::TMVA::RuleFit*)
00673 {
00674 return GenerateInitInstanceLocal((::TMVA::RuleFit*)0);
00675 }
00676
00677 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::RuleFit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00678 }
00679
00680 namespace ROOT {
00681 void TMVAcLcLRuleFitAPI_ShowMembers(void *obj, TMemberInspector &R__insp);
00682 static void delete_TMVAcLcLRuleFitAPI(void *p);
00683 static void deleteArray_TMVAcLcLRuleFitAPI(void *p);
00684 static void destruct_TMVAcLcLRuleFitAPI(void *p);
00685
00686
00687 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::RuleFitAPI*)
00688 {
00689 ::TMVA::RuleFitAPI *ptr = 0;
00690 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::RuleFitAPI >(0);
00691 static ::ROOT::TGenericClassInfo
00692 instance("TMVA::RuleFitAPI", ::TMVA::RuleFitAPI::Class_Version(), "./include/TMVA/RuleFitAPI.h", 49,
00693 typeid(::TMVA::RuleFitAPI), DefineBehavior(ptr, ptr),
00694 &::TMVA::RuleFitAPI::Dictionary, isa_proxy, 4,
00695 sizeof(::TMVA::RuleFitAPI) );
00696 instance.SetDelete(&delete_TMVAcLcLRuleFitAPI);
00697 instance.SetDeleteArray(&deleteArray_TMVAcLcLRuleFitAPI);
00698 instance.SetDestructor(&destruct_TMVAcLcLRuleFitAPI);
00699 return &instance;
00700 }
00701 TGenericClassInfo *GenerateInitInstance(const ::TMVA::RuleFitAPI*)
00702 {
00703 return GenerateInitInstanceLocal((::TMVA::RuleFitAPI*)0);
00704 }
00705
00706 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::RuleFitAPI*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00707 }
00708
00709 namespace ROOT {
00710 void TMVAcLcLIMethod_ShowMembers(void *obj, TMemberInspector &R__insp);
00711 static void delete_TMVAcLcLIMethod(void *p);
00712 static void deleteArray_TMVAcLcLIMethod(void *p);
00713 static void destruct_TMVAcLcLIMethod(void *p);
00714
00715
00716 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::IMethod*)
00717 {
00718 ::TMVA::IMethod *ptr = 0;
00719 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::IMethod >(0);
00720 static ::ROOT::TGenericClassInfo
00721 instance("TMVA::IMethod", ::TMVA::IMethod::Class_Version(), "./include/TMVA/IMethod.h", 62,
00722 typeid(::TMVA::IMethod), DefineBehavior(ptr, ptr),
00723 &::TMVA::IMethod::Dictionary, isa_proxy, 4,
00724 sizeof(::TMVA::IMethod) );
00725 instance.SetDelete(&delete_TMVAcLcLIMethod);
00726 instance.SetDeleteArray(&deleteArray_TMVAcLcLIMethod);
00727 instance.SetDestructor(&destruct_TMVAcLcLIMethod);
00728 return &instance;
00729 }
00730 TGenericClassInfo *GenerateInitInstance(const ::TMVA::IMethod*)
00731 {
00732 return GenerateInitInstanceLocal((::TMVA::IMethod*)0);
00733 }
00734
00735 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::IMethod*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00736 }
00737
00738 namespace ROOT {
00739 void TMVAcLcLVariableTransformBase_ShowMembers(void *obj, TMemberInspector &R__insp);
00740 static void delete_TMVAcLcLVariableTransformBase(void *p);
00741 static void deleteArray_TMVAcLcLVariableTransformBase(void *p);
00742 static void destruct_TMVAcLcLVariableTransformBase(void *p);
00743
00744
00745 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::VariableTransformBase*)
00746 {
00747 ::TMVA::VariableTransformBase *ptr = 0;
00748 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::VariableTransformBase >(0);
00749 static ::ROOT::TGenericClassInfo
00750 instance("TMVA::VariableTransformBase", ::TMVA::VariableTransformBase::Class_Version(), "./include/TMVA/VariableTransformBase.h", 67,
00751 typeid(::TMVA::VariableTransformBase), DefineBehavior(ptr, ptr),
00752 &::TMVA::VariableTransformBase::Dictionary, isa_proxy, 4,
00753 sizeof(::TMVA::VariableTransformBase) );
00754 instance.SetDelete(&delete_TMVAcLcLVariableTransformBase);
00755 instance.SetDeleteArray(&deleteArray_TMVAcLcLVariableTransformBase);
00756 instance.SetDestructor(&destruct_TMVAcLcLVariableTransformBase);
00757 return &instance;
00758 }
00759 TGenericClassInfo *GenerateInitInstance(const ::TMVA::VariableTransformBase*)
00760 {
00761 return GenerateInitInstanceLocal((::TMVA::VariableTransformBase*)0);
00762 }
00763
00764 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::VariableTransformBase*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00765 }
00766
00767 namespace ROOT {
00768 void TMVAcLcLVariableIdentityTransform_ShowMembers(void *obj, TMemberInspector &R__insp);
00769 static void delete_TMVAcLcLVariableIdentityTransform(void *p);
00770 static void deleteArray_TMVAcLcLVariableIdentityTransform(void *p);
00771 static void destruct_TMVAcLcLVariableIdentityTransform(void *p);
00772
00773
00774 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::VariableIdentityTransform*)
00775 {
00776 ::TMVA::VariableIdentityTransform *ptr = 0;
00777 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::VariableIdentityTransform >(0);
00778 static ::ROOT::TGenericClassInfo
00779 instance("TMVA::VariableIdentityTransform", ::TMVA::VariableIdentityTransform::Class_Version(), "./include/TMVA/VariableIdentityTransform.h", 45,
00780 typeid(::TMVA::VariableIdentityTransform), DefineBehavior(ptr, ptr),
00781 &::TMVA::VariableIdentityTransform::Dictionary, isa_proxy, 4,
00782 sizeof(::TMVA::VariableIdentityTransform) );
00783 instance.SetDelete(&delete_TMVAcLcLVariableIdentityTransform);
00784 instance.SetDeleteArray(&deleteArray_TMVAcLcLVariableIdentityTransform);
00785 instance.SetDestructor(&destruct_TMVAcLcLVariableIdentityTransform);
00786 return &instance;
00787 }
00788 TGenericClassInfo *GenerateInitInstance(const ::TMVA::VariableIdentityTransform*)
00789 {
00790 return GenerateInitInstanceLocal((::TMVA::VariableIdentityTransform*)0);
00791 }
00792
00793 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::VariableIdentityTransform*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00794 }
00795
00796 namespace ROOT {
00797 void TMVAcLcLVariableDecorrTransform_ShowMembers(void *obj, TMemberInspector &R__insp);
00798 static void delete_TMVAcLcLVariableDecorrTransform(void *p);
00799 static void deleteArray_TMVAcLcLVariableDecorrTransform(void *p);
00800 static void destruct_TMVAcLcLVariableDecorrTransform(void *p);
00801
00802
00803 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::VariableDecorrTransform*)
00804 {
00805 ::TMVA::VariableDecorrTransform *ptr = 0;
00806 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::VariableDecorrTransform >(0);
00807 static ::ROOT::TGenericClassInfo
00808 instance("TMVA::VariableDecorrTransform", ::TMVA::VariableDecorrTransform::Class_Version(), "./include/TMVA/VariableDecorrTransform.h", 53,
00809 typeid(::TMVA::VariableDecorrTransform), DefineBehavior(ptr, ptr),
00810 &::TMVA::VariableDecorrTransform::Dictionary, isa_proxy, 4,
00811 sizeof(::TMVA::VariableDecorrTransform) );
00812 instance.SetDelete(&delete_TMVAcLcLVariableDecorrTransform);
00813 instance.SetDeleteArray(&deleteArray_TMVAcLcLVariableDecorrTransform);
00814 instance.SetDestructor(&destruct_TMVAcLcLVariableDecorrTransform);
00815 return &instance;
00816 }
00817 TGenericClassInfo *GenerateInitInstance(const ::TMVA::VariableDecorrTransform*)
00818 {
00819 return GenerateInitInstanceLocal((::TMVA::VariableDecorrTransform*)0);
00820 }
00821
00822 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::VariableDecorrTransform*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00823 }
00824
00825 namespace ROOT {
00826 void TMVAcLcLVariablePCATransform_ShowMembers(void *obj, TMemberInspector &R__insp);
00827 static void delete_TMVAcLcLVariablePCATransform(void *p);
00828 static void deleteArray_TMVAcLcLVariablePCATransform(void *p);
00829 static void destruct_TMVAcLcLVariablePCATransform(void *p);
00830
00831
00832 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::VariablePCATransform*)
00833 {
00834 ::TMVA::VariablePCATransform *ptr = 0;
00835 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::VariablePCATransform >(0);
00836 static ::ROOT::TGenericClassInfo
00837 instance("TMVA::VariablePCATransform", ::TMVA::VariablePCATransform::Class_Version(), "./include/TMVA/VariablePCATransform.h", 49,
00838 typeid(::TMVA::VariablePCATransform), DefineBehavior(ptr, ptr),
00839 &::TMVA::VariablePCATransform::Dictionary, isa_proxy, 4,
00840 sizeof(::TMVA::VariablePCATransform) );
00841 instance.SetDelete(&delete_TMVAcLcLVariablePCATransform);
00842 instance.SetDeleteArray(&deleteArray_TMVAcLcLVariablePCATransform);
00843 instance.SetDestructor(&destruct_TMVAcLcLVariablePCATransform);
00844 return &instance;
00845 }
00846 TGenericClassInfo *GenerateInitInstance(const ::TMVA::VariablePCATransform*)
00847 {
00848 return GenerateInitInstanceLocal((::TMVA::VariablePCATransform*)0);
00849 }
00850
00851 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::VariablePCATransform*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00852 }
00853
00854 namespace ROOT {
00855 void TMVAcLcLVariableGaussTransform_ShowMembers(void *obj, TMemberInspector &R__insp);
00856 static void delete_TMVAcLcLVariableGaussTransform(void *p);
00857 static void deleteArray_TMVAcLcLVariableGaussTransform(void *p);
00858 static void destruct_TMVAcLcLVariableGaussTransform(void *p);
00859
00860
00861 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::VariableGaussTransform*)
00862 {
00863 ::TMVA::VariableGaussTransform *ptr = 0;
00864 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::VariableGaussTransform >(0);
00865 static ::ROOT::TGenericClassInfo
00866 instance("TMVA::VariableGaussTransform", ::TMVA::VariableGaussTransform::Class_Version(), "./include/TMVA/VariableGaussTransform.h", 86,
00867 typeid(::TMVA::VariableGaussTransform), DefineBehavior(ptr, ptr),
00868 &::TMVA::VariableGaussTransform::Dictionary, isa_proxy, 4,
00869 sizeof(::TMVA::VariableGaussTransform) );
00870 instance.SetDelete(&delete_TMVAcLcLVariableGaussTransform);
00871 instance.SetDeleteArray(&deleteArray_TMVAcLcLVariableGaussTransform);
00872 instance.SetDestructor(&destruct_TMVAcLcLVariableGaussTransform);
00873 return &instance;
00874 }
00875 TGenericClassInfo *GenerateInitInstance(const ::TMVA::VariableGaussTransform*)
00876 {
00877 return GenerateInitInstanceLocal((::TMVA::VariableGaussTransform*)0);
00878 }
00879
00880 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::VariableGaussTransform*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00881 }
00882
00883 namespace ROOT {
00884 void TMVAcLcLVariableNormalizeTransform_ShowMembers(void *obj, TMemberInspector &R__insp);
00885 static void delete_TMVAcLcLVariableNormalizeTransform(void *p);
00886 static void deleteArray_TMVAcLcLVariableNormalizeTransform(void *p);
00887 static void destruct_TMVAcLcLVariableNormalizeTransform(void *p);
00888
00889
00890 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::VariableNormalizeTransform*)
00891 {
00892 ::TMVA::VariableNormalizeTransform *ptr = 0;
00893 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::VariableNormalizeTransform >(0);
00894 static ::ROOT::TGenericClassInfo
00895 instance("TMVA::VariableNormalizeTransform", ::TMVA::VariableNormalizeTransform::Class_Version(), "./include/TMVA/VariableNormalizeTransform.h", 49,
00896 typeid(::TMVA::VariableNormalizeTransform), DefineBehavior(ptr, ptr),
00897 &::TMVA::VariableNormalizeTransform::Dictionary, isa_proxy, 4,
00898 sizeof(::TMVA::VariableNormalizeTransform) );
00899 instance.SetDelete(&delete_TMVAcLcLVariableNormalizeTransform);
00900 instance.SetDeleteArray(&deleteArray_TMVAcLcLVariableNormalizeTransform);
00901 instance.SetDestructor(&destruct_TMVAcLcLVariableNormalizeTransform);
00902 return &instance;
00903 }
00904 TGenericClassInfo *GenerateInitInstance(const ::TMVA::VariableNormalizeTransform*)
00905 {
00906 return GenerateInitInstanceLocal((::TMVA::VariableNormalizeTransform*)0);
00907 }
00908
00909 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::VariableNormalizeTransform*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00910 }
00911
00912 namespace TMVA {
00913
00914 TClass *TNeuron::fgIsA = 0;
00915
00916
00917 const char *TNeuron::Class_Name()
00918 {
00919 return "TMVA::TNeuron";
00920 }
00921
00922
00923 const char *TNeuron::ImplFileName()
00924 {
00925 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuron*)0x0)->GetImplFileName();
00926 }
00927
00928
00929 int TNeuron::ImplFileLine()
00930 {
00931 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuron*)0x0)->GetImplFileLine();
00932 }
00933
00934
00935 void TNeuron::Dictionary()
00936 {
00937 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuron*)0x0)->GetClass();
00938 }
00939
00940
00941 TClass *TNeuron::Class()
00942 {
00943 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuron*)0x0)->GetClass();
00944 return fgIsA;
00945 }
00946
00947 }
00948 namespace TMVA {
00949
00950 TClass *MsgLogger::fgIsA = 0;
00951
00952
00953 const char *MsgLogger::Class_Name()
00954 {
00955 return "TMVA::MsgLogger";
00956 }
00957
00958
00959 const char *MsgLogger::ImplFileName()
00960 {
00961 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MsgLogger*)0x0)->GetImplFileName();
00962 }
00963
00964
00965 int MsgLogger::ImplFileLine()
00966 {
00967 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MsgLogger*)0x0)->GetImplFileLine();
00968 }
00969
00970
00971 void MsgLogger::Dictionary()
00972 {
00973 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MsgLogger*)0x0)->GetClass();
00974 }
00975
00976
00977 TClass *MsgLogger::Class()
00978 {
00979 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MsgLogger*)0x0)->GetClass();
00980 return fgIsA;
00981 }
00982
00983 }
00984 namespace TMVA {
00985
00986 TClass *TSynapse::fgIsA = 0;
00987
00988
00989 const char *TSynapse::Class_Name()
00990 {
00991 return "TMVA::TSynapse";
00992 }
00993
00994
00995 const char *TSynapse::ImplFileName()
00996 {
00997 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TSynapse*)0x0)->GetImplFileName();
00998 }
00999
01000
01001 int TSynapse::ImplFileLine()
01002 {
01003 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TSynapse*)0x0)->GetImplFileLine();
01004 }
01005
01006
01007 void TSynapse::Dictionary()
01008 {
01009 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TSynapse*)0x0)->GetClass();
01010 }
01011
01012
01013 TClass *TSynapse::Class()
01014 {
01015 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TSynapse*)0x0)->GetClass();
01016 return fgIsA;
01017 }
01018
01019 }
01020 namespace TMVA {
01021
01022 TClass *TActivation::fgIsA = 0;
01023
01024
01025 const char *TActivation::Class_Name()
01026 {
01027 return "TMVA::TActivation";
01028 }
01029
01030
01031 const char *TActivation::ImplFileName()
01032 {
01033 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivation*)0x0)->GetImplFileName();
01034 }
01035
01036
01037 int TActivation::ImplFileLine()
01038 {
01039 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivation*)0x0)->GetImplFileLine();
01040 }
01041
01042
01043 void TActivation::Dictionary()
01044 {
01045 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivation*)0x0)->GetClass();
01046 }
01047
01048
01049 TClass *TActivation::Class()
01050 {
01051 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivation*)0x0)->GetClass();
01052 return fgIsA;
01053 }
01054
01055 }
01056 namespace TMVA {
01057
01058 TClass *TNeuronInput::fgIsA = 0;
01059
01060
01061 const char *TNeuronInput::Class_Name()
01062 {
01063 return "TMVA::TNeuronInput";
01064 }
01065
01066
01067 const char *TNeuronInput::ImplFileName()
01068 {
01069 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInput*)0x0)->GetImplFileName();
01070 }
01071
01072
01073 int TNeuronInput::ImplFileLine()
01074 {
01075 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInput*)0x0)->GetImplFileLine();
01076 }
01077
01078
01079 void TNeuronInput::Dictionary()
01080 {
01081 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInput*)0x0)->GetClass();
01082 }
01083
01084
01085 TClass *TNeuronInput::Class()
01086 {
01087 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInput*)0x0)->GetClass();
01088 return fgIsA;
01089 }
01090
01091 }
01092 namespace TMVA {
01093
01094 TClass *TActivationChooser::fgIsA = 0;
01095
01096
01097 const char *TActivationChooser::Class_Name()
01098 {
01099 return "TMVA::TActivationChooser";
01100 }
01101
01102
01103 const char *TActivationChooser::ImplFileName()
01104 {
01105 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationChooser*)0x0)->GetImplFileName();
01106 }
01107
01108
01109 int TActivationChooser::ImplFileLine()
01110 {
01111 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationChooser*)0x0)->GetImplFileLine();
01112 }
01113
01114
01115 void TActivationChooser::Dictionary()
01116 {
01117 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationChooser*)0x0)->GetClass();
01118 }
01119
01120
01121 TClass *TActivationChooser::Class()
01122 {
01123 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationChooser*)0x0)->GetClass();
01124 return fgIsA;
01125 }
01126
01127 }
01128 namespace TMVA {
01129
01130 TClass *TActivationSigmoid::fgIsA = 0;
01131
01132
01133 const char *TActivationSigmoid::Class_Name()
01134 {
01135 return "TMVA::TActivationSigmoid";
01136 }
01137
01138
01139 const char *TActivationSigmoid::ImplFileName()
01140 {
01141 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationSigmoid*)0x0)->GetImplFileName();
01142 }
01143
01144
01145 int TActivationSigmoid::ImplFileLine()
01146 {
01147 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationSigmoid*)0x0)->GetImplFileLine();
01148 }
01149
01150
01151 void TActivationSigmoid::Dictionary()
01152 {
01153 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationSigmoid*)0x0)->GetClass();
01154 }
01155
01156
01157 TClass *TActivationSigmoid::Class()
01158 {
01159 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationSigmoid*)0x0)->GetClass();
01160 return fgIsA;
01161 }
01162
01163 }
01164 namespace TMVA {
01165
01166 TClass *TActivationIdentity::fgIsA = 0;
01167
01168
01169 const char *TActivationIdentity::Class_Name()
01170 {
01171 return "TMVA::TActivationIdentity";
01172 }
01173
01174
01175 const char *TActivationIdentity::ImplFileName()
01176 {
01177 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationIdentity*)0x0)->GetImplFileName();
01178 }
01179
01180
01181 int TActivationIdentity::ImplFileLine()
01182 {
01183 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationIdentity*)0x0)->GetImplFileLine();
01184 }
01185
01186
01187 void TActivationIdentity::Dictionary()
01188 {
01189 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationIdentity*)0x0)->GetClass();
01190 }
01191
01192
01193 TClass *TActivationIdentity::Class()
01194 {
01195 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationIdentity*)0x0)->GetClass();
01196 return fgIsA;
01197 }
01198
01199 }
01200 namespace TMVA {
01201
01202 TClass *TActivationTanh::fgIsA = 0;
01203
01204
01205 const char *TActivationTanh::Class_Name()
01206 {
01207 return "TMVA::TActivationTanh";
01208 }
01209
01210
01211 const char *TActivationTanh::ImplFileName()
01212 {
01213 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationTanh*)0x0)->GetImplFileName();
01214 }
01215
01216
01217 int TActivationTanh::ImplFileLine()
01218 {
01219 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationTanh*)0x0)->GetImplFileLine();
01220 }
01221
01222
01223 void TActivationTanh::Dictionary()
01224 {
01225 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationTanh*)0x0)->GetClass();
01226 }
01227
01228
01229 TClass *TActivationTanh::Class()
01230 {
01231 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationTanh*)0x0)->GetClass();
01232 return fgIsA;
01233 }
01234
01235 }
01236 namespace TMVA {
01237
01238 TClass *TActivationRadial::fgIsA = 0;
01239
01240
01241 const char *TActivationRadial::Class_Name()
01242 {
01243 return "TMVA::TActivationRadial";
01244 }
01245
01246
01247 const char *TActivationRadial::ImplFileName()
01248 {
01249 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationRadial*)0x0)->GetImplFileName();
01250 }
01251
01252
01253 int TActivationRadial::ImplFileLine()
01254 {
01255 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationRadial*)0x0)->GetImplFileLine();
01256 }
01257
01258
01259 void TActivationRadial::Dictionary()
01260 {
01261 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationRadial*)0x0)->GetClass();
01262 }
01263
01264
01265 TClass *TActivationRadial::Class()
01266 {
01267 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TActivationRadial*)0x0)->GetClass();
01268 return fgIsA;
01269 }
01270
01271 }
01272 namespace TMVA {
01273
01274 TClass *TNeuronInputSum::fgIsA = 0;
01275
01276
01277 const char *TNeuronInputSum::Class_Name()
01278 {
01279 return "TMVA::TNeuronInputSum";
01280 }
01281
01282
01283 const char *TNeuronInputSum::ImplFileName()
01284 {
01285 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputSum*)0x0)->GetImplFileName();
01286 }
01287
01288
01289 int TNeuronInputSum::ImplFileLine()
01290 {
01291 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputSum*)0x0)->GetImplFileLine();
01292 }
01293
01294
01295 void TNeuronInputSum::Dictionary()
01296 {
01297 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputSum*)0x0)->GetClass();
01298 }
01299
01300
01301 TClass *TNeuronInputSum::Class()
01302 {
01303 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputSum*)0x0)->GetClass();
01304 return fgIsA;
01305 }
01306
01307 }
01308 namespace TMVA {
01309
01310 TClass *TNeuronInputSqSum::fgIsA = 0;
01311
01312
01313 const char *TNeuronInputSqSum::Class_Name()
01314 {
01315 return "TMVA::TNeuronInputSqSum";
01316 }
01317
01318
01319 const char *TNeuronInputSqSum::ImplFileName()
01320 {
01321 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputSqSum*)0x0)->GetImplFileName();
01322 }
01323
01324
01325 int TNeuronInputSqSum::ImplFileLine()
01326 {
01327 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputSqSum*)0x0)->GetImplFileLine();
01328 }
01329
01330
01331 void TNeuronInputSqSum::Dictionary()
01332 {
01333 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputSqSum*)0x0)->GetClass();
01334 }
01335
01336
01337 TClass *TNeuronInputSqSum::Class()
01338 {
01339 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputSqSum*)0x0)->GetClass();
01340 return fgIsA;
01341 }
01342
01343 }
01344 namespace TMVA {
01345
01346 TClass *TNeuronInputAbs::fgIsA = 0;
01347
01348
01349 const char *TNeuronInputAbs::Class_Name()
01350 {
01351 return "TMVA::TNeuronInputAbs";
01352 }
01353
01354
01355 const char *TNeuronInputAbs::ImplFileName()
01356 {
01357 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputAbs*)0x0)->GetImplFileName();
01358 }
01359
01360
01361 int TNeuronInputAbs::ImplFileLine()
01362 {
01363 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputAbs*)0x0)->GetImplFileLine();
01364 }
01365
01366
01367 void TNeuronInputAbs::Dictionary()
01368 {
01369 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputAbs*)0x0)->GetClass();
01370 }
01371
01372
01373 TClass *TNeuronInputAbs::Class()
01374 {
01375 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputAbs*)0x0)->GetClass();
01376 return fgIsA;
01377 }
01378
01379 }
01380 namespace TMVA {
01381
01382 TClass *TNeuronInputChooser::fgIsA = 0;
01383
01384
01385 const char *TNeuronInputChooser::Class_Name()
01386 {
01387 return "TMVA::TNeuronInputChooser";
01388 }
01389
01390
01391 const char *TNeuronInputChooser::ImplFileName()
01392 {
01393 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputChooser*)0x0)->GetImplFileName();
01394 }
01395
01396
01397 int TNeuronInputChooser::ImplFileLine()
01398 {
01399 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputChooser*)0x0)->GetImplFileLine();
01400 }
01401
01402
01403 void TNeuronInputChooser::Dictionary()
01404 {
01405 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputChooser*)0x0)->GetClass();
01406 }
01407
01408
01409 TClass *TNeuronInputChooser::Class()
01410 {
01411 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::TNeuronInputChooser*)0x0)->GetClass();
01412 return fgIsA;
01413 }
01414
01415 }
01416 namespace TMVA {
01417
01418 TClass *Ranking::fgIsA = 0;
01419
01420
01421 const char *Ranking::Class_Name()
01422 {
01423 return "TMVA::Ranking";
01424 }
01425
01426
01427 const char *Ranking::ImplFileName()
01428 {
01429 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Ranking*)0x0)->GetImplFileName();
01430 }
01431
01432
01433 int Ranking::ImplFileLine()
01434 {
01435 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Ranking*)0x0)->GetImplFileLine();
01436 }
01437
01438
01439 void Ranking::Dictionary()
01440 {
01441 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Ranking*)0x0)->GetClass();
01442 }
01443
01444
01445 TClass *Ranking::Class()
01446 {
01447 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Ranking*)0x0)->GetClass();
01448 return fgIsA;
01449 }
01450
01451 }
01452 namespace TMVA {
01453
01454 TClass *RuleFit::fgIsA = 0;
01455
01456
01457 const char *RuleFit::Class_Name()
01458 {
01459 return "TMVA::RuleFit";
01460 }
01461
01462
01463 const char *RuleFit::ImplFileName()
01464 {
01465 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::RuleFit*)0x0)->GetImplFileName();
01466 }
01467
01468
01469 int RuleFit::ImplFileLine()
01470 {
01471 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::RuleFit*)0x0)->GetImplFileLine();
01472 }
01473
01474
01475 void RuleFit::Dictionary()
01476 {
01477 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::RuleFit*)0x0)->GetClass();
01478 }
01479
01480
01481 TClass *RuleFit::Class()
01482 {
01483 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::RuleFit*)0x0)->GetClass();
01484 return fgIsA;
01485 }
01486
01487 }
01488 namespace TMVA {
01489
01490 TClass *RuleFitAPI::fgIsA = 0;
01491
01492
01493 const char *RuleFitAPI::Class_Name()
01494 {
01495 return "TMVA::RuleFitAPI";
01496 }
01497
01498
01499 const char *RuleFitAPI::ImplFileName()
01500 {
01501 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::RuleFitAPI*)0x0)->GetImplFileName();
01502 }
01503
01504
01505 int RuleFitAPI::ImplFileLine()
01506 {
01507 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::RuleFitAPI*)0x0)->GetImplFileLine();
01508 }
01509
01510
01511 void RuleFitAPI::Dictionary()
01512 {
01513 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::RuleFitAPI*)0x0)->GetClass();
01514 }
01515
01516
01517 TClass *RuleFitAPI::Class()
01518 {
01519 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::RuleFitAPI*)0x0)->GetClass();
01520 return fgIsA;
01521 }
01522
01523 }
01524 namespace TMVA {
01525
01526 TClass *IMethod::fgIsA = 0;
01527
01528
01529 const char *IMethod::Class_Name()
01530 {
01531 return "TMVA::IMethod";
01532 }
01533
01534
01535 const char *IMethod::ImplFileName()
01536 {
01537 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::IMethod*)0x0)->GetImplFileName();
01538 }
01539
01540
01541 int IMethod::ImplFileLine()
01542 {
01543 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::IMethod*)0x0)->GetImplFileLine();
01544 }
01545
01546
01547 void IMethod::Dictionary()
01548 {
01549 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::IMethod*)0x0)->GetClass();
01550 }
01551
01552
01553 TClass *IMethod::Class()
01554 {
01555 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::IMethod*)0x0)->GetClass();
01556 return fgIsA;
01557 }
01558
01559 }
01560 namespace TMVA {
01561
01562 TClass *VariableTransformBase::fgIsA = 0;
01563
01564
01565 const char *VariableTransformBase::Class_Name()
01566 {
01567 return "TMVA::VariableTransformBase";
01568 }
01569
01570
01571 const char *VariableTransformBase::ImplFileName()
01572 {
01573 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableTransformBase*)0x0)->GetImplFileName();
01574 }
01575
01576
01577 int VariableTransformBase::ImplFileLine()
01578 {
01579 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableTransformBase*)0x0)->GetImplFileLine();
01580 }
01581
01582
01583 void VariableTransformBase::Dictionary()
01584 {
01585 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableTransformBase*)0x0)->GetClass();
01586 }
01587
01588
01589 TClass *VariableTransformBase::Class()
01590 {
01591 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableTransformBase*)0x0)->GetClass();
01592 return fgIsA;
01593 }
01594
01595 }
01596 namespace TMVA {
01597
01598 TClass *VariableIdentityTransform::fgIsA = 0;
01599
01600
01601 const char *VariableIdentityTransform::Class_Name()
01602 {
01603 return "TMVA::VariableIdentityTransform";
01604 }
01605
01606
01607 const char *VariableIdentityTransform::ImplFileName()
01608 {
01609 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableIdentityTransform*)0x0)->GetImplFileName();
01610 }
01611
01612
01613 int VariableIdentityTransform::ImplFileLine()
01614 {
01615 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableIdentityTransform*)0x0)->GetImplFileLine();
01616 }
01617
01618
01619 void VariableIdentityTransform::Dictionary()
01620 {
01621 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableIdentityTransform*)0x0)->GetClass();
01622 }
01623
01624
01625 TClass *VariableIdentityTransform::Class()
01626 {
01627 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableIdentityTransform*)0x0)->GetClass();
01628 return fgIsA;
01629 }
01630
01631 }
01632 namespace TMVA {
01633
01634 TClass *VariableDecorrTransform::fgIsA = 0;
01635
01636
01637 const char *VariableDecorrTransform::Class_Name()
01638 {
01639 return "TMVA::VariableDecorrTransform";
01640 }
01641
01642
01643 const char *VariableDecorrTransform::ImplFileName()
01644 {
01645 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableDecorrTransform*)0x0)->GetImplFileName();
01646 }
01647
01648
01649 int VariableDecorrTransform::ImplFileLine()
01650 {
01651 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableDecorrTransform*)0x0)->GetImplFileLine();
01652 }
01653
01654
01655 void VariableDecorrTransform::Dictionary()
01656 {
01657 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableDecorrTransform*)0x0)->GetClass();
01658 }
01659
01660
01661 TClass *VariableDecorrTransform::Class()
01662 {
01663 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableDecorrTransform*)0x0)->GetClass();
01664 return fgIsA;
01665 }
01666
01667 }
01668 namespace TMVA {
01669
01670 TClass *VariablePCATransform::fgIsA = 0;
01671
01672
01673 const char *VariablePCATransform::Class_Name()
01674 {
01675 return "TMVA::VariablePCATransform";
01676 }
01677
01678
01679 const char *VariablePCATransform::ImplFileName()
01680 {
01681 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariablePCATransform*)0x0)->GetImplFileName();
01682 }
01683
01684
01685 int VariablePCATransform::ImplFileLine()
01686 {
01687 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariablePCATransform*)0x0)->GetImplFileLine();
01688 }
01689
01690
01691 void VariablePCATransform::Dictionary()
01692 {
01693 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariablePCATransform*)0x0)->GetClass();
01694 }
01695
01696
01697 TClass *VariablePCATransform::Class()
01698 {
01699 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariablePCATransform*)0x0)->GetClass();
01700 return fgIsA;
01701 }
01702
01703 }
01704 namespace TMVA {
01705
01706 TClass *VariableGaussTransform::fgIsA = 0;
01707
01708
01709 const char *VariableGaussTransform::Class_Name()
01710 {
01711 return "TMVA::VariableGaussTransform";
01712 }
01713
01714
01715 const char *VariableGaussTransform::ImplFileName()
01716 {
01717 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableGaussTransform*)0x0)->GetImplFileName();
01718 }
01719
01720
01721 int VariableGaussTransform::ImplFileLine()
01722 {
01723 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableGaussTransform*)0x0)->GetImplFileLine();
01724 }
01725
01726
01727 void VariableGaussTransform::Dictionary()
01728 {
01729 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableGaussTransform*)0x0)->GetClass();
01730 }
01731
01732
01733 TClass *VariableGaussTransform::Class()
01734 {
01735 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableGaussTransform*)0x0)->GetClass();
01736 return fgIsA;
01737 }
01738
01739 }
01740 namespace TMVA {
01741
01742 TClass *VariableNormalizeTransform::fgIsA = 0;
01743
01744
01745 const char *VariableNormalizeTransform::Class_Name()
01746 {
01747 return "TMVA::VariableNormalizeTransform";
01748 }
01749
01750
01751 const char *VariableNormalizeTransform::ImplFileName()
01752 {
01753 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableNormalizeTransform*)0x0)->GetImplFileName();
01754 }
01755
01756
01757 int VariableNormalizeTransform::ImplFileLine()
01758 {
01759 return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableNormalizeTransform*)0x0)->GetImplFileLine();
01760 }
01761
01762
01763 void VariableNormalizeTransform::Dictionary()
01764 {
01765 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableNormalizeTransform*)0x0)->GetClass();
01766 }
01767
01768
01769 TClass *VariableNormalizeTransform::Class()
01770 {
01771 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::VariableNormalizeTransform*)0x0)->GetClass();
01772 return fgIsA;
01773 }
01774
01775 }
01776 namespace TMVA {
01777
01778 void TNeuron::Streamer(TBuffer &R__b)
01779 {
01780
01781
01782 if (R__b.IsReading()) {
01783 R__b.ReadClassBuffer(TMVA::TNeuron::Class(),this);
01784 } else {
01785 R__b.WriteClassBuffer(TMVA::TNeuron::Class(),this);
01786 }
01787 }
01788
01789 }
01790
01791 namespace TMVA {
01792 void TNeuron::ShowMembers(TMemberInspector &R__insp)
01793 {
01794
01795 TClass *R__cl = ::TMVA::TNeuron::IsA();
01796 if (R__cl || R__insp.IsA()) { }
01797 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLinksIn", &fLinksIn);
01798 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLinksOut", &fLinksOut);
01799 R__insp.Inspect(R__cl, R__insp.GetParent(), "fValue", &fValue);
01800 R__insp.Inspect(R__cl, R__insp.GetParent(), "fActivationValue", &fActivationValue);
01801 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDelta", &fDelta);
01802 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDEDw", &fDEDw);
01803 R__insp.Inspect(R__cl, R__insp.GetParent(), "fError", &fError);
01804 R__insp.Inspect(R__cl, R__insp.GetParent(), "fForcedValue", &fForcedValue);
01805 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fActivation", &fActivation);
01806 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInputCalculator", &fInputCalculator);
01807 TObject::ShowMembers(R__insp);
01808 }
01809
01810 }
01811 namespace ROOT {
01812
01813 static void *new_TMVAcLcLTNeuron(void *p) {
01814 return p ? new(p) ::TMVA::TNeuron : new ::TMVA::TNeuron;
01815 }
01816 static void *newArray_TMVAcLcLTNeuron(Long_t nElements, void *p) {
01817 return p ? new(p) ::TMVA::TNeuron[nElements] : new ::TMVA::TNeuron[nElements];
01818 }
01819
01820 static void delete_TMVAcLcLTNeuron(void *p) {
01821 delete ((::TMVA::TNeuron*)p);
01822 }
01823 static void deleteArray_TMVAcLcLTNeuron(void *p) {
01824 delete [] ((::TMVA::TNeuron*)p);
01825 }
01826 static void destruct_TMVAcLcLTNeuron(void *p) {
01827 typedef ::TMVA::TNeuron current_t;
01828 ((current_t*)p)->~current_t();
01829 }
01830 }
01831
01832 namespace TMVA {
01833
01834 void TSynapse::Streamer(TBuffer &R__b)
01835 {
01836
01837
01838 if (R__b.IsReading()) {
01839 R__b.ReadClassBuffer(TMVA::TSynapse::Class(),this);
01840 } else {
01841 R__b.WriteClassBuffer(TMVA::TSynapse::Class(),this);
01842 }
01843 }
01844
01845 }
01846
01847 namespace TMVA {
01848 void TSynapse::ShowMembers(TMemberInspector &R__insp)
01849 {
01850
01851 TClass *R__cl = ::TMVA::TSynapse::IsA();
01852 if (R__cl || R__insp.IsA()) { }
01853 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeight", &fWeight);
01854 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLearnRate", &fLearnRate);
01855 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDelta", &fDelta);
01856 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDEDw", &fDEDw);
01857 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCount", &fCount);
01858 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPreNeuron", &fPreNeuron);
01859 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPostNeuron", &fPostNeuron);
01860 TObject::ShowMembers(R__insp);
01861 }
01862
01863 }
01864 namespace ROOT {
01865
01866 static void *new_TMVAcLcLTSynapse(void *p) {
01867 return p ? new(p) ::TMVA::TSynapse : new ::TMVA::TSynapse;
01868 }
01869 static void *newArray_TMVAcLcLTSynapse(Long_t nElements, void *p) {
01870 return p ? new(p) ::TMVA::TSynapse[nElements] : new ::TMVA::TSynapse[nElements];
01871 }
01872
01873 static void delete_TMVAcLcLTSynapse(void *p) {
01874 delete ((::TMVA::TSynapse*)p);
01875 }
01876 static void deleteArray_TMVAcLcLTSynapse(void *p) {
01877 delete [] ((::TMVA::TSynapse*)p);
01878 }
01879 static void destruct_TMVAcLcLTSynapse(void *p) {
01880 typedef ::TMVA::TSynapse current_t;
01881 ((current_t*)p)->~current_t();
01882 }
01883 }
01884
01885 namespace TMVA {
01886
01887 void TActivationChooser::Streamer(TBuffer &R__b)
01888 {
01889
01890
01891 if (R__b.IsReading()) {
01892 R__b.ReadClassBuffer(TMVA::TActivationChooser::Class(),this);
01893 } else {
01894 R__b.WriteClassBuffer(TMVA::TActivationChooser::Class(),this);
01895 }
01896 }
01897
01898 }
01899
01900 namespace TMVA {
01901 void TActivationChooser::ShowMembers(TMemberInspector &R__insp)
01902 {
01903
01904 TClass *R__cl = ::TMVA::TActivationChooser::IsA();
01905 if (R__cl || R__insp.IsA()) { }
01906 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLINEAR", &fLINEAR);
01907 R__insp.InspectMember(fLINEAR, "fLINEAR.");
01908 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSIGMOID", &fSIGMOID);
01909 R__insp.InspectMember(fSIGMOID, "fSIGMOID.");
01910 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTANH", &fTANH);
01911 R__insp.InspectMember(fTANH, "fTANH.");
01912 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRADIAL", &fRADIAL);
01913 R__insp.InspectMember(fRADIAL, "fRADIAL.");
01914 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
01915 }
01916
01917 }
01918 namespace ROOT {
01919
01920 static void *new_TMVAcLcLTActivationChooser(void *p) {
01921 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationChooser : new ::TMVA::TActivationChooser;
01922 }
01923 static void *newArray_TMVAcLcLTActivationChooser(Long_t nElements, void *p) {
01924 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationChooser[nElements] : new ::TMVA::TActivationChooser[nElements];
01925 }
01926
01927 static void delete_TMVAcLcLTActivationChooser(void *p) {
01928 delete ((::TMVA::TActivationChooser*)p);
01929 }
01930 static void deleteArray_TMVAcLcLTActivationChooser(void *p) {
01931 delete [] ((::TMVA::TActivationChooser*)p);
01932 }
01933 static void destruct_TMVAcLcLTActivationChooser(void *p) {
01934 typedef ::TMVA::TActivationChooser current_t;
01935 ((current_t*)p)->~current_t();
01936 }
01937 }
01938
01939 namespace TMVA {
01940
01941 void TActivation::Streamer(TBuffer &R__b)
01942 {
01943
01944
01945 if (R__b.IsReading()) {
01946 R__b.ReadClassBuffer(TMVA::TActivation::Class(),this);
01947 } else {
01948 R__b.WriteClassBuffer(TMVA::TActivation::Class(),this);
01949 }
01950 }
01951
01952 }
01953
01954 namespace TMVA {
01955 void TActivation::ShowMembers(TMemberInspector &R__insp)
01956 {
01957
01958 TClass *R__cl = ::TMVA::TActivation::IsA();
01959 if (R__cl || R__insp.IsA()) { }
01960 }
01961
01962 }
01963 namespace ROOT {
01964
01965 static void delete_TMVAcLcLTActivation(void *p) {
01966 delete ((::TMVA::TActivation*)p);
01967 }
01968 static void deleteArray_TMVAcLcLTActivation(void *p) {
01969 delete [] ((::TMVA::TActivation*)p);
01970 }
01971 static void destruct_TMVAcLcLTActivation(void *p) {
01972 typedef ::TMVA::TActivation current_t;
01973 ((current_t*)p)->~current_t();
01974 }
01975 }
01976
01977 namespace TMVA {
01978
01979 void TActivationSigmoid::Streamer(TBuffer &R__b)
01980 {
01981
01982
01983 if (R__b.IsReading()) {
01984 R__b.ReadClassBuffer(TMVA::TActivationSigmoid::Class(),this);
01985 } else {
01986 R__b.WriteClassBuffer(TMVA::TActivationSigmoid::Class(),this);
01987 }
01988 }
01989
01990 }
01991
01992 namespace TMVA {
01993 void TActivationSigmoid::ShowMembers(TMemberInspector &R__insp)
01994 {
01995
01996 TClass *R__cl = ::TMVA::TActivationSigmoid::IsA();
01997 if (R__cl || R__insp.IsA()) { }
01998 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEqn", &fEqn);
01999 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEqnDerivative", &fEqnDerivative);
02000
02001 typedef TMVA::TActivation baseClass1;
02002 baseClass1::ShowMembers(R__insp);
02003 }
02004
02005 }
02006 namespace ROOT {
02007
02008 static void *new_TMVAcLcLTActivationSigmoid(void *p) {
02009 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationSigmoid : new ::TMVA::TActivationSigmoid;
02010 }
02011 static void *newArray_TMVAcLcLTActivationSigmoid(Long_t nElements, void *p) {
02012 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationSigmoid[nElements] : new ::TMVA::TActivationSigmoid[nElements];
02013 }
02014
02015 static void delete_TMVAcLcLTActivationSigmoid(void *p) {
02016 delete ((::TMVA::TActivationSigmoid*)p);
02017 }
02018 static void deleteArray_TMVAcLcLTActivationSigmoid(void *p) {
02019 delete [] ((::TMVA::TActivationSigmoid*)p);
02020 }
02021 static void destruct_TMVAcLcLTActivationSigmoid(void *p) {
02022 typedef ::TMVA::TActivationSigmoid current_t;
02023 ((current_t*)p)->~current_t();
02024 }
02025 }
02026
02027 namespace TMVA {
02028
02029 void TActivationIdentity::Streamer(TBuffer &R__b)
02030 {
02031
02032
02033 if (R__b.IsReading()) {
02034 R__b.ReadClassBuffer(TMVA::TActivationIdentity::Class(),this);
02035 } else {
02036 R__b.WriteClassBuffer(TMVA::TActivationIdentity::Class(),this);
02037 }
02038 }
02039
02040 }
02041
02042 namespace TMVA {
02043 void TActivationIdentity::ShowMembers(TMemberInspector &R__insp)
02044 {
02045
02046 TClass *R__cl = ::TMVA::TActivationIdentity::IsA();
02047 if (R__cl || R__insp.IsA()) { }
02048
02049 typedef TMVA::TActivation baseClass1;
02050 baseClass1::ShowMembers(R__insp);
02051 }
02052
02053 }
02054 namespace ROOT {
02055
02056 static void *new_TMVAcLcLTActivationIdentity(void *p) {
02057 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationIdentity : new ::TMVA::TActivationIdentity;
02058 }
02059 static void *newArray_TMVAcLcLTActivationIdentity(Long_t nElements, void *p) {
02060 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationIdentity[nElements] : new ::TMVA::TActivationIdentity[nElements];
02061 }
02062
02063 static void delete_TMVAcLcLTActivationIdentity(void *p) {
02064 delete ((::TMVA::TActivationIdentity*)p);
02065 }
02066 static void deleteArray_TMVAcLcLTActivationIdentity(void *p) {
02067 delete [] ((::TMVA::TActivationIdentity*)p);
02068 }
02069 static void destruct_TMVAcLcLTActivationIdentity(void *p) {
02070 typedef ::TMVA::TActivationIdentity current_t;
02071 ((current_t*)p)->~current_t();
02072 }
02073 }
02074
02075 namespace TMVA {
02076
02077 void TActivationTanh::Streamer(TBuffer &R__b)
02078 {
02079
02080
02081 if (R__b.IsReading()) {
02082 R__b.ReadClassBuffer(TMVA::TActivationTanh::Class(),this);
02083 } else {
02084 R__b.WriteClassBuffer(TMVA::TActivationTanh::Class(),this);
02085 }
02086 }
02087
02088 }
02089
02090 namespace TMVA {
02091 void TActivationTanh::ShowMembers(TMemberInspector &R__insp)
02092 {
02093
02094 TClass *R__cl = ::TMVA::TActivationTanh::IsA();
02095 if (R__cl || R__insp.IsA()) { }
02096 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEqn", &fEqn);
02097 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEqnDerivative", &fEqnDerivative);
02098
02099 typedef TMVA::TActivation baseClass1;
02100 baseClass1::ShowMembers(R__insp);
02101 }
02102
02103 }
02104 namespace ROOT {
02105
02106 static void *new_TMVAcLcLTActivationTanh(void *p) {
02107 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationTanh : new ::TMVA::TActivationTanh;
02108 }
02109 static void *newArray_TMVAcLcLTActivationTanh(Long_t nElements, void *p) {
02110 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationTanh[nElements] : new ::TMVA::TActivationTanh[nElements];
02111 }
02112
02113 static void delete_TMVAcLcLTActivationTanh(void *p) {
02114 delete ((::TMVA::TActivationTanh*)p);
02115 }
02116 static void deleteArray_TMVAcLcLTActivationTanh(void *p) {
02117 delete [] ((::TMVA::TActivationTanh*)p);
02118 }
02119 static void destruct_TMVAcLcLTActivationTanh(void *p) {
02120 typedef ::TMVA::TActivationTanh current_t;
02121 ((current_t*)p)->~current_t();
02122 }
02123 }
02124
02125 namespace TMVA {
02126
02127 void TActivationRadial::Streamer(TBuffer &R__b)
02128 {
02129
02130
02131 if (R__b.IsReading()) {
02132 R__b.ReadClassBuffer(TMVA::TActivationRadial::Class(),this);
02133 } else {
02134 R__b.WriteClassBuffer(TMVA::TActivationRadial::Class(),this);
02135 }
02136 }
02137
02138 }
02139
02140 namespace TMVA {
02141 void TActivationRadial::ShowMembers(TMemberInspector &R__insp)
02142 {
02143
02144 TClass *R__cl = ::TMVA::TActivationRadial::IsA();
02145 if (R__cl || R__insp.IsA()) { }
02146 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEqn", &fEqn);
02147 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEqnDerivative", &fEqnDerivative);
02148
02149 typedef TMVA::TActivation baseClass1;
02150 baseClass1::ShowMembers(R__insp);
02151 }
02152
02153 }
02154 namespace ROOT {
02155
02156 static void *new_TMVAcLcLTActivationRadial(void *p) {
02157 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationRadial : new ::TMVA::TActivationRadial;
02158 }
02159 static void *newArray_TMVAcLcLTActivationRadial(Long_t nElements, void *p) {
02160 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationRadial[nElements] : new ::TMVA::TActivationRadial[nElements];
02161 }
02162
02163 static void delete_TMVAcLcLTActivationRadial(void *p) {
02164 delete ((::TMVA::TActivationRadial*)p);
02165 }
02166 static void deleteArray_TMVAcLcLTActivationRadial(void *p) {
02167 delete [] ((::TMVA::TActivationRadial*)p);
02168 }
02169 static void destruct_TMVAcLcLTActivationRadial(void *p) {
02170 typedef ::TMVA::TActivationRadial current_t;
02171 ((current_t*)p)->~current_t();
02172 }
02173 }
02174
02175 namespace TMVA {
02176
02177 void TNeuronInputChooser::Streamer(TBuffer &R__b)
02178 {
02179
02180
02181 if (R__b.IsReading()) {
02182 R__b.ReadClassBuffer(TMVA::TNeuronInputChooser::Class(),this);
02183 } else {
02184 R__b.WriteClassBuffer(TMVA::TNeuronInputChooser::Class(),this);
02185 }
02186 }
02187
02188 }
02189
02190 namespace TMVA {
02191 void TNeuronInputChooser::ShowMembers(TMemberInspector &R__insp)
02192 {
02193
02194 TClass *R__cl = ::TMVA::TNeuronInputChooser::IsA();
02195 if (R__cl || R__insp.IsA()) { }
02196 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSUM", &fSUM);
02197 R__insp.InspectMember(fSUM, "fSUM.");
02198 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSQSUM", &fSQSUM);
02199 R__insp.InspectMember(fSQSUM, "fSQSUM.");
02200 R__insp.Inspect(R__cl, R__insp.GetParent(), "fABSSUM", &fABSSUM);
02201 R__insp.InspectMember(fABSSUM, "fABSSUM.");
02202 }
02203
02204 }
02205 namespace ROOT {
02206
02207 static void *new_TMVAcLcLTNeuronInputChooser(void *p) {
02208 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputChooser : new ::TMVA::TNeuronInputChooser;
02209 }
02210 static void *newArray_TMVAcLcLTNeuronInputChooser(Long_t nElements, void *p) {
02211 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputChooser[nElements] : new ::TMVA::TNeuronInputChooser[nElements];
02212 }
02213
02214 static void delete_TMVAcLcLTNeuronInputChooser(void *p) {
02215 delete ((::TMVA::TNeuronInputChooser*)p);
02216 }
02217 static void deleteArray_TMVAcLcLTNeuronInputChooser(void *p) {
02218 delete [] ((::TMVA::TNeuronInputChooser*)p);
02219 }
02220 static void destruct_TMVAcLcLTNeuronInputChooser(void *p) {
02221 typedef ::TMVA::TNeuronInputChooser current_t;
02222 ((current_t*)p)->~current_t();
02223 }
02224 }
02225
02226 namespace TMVA {
02227
02228 void TNeuronInput::Streamer(TBuffer &R__b)
02229 {
02230
02231
02232 if (R__b.IsReading()) {
02233 R__b.ReadClassBuffer(TMVA::TNeuronInput::Class(),this);
02234 } else {
02235 R__b.WriteClassBuffer(TMVA::TNeuronInput::Class(),this);
02236 }
02237 }
02238
02239 }
02240
02241 namespace TMVA {
02242 void TNeuronInput::ShowMembers(TMemberInspector &R__insp)
02243 {
02244
02245 TClass *R__cl = ::TMVA::TNeuronInput::IsA();
02246 if (R__cl || R__insp.IsA()) { }
02247 }
02248
02249 }
02250 namespace ROOT {
02251
02252 static void delete_TMVAcLcLTNeuronInput(void *p) {
02253 delete ((::TMVA::TNeuronInput*)p);
02254 }
02255 static void deleteArray_TMVAcLcLTNeuronInput(void *p) {
02256 delete [] ((::TMVA::TNeuronInput*)p);
02257 }
02258 static void destruct_TMVAcLcLTNeuronInput(void *p) {
02259 typedef ::TMVA::TNeuronInput current_t;
02260 ((current_t*)p)->~current_t();
02261 }
02262 }
02263
02264 namespace TMVA {
02265
02266 void TNeuronInputSum::Streamer(TBuffer &R__b)
02267 {
02268
02269
02270 if (R__b.IsReading()) {
02271 R__b.ReadClassBuffer(TMVA::TNeuronInputSum::Class(),this);
02272 } else {
02273 R__b.WriteClassBuffer(TMVA::TNeuronInputSum::Class(),this);
02274 }
02275 }
02276
02277 }
02278
02279 namespace TMVA {
02280 void TNeuronInputSum::ShowMembers(TMemberInspector &R__insp)
02281 {
02282
02283 TClass *R__cl = ::TMVA::TNeuronInputSum::IsA();
02284 if (R__cl || R__insp.IsA()) { }
02285
02286 typedef TMVA::TNeuronInput baseClass1;
02287 baseClass1::ShowMembers(R__insp);
02288 }
02289
02290 }
02291 namespace ROOT {
02292
02293 static void *new_TMVAcLcLTNeuronInputSum(void *p) {
02294 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputSum : new ::TMVA::TNeuronInputSum;
02295 }
02296 static void *newArray_TMVAcLcLTNeuronInputSum(Long_t nElements, void *p) {
02297 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputSum[nElements] : new ::TMVA::TNeuronInputSum[nElements];
02298 }
02299
02300 static void delete_TMVAcLcLTNeuronInputSum(void *p) {
02301 delete ((::TMVA::TNeuronInputSum*)p);
02302 }
02303 static void deleteArray_TMVAcLcLTNeuronInputSum(void *p) {
02304 delete [] ((::TMVA::TNeuronInputSum*)p);
02305 }
02306 static void destruct_TMVAcLcLTNeuronInputSum(void *p) {
02307 typedef ::TMVA::TNeuronInputSum current_t;
02308 ((current_t*)p)->~current_t();
02309 }
02310 }
02311
02312 namespace TMVA {
02313
02314 void TNeuronInputSqSum::Streamer(TBuffer &R__b)
02315 {
02316
02317
02318 if (R__b.IsReading()) {
02319 R__b.ReadClassBuffer(TMVA::TNeuronInputSqSum::Class(),this);
02320 } else {
02321 R__b.WriteClassBuffer(TMVA::TNeuronInputSqSum::Class(),this);
02322 }
02323 }
02324
02325 }
02326
02327 namespace TMVA {
02328 void TNeuronInputSqSum::ShowMembers(TMemberInspector &R__insp)
02329 {
02330
02331 TClass *R__cl = ::TMVA::TNeuronInputSqSum::IsA();
02332 if (R__cl || R__insp.IsA()) { }
02333
02334 typedef TMVA::TNeuronInput baseClass1;
02335 baseClass1::ShowMembers(R__insp);
02336 }
02337
02338 }
02339 namespace ROOT {
02340
02341 static void *new_TMVAcLcLTNeuronInputSqSum(void *p) {
02342 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputSqSum : new ::TMVA::TNeuronInputSqSum;
02343 }
02344 static void *newArray_TMVAcLcLTNeuronInputSqSum(Long_t nElements, void *p) {
02345 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputSqSum[nElements] : new ::TMVA::TNeuronInputSqSum[nElements];
02346 }
02347
02348 static void delete_TMVAcLcLTNeuronInputSqSum(void *p) {
02349 delete ((::TMVA::TNeuronInputSqSum*)p);
02350 }
02351 static void deleteArray_TMVAcLcLTNeuronInputSqSum(void *p) {
02352 delete [] ((::TMVA::TNeuronInputSqSum*)p);
02353 }
02354 static void destruct_TMVAcLcLTNeuronInputSqSum(void *p) {
02355 typedef ::TMVA::TNeuronInputSqSum current_t;
02356 ((current_t*)p)->~current_t();
02357 }
02358 }
02359
02360 namespace TMVA {
02361
02362 void TNeuronInputAbs::Streamer(TBuffer &R__b)
02363 {
02364
02365
02366 if (R__b.IsReading()) {
02367 R__b.ReadClassBuffer(TMVA::TNeuronInputAbs::Class(),this);
02368 } else {
02369 R__b.WriteClassBuffer(TMVA::TNeuronInputAbs::Class(),this);
02370 }
02371 }
02372
02373 }
02374
02375 namespace TMVA {
02376 void TNeuronInputAbs::ShowMembers(TMemberInspector &R__insp)
02377 {
02378
02379 TClass *R__cl = ::TMVA::TNeuronInputAbs::IsA();
02380 if (R__cl || R__insp.IsA()) { }
02381
02382 typedef TMVA::TNeuronInput baseClass1;
02383 baseClass1::ShowMembers(R__insp);
02384 }
02385
02386 }
02387 namespace ROOT {
02388
02389 static void *new_TMVAcLcLTNeuronInputAbs(void *p) {
02390 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputAbs : new ::TMVA::TNeuronInputAbs;
02391 }
02392 static void *newArray_TMVAcLcLTNeuronInputAbs(Long_t nElements, void *p) {
02393 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputAbs[nElements] : new ::TMVA::TNeuronInputAbs[nElements];
02394 }
02395
02396 static void delete_TMVAcLcLTNeuronInputAbs(void *p) {
02397 delete ((::TMVA::TNeuronInputAbs*)p);
02398 }
02399 static void deleteArray_TMVAcLcLTNeuronInputAbs(void *p) {
02400 delete [] ((::TMVA::TNeuronInputAbs*)p);
02401 }
02402 static void destruct_TMVAcLcLTNeuronInputAbs(void *p) {
02403 typedef ::TMVA::TNeuronInputAbs current_t;
02404 ((current_t*)p)->~current_t();
02405 }
02406 }
02407
02408
02409 namespace ROOT {
02410 void TMVAcLcLTypes_ShowMembers(void *obj, TMemberInspector &R__insp)
02411 {
02412
02413 typedef ::ROOT::Shadow::TMVA::Types ShadowClass;
02414 ShadowClass *sobj = (ShadowClass*)obj;
02415 if (sobj) { }
02416
02417 TClass *R__cl = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Types*)0x0)->GetClass();
02418 if (R__cl || R__insp.IsA()) { }
02419 R__insp.Inspect(R__cl, R__insp.GetParent(), "fStr2type", (void*)&sobj->fStr2type);
02420 R__insp.InspectMember("map<TString,TMVA::Types::EMVA>", (void*)&sobj->fStr2type, "fStr2type.", false);
02421 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &sobj->fLogger);
02422 }
02423
02424 }
02425
02426 namespace ROOT {
02427
02428 static void delete_TMVAcLcLTypes(void *p) {
02429 delete ((::TMVA::Types*)p);
02430 }
02431 static void deleteArray_TMVAcLcLTypes(void *p) {
02432 delete [] ((::TMVA::Types*)p);
02433 }
02434 static void destruct_TMVAcLcLTypes(void *p) {
02435 typedef ::TMVA::Types current_t;
02436 ((current_t*)p)->~current_t();
02437 }
02438 }
02439
02440 namespace TMVA {
02441
02442 void Ranking::Streamer(TBuffer &R__b)
02443 {
02444
02445
02446 if (R__b.IsReading()) {
02447 R__b.ReadClassBuffer(TMVA::Ranking::Class(),this);
02448 } else {
02449 R__b.WriteClassBuffer(TMVA::Ranking::Class(),this);
02450 }
02451 }
02452
02453 }
02454
02455 namespace TMVA {
02456 void Ranking::ShowMembers(TMemberInspector &R__insp)
02457 {
02458
02459 TClass *R__cl = ::TMVA::Ranking::IsA();
02460 if (R__cl || R__insp.IsA()) { }
02461 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRanking", (void*)&fRanking);
02462 R__insp.InspectMember("vector<TMVA::Rank>", (void*)&fRanking, "fRanking.", false);
02463 R__insp.Inspect(R__cl, R__insp.GetParent(), "fContext", &fContext);
02464 R__insp.InspectMember(fContext, "fContext.");
02465 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRankingDiscriminatorName", &fRankingDiscriminatorName);
02466 R__insp.InspectMember(fRankingDiscriminatorName, "fRankingDiscriminatorName.");
02467 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
02468 }
02469
02470 }
02471 namespace ROOT {
02472
02473 static void *new_TMVAcLcLRanking(void *p) {
02474 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::Ranking : new ::TMVA::Ranking;
02475 }
02476 static void *newArray_TMVAcLcLRanking(Long_t nElements, void *p) {
02477 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::Ranking[nElements] : new ::TMVA::Ranking[nElements];
02478 }
02479
02480 static void delete_TMVAcLcLRanking(void *p) {
02481 delete ((::TMVA::Ranking*)p);
02482 }
02483 static void deleteArray_TMVAcLcLRanking(void *p) {
02484 delete [] ((::TMVA::Ranking*)p);
02485 }
02486 static void destruct_TMVAcLcLRanking(void *p) {
02487 typedef ::TMVA::Ranking current_t;
02488 ((current_t*)p)->~current_t();
02489 }
02490 }
02491
02492 namespace TMVA {
02493
02494 void RuleFit::Streamer(TBuffer &R__b)
02495 {
02496
02497
02498 if (R__b.IsReading()) {
02499 R__b.ReadClassBuffer(TMVA::RuleFit::Class(),this);
02500 } else {
02501 R__b.WriteClassBuffer(TMVA::RuleFit::Class(),this);
02502 }
02503 }
02504
02505 }
02506
02507 namespace TMVA {
02508 void RuleFit::ShowMembers(TMemberInspector &R__insp)
02509 {
02510
02511 TClass *R__cl = ::TMVA::RuleFit::IsA();
02512 if (R__cl || R__insp.IsA()) { }
02513 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrainingEvents", (void*)&fTrainingEvents);
02514 R__insp.InspectMember("vector<TMVA::Event*>", (void*)&fTrainingEvents, "fTrainingEvents.", false);
02515 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrainingEventsRndm", (void*)&fTrainingEventsRndm);
02516 R__insp.InspectMember("vector<TMVA::Event*>", (void*)&fTrainingEventsRndm, "fTrainingEventsRndm.", false);
02517 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventWeights", (void*)&fEventWeights);
02518 R__insp.InspectMember("vector<Double_t>", (void*)&fEventWeights, "fEventWeights.", false);
02519 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTreeSample", &fNTreeSample);
02520 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNEveEffTrain", &fNEveEffTrain);
02521 R__insp.Inspect(R__cl, R__insp.GetParent(), "fForest", (void*)&fForest);
02522 R__insp.InspectMember("vector<const TMVA::DecisionTree*>", (void*)&fForest, "fForest.", false);
02523 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRuleEnsemble", (void*)&fRuleEnsemble);
02524 R__insp.InspectMember("TMVA::RuleEnsemble", (void*)&fRuleEnsemble, "fRuleEnsemble.", false);
02525 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRuleFitParams", (void*)&fRuleFitParams);
02526 R__insp.InspectMember("TMVA::RuleFitParams", (void*)&fRuleFitParams, "fRuleFitParams.", false);
02527 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethodRuleFit", &fMethodRuleFit);
02528 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethodBase", &fMethodBase);
02529 R__insp.Inspect(R__cl, R__insp.GetParent(), "fVisHistsUseImp", &fVisHistsUseImp);
02530 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
02531 }
02532
02533 }
02534 namespace ROOT {
02535
02536 static void *new_TMVAcLcLRuleFit(void *p) {
02537 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::RuleFit : new ::TMVA::RuleFit;
02538 }
02539 static void *newArray_TMVAcLcLRuleFit(Long_t nElements, void *p) {
02540 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::RuleFit[nElements] : new ::TMVA::RuleFit[nElements];
02541 }
02542
02543 static void delete_TMVAcLcLRuleFit(void *p) {
02544 delete ((::TMVA::RuleFit*)p);
02545 }
02546 static void deleteArray_TMVAcLcLRuleFit(void *p) {
02547 delete [] ((::TMVA::RuleFit*)p);
02548 }
02549 static void destruct_TMVAcLcLRuleFit(void *p) {
02550 typedef ::TMVA::RuleFit current_t;
02551 ((current_t*)p)->~current_t();
02552 }
02553 }
02554
02555 namespace TMVA {
02556
02557 void RuleFitAPI::Streamer(TBuffer &R__b)
02558 {
02559
02560
02561 if (R__b.IsReading()) {
02562 R__b.ReadClassBuffer(TMVA::RuleFitAPI::Class(),this);
02563 } else {
02564 R__b.WriteClassBuffer(TMVA::RuleFitAPI::Class(),this);
02565 }
02566 }
02567
02568 }
02569
02570 namespace TMVA {
02571 void RuleFitAPI::ShowMembers(TMemberInspector &R__insp)
02572 {
02573
02574 TClass *R__cl = ::TMVA::RuleFitAPI::IsA();
02575 if (R__cl || R__insp.IsA()) { }
02576 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethodRuleFit", &fMethodRuleFit);
02577 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRuleFit", &fRuleFit);
02578 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFYhat", (void*)&fRFYhat);
02579 R__insp.InspectMember("vector<Float_t>", (void*)&fRFYhat, "fRFYhat.", false);
02580 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFVarImp", (void*)&fRFVarImp);
02581 R__insp.InspectMember("vector<Float_t>", (void*)&fRFVarImp, "fRFVarImp.", false);
02582 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFVarImpInd", (void*)&fRFVarImpInd);
02583 R__insp.InspectMember("vector<Int_t>", (void*)&fRFVarImpInd, "fRFVarImpInd.", false);
02584 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFWorkDir", &fRFWorkDir);
02585 R__insp.InspectMember(fRFWorkDir, "fRFWorkDir.");
02586 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFIntParms", (void*)&fRFIntParms);
02587 R__insp.InspectMember("TMVA::RuleFitAPI::IntParms", (void*)&fRFIntParms, "fRFIntParms.", false);
02588 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFRealParms", (void*)&fRFRealParms);
02589 R__insp.InspectMember("TMVA::RuleFitAPI::RealParms", (void*)&fRFRealParms, "fRFRealParms.", false);
02590 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFLx", (void*)&fRFLx);
02591 R__insp.InspectMember("vector<int>", (void*)&fRFLx, "fRFLx.", false);
02592 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFProgram", &fRFProgram);
02593 R__insp.Inspect(R__cl, R__insp.GetParent(), "fModelType", &fModelType);
02594 R__insp.InspectMember(fModelType, "fModelType.");
02595 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogger", &fLogger);
02596 R__insp.InspectMember(fLogger, "fLogger.");
02597 }
02598
02599 }
02600 namespace ROOT {
02601
02602 static void delete_TMVAcLcLRuleFitAPI(void *p) {
02603 delete ((::TMVA::RuleFitAPI*)p);
02604 }
02605 static void deleteArray_TMVAcLcLRuleFitAPI(void *p) {
02606 delete [] ((::TMVA::RuleFitAPI*)p);
02607 }
02608 static void destruct_TMVAcLcLRuleFitAPI(void *p) {
02609 typedef ::TMVA::RuleFitAPI current_t;
02610 ((current_t*)p)->~current_t();
02611 }
02612 }
02613
02614 namespace TMVA {
02615
02616 void IMethod::Streamer(TBuffer &R__b)
02617 {
02618
02619
02620 if (R__b.IsReading()) {
02621 R__b.ReadClassBuffer(TMVA::IMethod::Class(),this);
02622 } else {
02623 R__b.WriteClassBuffer(TMVA::IMethod::Class(),this);
02624 }
02625 }
02626
02627 }
02628
02629 namespace TMVA {
02630 void IMethod::ShowMembers(TMemberInspector &R__insp)
02631 {
02632
02633 TClass *R__cl = ::TMVA::IMethod::IsA();
02634 if (R__cl || R__insp.IsA()) { }
02635 }
02636
02637 }
02638 namespace ROOT {
02639
02640 static void delete_TMVAcLcLIMethod(void *p) {
02641 delete ((::TMVA::IMethod*)p);
02642 }
02643 static void deleteArray_TMVAcLcLIMethod(void *p) {
02644 delete [] ((::TMVA::IMethod*)p);
02645 }
02646 static void destruct_TMVAcLcLIMethod(void *p) {
02647 typedef ::TMVA::IMethod current_t;
02648 ((current_t*)p)->~current_t();
02649 }
02650 }
02651
02652 namespace TMVA {
02653
02654 void MsgLogger::Streamer(TBuffer &R__b)
02655 {
02656
02657
02658 if (R__b.IsReading()) {
02659 R__b.ReadClassBuffer(TMVA::MsgLogger::Class(),this);
02660 } else {
02661 R__b.WriteClassBuffer(TMVA::MsgLogger::Class(),this);
02662 }
02663 }
02664
02665 }
02666
02667 namespace TMVA {
02668 void MsgLogger::ShowMembers(TMemberInspector &R__insp)
02669 {
02670
02671 TClass *R__cl = ::TMVA::MsgLogger::IsA();
02672 if (R__cl || R__insp.IsA()) { }
02673 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObjSource", &fObjSource);
02674 R__insp.Inspect(R__cl, R__insp.GetParent(), "fStrSource", (void*)&fStrSource);
02675 R__insp.InspectMember("string", (void*)&fStrSource, "fStrSource.", false);
02676 R__insp.Inspect(R__cl, R__insp.GetParent(), "fActiveType", &fActiveType);
02677 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinType", &fMinType);
02678 R__insp.GenericShowMembers("basic_ostringstream<char,char_traits<char>,allocator<char> >", ( ::basic_ostringstream<char,char_traits<char>,allocator<char> > *) (this ), false);
02679 TObject::ShowMembers(R__insp);
02680 }
02681
02682 }
02683 namespace ROOT {
02684
02685 static void *new_TMVAcLcLMsgLogger(void *p) {
02686 return p ? new(p) ::TMVA::MsgLogger : new ::TMVA::MsgLogger;
02687 }
02688 static void *newArray_TMVAcLcLMsgLogger(Long_t nElements, void *p) {
02689 return p ? new(p) ::TMVA::MsgLogger[nElements] : new ::TMVA::MsgLogger[nElements];
02690 }
02691
02692 static void delete_TMVAcLcLMsgLogger(void *p) {
02693 delete ((::TMVA::MsgLogger*)p);
02694 }
02695 static void deleteArray_TMVAcLcLMsgLogger(void *p) {
02696 delete [] ((::TMVA::MsgLogger*)p);
02697 }
02698 static void destruct_TMVAcLcLMsgLogger(void *p) {
02699 typedef ::TMVA::MsgLogger current_t;
02700 ((current_t*)p)->~current_t();
02701 }
02702 }
02703
02704 namespace TMVA {
02705
02706 void VariableTransformBase::Streamer(TBuffer &R__b)
02707 {
02708
02709
02710 if (R__b.IsReading()) {
02711 R__b.ReadClassBuffer(TMVA::VariableTransformBase::Class(),this);
02712 } else {
02713 R__b.WriteClassBuffer(TMVA::VariableTransformBase::Class(),this);
02714 }
02715 }
02716
02717 }
02718
02719 namespace TMVA {
02720 void VariableTransformBase::ShowMembers(TMemberInspector &R__insp)
02721 {
02722
02723 TClass *R__cl = ::TMVA::VariableTransformBase::IsA();
02724 if (R__cl || R__insp.IsA()) { }
02725 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransformedEvent", &fTransformedEvent);
02726 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBackTransformedEvent", &fBackTransformedEvent);
02727 R__insp.Inspect(R__cl, R__insp.GetParent(), "fVariableTransform", &fVariableTransform);
02728 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseSignalTransform", &fUseSignalTransform);
02729 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnabled", &fEnabled);
02730 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCreated", &fCreated);
02731 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormalise", &fNormalise);
02732 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNVars", &fNVars);
02733 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTransformName", &fTransformName);
02734 R__insp.InspectMember(fTransformName, "fTransformName.");
02735 R__insp.Inspect(R__cl, R__insp.GetParent(), "fVariables", (void*)&fVariables);
02736 R__insp.InspectMember("vector<TMVA::VariableInfo>", (void*)&fVariables, "fVariables.", false);
02737 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTargets", (void*)&fTargets);
02738 R__insp.InspectMember("vector<TMVA::VariableInfo>", (void*)&fTargets, "fTargets.", false);
02739 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTMVAVersion", &fTMVAVersion);
02740 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
02741 TObject::ShowMembers(R__insp);
02742 }
02743
02744 }
02745 namespace ROOT {
02746
02747 static void delete_TMVAcLcLVariableTransformBase(void *p) {
02748 delete ((::TMVA::VariableTransformBase*)p);
02749 }
02750 static void deleteArray_TMVAcLcLVariableTransformBase(void *p) {
02751 delete [] ((::TMVA::VariableTransformBase*)p);
02752 }
02753 static void destruct_TMVAcLcLVariableTransformBase(void *p) {
02754 typedef ::TMVA::VariableTransformBase current_t;
02755 ((current_t*)p)->~current_t();
02756 }
02757 }
02758
02759 namespace TMVA {
02760
02761 void VariableIdentityTransform::Streamer(TBuffer &R__b)
02762 {
02763
02764
02765 if (R__b.IsReading()) {
02766 R__b.ReadClassBuffer(TMVA::VariableIdentityTransform::Class(),this);
02767 } else {
02768 R__b.WriteClassBuffer(TMVA::VariableIdentityTransform::Class(),this);
02769 }
02770 }
02771
02772 }
02773
02774 namespace TMVA {
02775 void VariableIdentityTransform::ShowMembers(TMemberInspector &R__insp)
02776 {
02777
02778 TClass *R__cl = ::TMVA::VariableIdentityTransform::IsA();
02779 if (R__cl || R__insp.IsA()) { }
02780
02781 typedef TMVA::VariableTransformBase baseClass1;
02782 baseClass1::ShowMembers(R__insp);
02783 }
02784
02785 }
02786 namespace ROOT {
02787
02788 static void delete_TMVAcLcLVariableIdentityTransform(void *p) {
02789 delete ((::TMVA::VariableIdentityTransform*)p);
02790 }
02791 static void deleteArray_TMVAcLcLVariableIdentityTransform(void *p) {
02792 delete [] ((::TMVA::VariableIdentityTransform*)p);
02793 }
02794 static void destruct_TMVAcLcLVariableIdentityTransform(void *p) {
02795 typedef ::TMVA::VariableIdentityTransform current_t;
02796 ((current_t*)p)->~current_t();
02797 }
02798 }
02799
02800 namespace TMVA {
02801
02802 void VariableDecorrTransform::Streamer(TBuffer &R__b)
02803 {
02804
02805
02806 if (R__b.IsReading()) {
02807 R__b.ReadClassBuffer(TMVA::VariableDecorrTransform::Class(),this);
02808 } else {
02809 R__b.WriteClassBuffer(TMVA::VariableDecorrTransform::Class(),this);
02810 }
02811 }
02812
02813 }
02814
02815 namespace TMVA {
02816 void VariableDecorrTransform::ShowMembers(TMemberInspector &R__insp)
02817 {
02818
02819 TClass *R__cl = ::TMVA::VariableDecorrTransform::IsA();
02820 if (R__cl || R__insp.IsA()) { }
02821 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDecorrMatrices", (void*)&fDecorrMatrices);
02822 R__insp.InspectMember("vector<TMatrixD*>", (void*)&fDecorrMatrices, "fDecorrMatrices.", true);
02823
02824 typedef TMVA::VariableTransformBase baseClass1;
02825 baseClass1::ShowMembers(R__insp);
02826 }
02827
02828 }
02829 namespace ROOT {
02830
02831 static void delete_TMVAcLcLVariableDecorrTransform(void *p) {
02832 delete ((::TMVA::VariableDecorrTransform*)p);
02833 }
02834 static void deleteArray_TMVAcLcLVariableDecorrTransform(void *p) {
02835 delete [] ((::TMVA::VariableDecorrTransform*)p);
02836 }
02837 static void destruct_TMVAcLcLVariableDecorrTransform(void *p) {
02838 typedef ::TMVA::VariableDecorrTransform current_t;
02839 ((current_t*)p)->~current_t();
02840 }
02841 }
02842
02843 namespace TMVA {
02844
02845 void VariablePCATransform::Streamer(TBuffer &R__b)
02846 {
02847
02848
02849 if (R__b.IsReading()) {
02850 R__b.ReadClassBuffer(TMVA::VariablePCATransform::Class(),this);
02851 } else {
02852 R__b.WriteClassBuffer(TMVA::VariablePCATransform::Class(),this);
02853 }
02854 }
02855
02856 }
02857
02858 namespace TMVA {
02859 void VariablePCATransform::ShowMembers(TMemberInspector &R__insp)
02860 {
02861
02862 TClass *R__cl = ::TMVA::VariablePCATransform::IsA();
02863 if (R__cl || R__insp.IsA()) { }
02864 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeanValues", (void*)&fMeanValues);
02865 R__insp.InspectMember("vector<TVectorD*>", (void*)&fMeanValues, "fMeanValues.", false);
02866 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEigenVectors", (void*)&fEigenVectors);
02867 R__insp.InspectMember("vector<TMatrixD*>", (void*)&fEigenVectors, "fEigenVectors.", false);
02868
02869 typedef TMVA::VariableTransformBase baseClass1;
02870 baseClass1::ShowMembers(R__insp);
02871 }
02872
02873 }
02874 namespace ROOT {
02875
02876 static void delete_TMVAcLcLVariablePCATransform(void *p) {
02877 delete ((::TMVA::VariablePCATransform*)p);
02878 }
02879 static void deleteArray_TMVAcLcLVariablePCATransform(void *p) {
02880 delete [] ((::TMVA::VariablePCATransform*)p);
02881 }
02882 static void destruct_TMVAcLcLVariablePCATransform(void *p) {
02883 typedef ::TMVA::VariablePCATransform current_t;
02884 ((current_t*)p)->~current_t();
02885 }
02886 }
02887
02888 namespace TMVA {
02889
02890 void VariableGaussTransform::Streamer(TBuffer &R__b)
02891 {
02892
02893
02894 if (R__b.IsReading()) {
02895 R__b.ReadClassBuffer(TMVA::VariableGaussTransform::Class(),this);
02896 } else {
02897 R__b.WriteClassBuffer(TMVA::VariableGaussTransform::Class(),this);
02898 }
02899 }
02900
02901 }
02902
02903 namespace TMVA {
02904 void VariableGaussTransform::ShowMembers(TMemberInspector &R__insp)
02905 {
02906
02907 TClass *R__cl = ::TMVA::VariableGaussTransform::IsA();
02908 if (R__cl || R__insp.IsA()) { }
02909 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFlatNotGauss", &fFlatNotGauss);
02910 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPdfMinSmooth", &fPdfMinSmooth);
02911 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPdfMaxSmooth", &fPdfMaxSmooth);
02912 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCumulativeDist", (void*)&fCumulativeDist);
02913 R__insp.InspectMember("vector<std::vector<TH1F*> >", (void*)&fCumulativeDist, "fCumulativeDist.", true);
02914 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCumulativePDF", (void*)&fCumulativePDF);
02915 R__insp.InspectMember("vector<std::vector<PDF*> >", (void*)&fCumulativePDF, "fCumulativePDF.", false);
02916 R__insp.Inspect(R__cl, R__insp.GetParent(), "fElementsperbin", &fElementsperbin);
02917
02918 typedef TMVA::VariableTransformBase baseClass1;
02919 baseClass1::ShowMembers(R__insp);
02920 }
02921
02922 }
02923 namespace ROOT {
02924
02925 static void delete_TMVAcLcLVariableGaussTransform(void *p) {
02926 delete ((::TMVA::VariableGaussTransform*)p);
02927 }
02928 static void deleteArray_TMVAcLcLVariableGaussTransform(void *p) {
02929 delete [] ((::TMVA::VariableGaussTransform*)p);
02930 }
02931 static void destruct_TMVAcLcLVariableGaussTransform(void *p) {
02932 typedef ::TMVA::VariableGaussTransform current_t;
02933 ((current_t*)p)->~current_t();
02934 }
02935 }
02936
02937 namespace TMVA {
02938
02939 void VariableNormalizeTransform::Streamer(TBuffer &R__b)
02940 {
02941
02942
02943 if (R__b.IsReading()) {
02944 R__b.ReadClassBuffer(TMVA::VariableNormalizeTransform::Class(),this);
02945 } else {
02946 R__b.WriteClassBuffer(TMVA::VariableNormalizeTransform::Class(),this);
02947 }
02948 }
02949
02950 }
02951
02952 namespace TMVA {
02953 void VariableNormalizeTransform::ShowMembers(TMemberInspector &R__insp)
02954 {
02955
02956 TClass *R__cl = ::TMVA::VariableNormalizeTransform::IsA();
02957 if (R__cl || R__insp.IsA()) { }
02958 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMin", (void*)&fMin);
02959 R__insp.InspectMember("vector<std::vector<Float_t> >", (void*)&fMin, "fMin.", true);
02960 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMax", (void*)&fMax);
02961 R__insp.InspectMember("vector<std::vector<Float_t> >", (void*)&fMax, "fMax.", true);
02962
02963 typedef TMVA::VariableTransformBase baseClass1;
02964 baseClass1::ShowMembers(R__insp);
02965 }
02966
02967 }
02968 namespace ROOT {
02969
02970 static void delete_TMVAcLcLVariableNormalizeTransform(void *p) {
02971 delete ((::TMVA::VariableNormalizeTransform*)p);
02972 }
02973 static void deleteArray_TMVAcLcLVariableNormalizeTransform(void *p) {
02974 delete [] ((::TMVA::VariableNormalizeTransform*)p);
02975 }
02976 static void destruct_TMVAcLcLVariableNormalizeTransform(void *p) {
02977 typedef ::TMVA::VariableNormalizeTransform current_t;
02978 ((current_t*)p)->~current_t();
02979 }
02980 }
02981
02982 namespace ROOT {
02983 void maplETStringcOTMVAcLcLTypescLcLEMVAgR_ShowMembers(void *obj, TMemberInspector &R__insp);
02984 static void maplETStringcOTMVAcLcLTypescLcLEMVAgR_Dictionary();
02985 static void *new_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p = 0);
02986 static void *newArray_maplETStringcOTMVAcLcLTypescLcLEMVAgR(Long_t size, void *p);
02987 static void delete_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p);
02988 static void deleteArray_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p);
02989 static void destruct_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p);
02990
02991
02992 static TGenericClassInfo *GenerateInitInstanceLocal(const map<TString,TMVA::Types::EMVA>*)
02993 {
02994 map<TString,TMVA::Types::EMVA> *ptr = 0;
02995 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<TString,TMVA::Types::EMVA>),0);
02996 static ::ROOT::TGenericClassInfo
02997 instance("map<TString,TMVA::Types::EMVA>", -2, "prec_stl/map", 63,
02998 typeid(map<TString,TMVA::Types::EMVA>), DefineBehavior(ptr, ptr),
02999 0, &maplETStringcOTMVAcLcLTypescLcLEMVAgR_Dictionary, isa_proxy, 0,
03000 sizeof(map<TString,TMVA::Types::EMVA>) );
03001 instance.SetNew(&new_maplETStringcOTMVAcLcLTypescLcLEMVAgR);
03002 instance.SetNewArray(&newArray_maplETStringcOTMVAcLcLTypescLcLEMVAgR);
03003 instance.SetDelete(&delete_maplETStringcOTMVAcLcLTypescLcLEMVAgR);
03004 instance.SetDeleteArray(&deleteArray_maplETStringcOTMVAcLcLTypescLcLEMVAgR);
03005 instance.SetDestructor(&destruct_maplETStringcOTMVAcLcLTypescLcLEMVAgR);
03006 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<TString,TMVA::Types::EMVA> >()));
03007 return &instance;
03008 }
03009
03010 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<TString,TMVA::Types::EMVA>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
03011
03012
03013 static void maplETStringcOTMVAcLcLTypescLcLEMVAgR_Dictionary() {
03014 ::ROOT::GenerateInitInstanceLocal((const map<TString,TMVA::Types::EMVA>*)0x0)->GetClass();
03015 }
03016
03017 }
03018
03019 namespace ROOT {
03020
03021 static void *new_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p) {
03022 return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<TString,TMVA::Types::EMVA> : new map<TString,TMVA::Types::EMVA>;
03023 }
03024 static void *newArray_maplETStringcOTMVAcLcLTypescLcLEMVAgR(Long_t nElements, void *p) {
03025 return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<TString,TMVA::Types::EMVA>[nElements] : new map<TString,TMVA::Types::EMVA>[nElements];
03026 }
03027
03028 static void delete_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p) {
03029 delete ((map<TString,TMVA::Types::EMVA>*)p);
03030 }
03031 static void deleteArray_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p) {
03032 delete [] ((map<TString,TMVA::Types::EMVA>*)p);
03033 }
03034 static void destruct_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p) {
03035 typedef map<TString,TMVA::Types::EMVA> current_t;
03036 ((current_t*)p)->~current_t();
03037 }
03038 }
03039
03040
03041
03042
03043
03044
03045
03046
03047 #ifdef G__MEMTEST
03048 #undef malloc
03049 #undef free
03050 #endif
03051
03052 #if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
03053 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
03054 #endif
03055
03056 extern "C" void G__cpp_reset_tagtableG__TMVA4();
03057
03058 extern "C" void G__set_cpp_environmentG__TMVA4() {
03059 G__add_compiledheader("TObject.h");
03060 G__add_compiledheader("TMemberInspector.h");
03061 G__add_compiledheader("include/TMVA/TNeuron.h");
03062 G__add_compiledheader("include/TMVA/TSynapse.h");
03063 G__add_compiledheader("include/TMVA/TActivationChooser.h");
03064 G__add_compiledheader("include/TMVA/TActivation.h");
03065 G__add_compiledheader("include/TMVA/TActivationSigmoid.h");
03066 G__add_compiledheader("include/TMVA/TActivationIdentity.h");
03067 G__add_compiledheader("include/TMVA/TActivationTanh.h");
03068 G__add_compiledheader("include/TMVA/TActivationRadial.h");
03069 G__add_compiledheader("include/TMVA/TNeuronInputChooser.h");
03070 G__add_compiledheader("include/TMVA/TNeuronInput.h");
03071 G__add_compiledheader("include/TMVA/TNeuronInputSum.h");
03072 G__add_compiledheader("include/TMVA/TNeuronInputSqSum.h");
03073 G__add_compiledheader("include/TMVA/TNeuronInputAbs.h");
03074 G__add_compiledheader("include/TMVA/Types.h");
03075 G__add_compiledheader("include/TMVA/Ranking.h");
03076 G__add_compiledheader("include/TMVA/RuleFit.h");
03077 G__add_compiledheader("include/TMVA/RuleFitAPI.h");
03078 G__add_compiledheader("include/TMVA/IMethod.h");
03079 G__add_compiledheader("include/TMVA/MsgLogger.h");
03080 G__add_compiledheader("include/TMVA/VariableTransformBase.h");
03081 G__add_compiledheader("include/TMVA/VariableIdentityTransform.h");
03082 G__add_compiledheader("include/TMVA/VariableDecorrTransform.h");
03083 G__add_compiledheader("include/TMVA/VariablePCATransform.h");
03084 G__add_compiledheader("include/TMVA/VariableGaussTransform.h");
03085 G__add_compiledheader("include/TMVA/VariableNormalizeTransform.h");
03086 G__cpp_reset_tagtableG__TMVA4();
03087 }
03088 #include <new>
03089 extern "C" int G__cpp_dllrevG__TMVA4() { return(30051515); }
03090
03091
03092
03093
03094
03095
03096 static int G__G__TMVA4_125_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03097 {
03098 {
03099 const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, *(TMVA::Node*) libp->para[1].ref);
03100 result7->ref = (long) (&obj);
03101 result7->obj.i = (long) (&obj);
03102 }
03103 return(1 || funcname || hash || result7 || libp) ;
03104 }
03105
03106 static int G__G__TMVA4_125_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03107 {
03108 {
03109 const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, (TMVA::Node*) G__int(libp->para[1]));
03110 result7->ref = (long) (&obj);
03111 result7->obj.i = (long) (&obj);
03112 }
03113 return(1 || funcname || hash || result7 || libp) ;
03114 }
03115
03116 static int G__G__TMVA4_125_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03117 {
03118 {
03119 const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, *(TMVA::BinaryTree*) libp->para[1].ref);
03120 result7->ref = (long) (&obj);
03121 result7->obj.i = (long) (&obj);
03122 }
03123 return(1 || funcname || hash || result7 || libp) ;
03124 }
03125
03126 static int G__G__TMVA4_125_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03127 {
03128 {
03129 const istream& obj = TMVA::operator>>(*(istream*) libp->para[0].ref, *(TMVA::BinaryTree*) libp->para[1].ref);
03130 result7->ref = (long) (&obj);
03131 result7->obj.i = (long) (&obj);
03132 }
03133 return(1 || funcname || hash || result7 || libp) ;
03134 }
03135
03136 static int G__G__TMVA4_125_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03137 {
03138 {
03139 const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, *(TMVA::Event*) libp->para[1].ref);
03140 result7->ref = (long) (&obj);
03141 result7->obj.i = (long) (&obj);
03142 }
03143 return(1 || funcname || hash || result7 || libp) ;
03144 }
03145
03146 static int G__G__TMVA4_125_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03147 {
03148 {
03149 const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, *(TMVA::Rule*) libp->para[1].ref);
03150 result7->ref = (long) (&obj);
03151 result7->obj.i = (long) (&obj);
03152 }
03153 return(1 || funcname || hash || result7 || libp) ;
03154 }
03155
03156 static int G__G__TMVA4_125_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03157 {
03158 {
03159 const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, *(TMVA::RuleEnsemble*) libp->para[1].ref);
03160 result7->ref = (long) (&obj);
03161 result7->obj.i = (long) (&obj);
03162 }
03163 return(1 || funcname || hash || result7 || libp) ;
03164 }
03165
03166 static int G__G__TMVA4_125_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03167 {
03168 {
03169 const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, *(TMVA::PDF*) libp->para[1].ref);
03170 result7->ref = (long) (&obj);
03171 result7->obj.i = (long) (&obj);
03172 }
03173 return(1 || funcname || hash || result7 || libp) ;
03174 }
03175
03176 static int G__G__TMVA4_125_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03177 {
03178 {
03179 const istream& obj = TMVA::operator>>(*(istream*) libp->para[0].ref, *(TMVA::PDF*) libp->para[1].ref);
03180 result7->ref = (long) (&obj);
03181 result7->obj.i = (long) (&obj);
03182 }
03183 return(1 || funcname || hash || result7 || libp) ;
03184 }
03185
03186
03187
03188 static int G__G__TMVA4_126_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03189 {
03190 TMVA::TNeuron* p = NULL;
03191 char* gvp = (char*) G__getgvp();
03192 int n = G__getaryconstruct();
03193 if (n) {
03194 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03195 p = new TMVA::TNeuron[n];
03196 } else {
03197 p = new((void*) gvp) TMVA::TNeuron[n];
03198 }
03199 } else {
03200 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03201 p = new TMVA::TNeuron;
03202 } else {
03203 p = new((void*) gvp) TMVA::TNeuron;
03204 }
03205 }
03206 result7->obj.i = (long) p;
03207 result7->ref = (long) p;
03208 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron));
03209 return(1 || funcname || hash || result7 || libp) ;
03210 }
03211
03212 static int G__G__TMVA4_126_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03213 {
03214 ((TMVA::TNeuron*) G__getstructoffset())->ForceValue((Double_t) G__double(libp->para[0]));
03215 G__setnull(result7);
03216 return(1 || funcname || hash || result7 || libp) ;
03217 }
03218
03219 static int G__G__TMVA4_126_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03220 {
03221 ((TMVA::TNeuron*) G__getstructoffset())->CalculateValue();
03222 G__setnull(result7);
03223 return(1 || funcname || hash || result7 || libp) ;
03224 }
03225
03226 static int G__G__TMVA4_126_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03227 {
03228 ((TMVA::TNeuron*) G__getstructoffset())->CalculateActivationValue();
03229 G__setnull(result7);
03230 return(1 || funcname || hash || result7 || libp) ;
03231 }
03232
03233 static int G__G__TMVA4_126_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03234 {
03235 ((TMVA::TNeuron*) G__getstructoffset())->CalculateDelta();
03236 G__setnull(result7);
03237 return(1 || funcname || hash || result7 || libp) ;
03238 }
03239
03240 static int G__G__TMVA4_126_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03241 {
03242 ((TMVA::TNeuron*) G__getstructoffset())->SetActivationEqn((TMVA::TActivation*) G__int(libp->para[0]));
03243 G__setnull(result7);
03244 return(1 || funcname || hash || result7 || libp) ;
03245 }
03246
03247 static int G__G__TMVA4_126_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03248 {
03249 ((TMVA::TNeuron*) G__getstructoffset())->SetInputCalculator((TMVA::TNeuronInput*) G__int(libp->para[0]));
03250 G__setnull(result7);
03251 return(1 || funcname || hash || result7 || libp) ;
03252 }
03253
03254 static int G__G__TMVA4_126_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03255 {
03256 ((TMVA::TNeuron*) G__getstructoffset())->AddPreLink((TMVA::TSynapse*) G__int(libp->para[0]));
03257 G__setnull(result7);
03258 return(1 || funcname || hash || result7 || libp) ;
03259 }
03260
03261 static int G__G__TMVA4_126_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03262 {
03263 ((TMVA::TNeuron*) G__getstructoffset())->AddPostLink((TMVA::TSynapse*) G__int(libp->para[0]));
03264 G__setnull(result7);
03265 return(1 || funcname || hash || result7 || libp) ;
03266 }
03267
03268 static int G__G__TMVA4_126_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03269 {
03270 ((TMVA::TNeuron*) G__getstructoffset())->DeletePreLinks();
03271 G__setnull(result7);
03272 return(1 || funcname || hash || result7 || libp) ;
03273 }
03274
03275 static int G__G__TMVA4_126_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03276 {
03277 ((TMVA::TNeuron*) G__getstructoffset())->SetError((Double_t) G__double(libp->para[0]));
03278 G__setnull(result7);
03279 return(1 || funcname || hash || result7 || libp) ;
03280 }
03281
03282 static int G__G__TMVA4_126_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03283 {
03284 ((TMVA::TNeuron*) G__getstructoffset())->UpdateSynapsesBatch();
03285 G__setnull(result7);
03286 return(1 || funcname || hash || result7 || libp) ;
03287 }
03288
03289 static int G__G__TMVA4_126_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03290 {
03291 ((TMVA::TNeuron*) G__getstructoffset())->UpdateSynapsesSequential();
03292 G__setnull(result7);
03293 return(1 || funcname || hash || result7 || libp) ;
03294 }
03295
03296 static int G__G__TMVA4_126_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03297 {
03298 ((TMVA::TNeuron*) G__getstructoffset())->AdjustSynapseWeights();
03299 G__setnull(result7);
03300 return(1 || funcname || hash || result7 || libp) ;
03301 }
03302
03303 static int G__G__TMVA4_126_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03304 {
03305 ((TMVA::TNeuron*) G__getstructoffset())->InitSynapseDeltas();
03306 G__setnull(result7);
03307 return(1 || funcname || hash || result7 || libp) ;
03308 }
03309
03310 static int G__G__TMVA4_126_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03311 {
03312 ((TMVA::TNeuron*) G__getstructoffset())->PrintActivationEqn();
03313 G__setnull(result7);
03314 return(1 || funcname || hash || result7 || libp) ;
03315 }
03316
03317 static int G__G__TMVA4_126_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03318 {
03319 G__letdouble(result7, 100, (double) ((const TMVA::TNeuron*) G__getstructoffset())->GetValue());
03320 return(1 || funcname || hash || result7 || libp) ;
03321 }
03322
03323 static int G__G__TMVA4_126_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03324 {
03325 G__letdouble(result7, 100, (double) ((const TMVA::TNeuron*) G__getstructoffset())->GetActivationValue());
03326 return(1 || funcname || hash || result7 || libp) ;
03327 }
03328
03329 static int G__G__TMVA4_126_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03330 {
03331 G__letdouble(result7, 100, (double) ((const TMVA::TNeuron*) G__getstructoffset())->GetDelta());
03332 return(1 || funcname || hash || result7 || libp) ;
03333 }
03334
03335 static int G__G__TMVA4_126_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03336 {
03337 G__letdouble(result7, 100, (double) ((const TMVA::TNeuron*) G__getstructoffset())->GetDEDw());
03338 return(1 || funcname || hash || result7 || libp) ;
03339 }
03340
03341 static int G__G__TMVA4_126_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03342 {
03343 G__letint(result7, 105, (long) ((const TMVA::TNeuron*) G__getstructoffset())->NumPreLinks());
03344 return(1 || funcname || hash || result7 || libp) ;
03345 }
03346
03347 static int G__G__TMVA4_126_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03348 {
03349 G__letint(result7, 105, (long) ((const TMVA::TNeuron*) G__getstructoffset())->NumPostLinks());
03350 return(1 || funcname || hash || result7 || libp) ;
03351 }
03352
03353 static int G__G__TMVA4_126_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03354 {
03355 G__letint(result7, 85, (long) ((const TMVA::TNeuron*) G__getstructoffset())->PreLinkAt((Int_t) G__int(libp->para[0])));
03356 return(1 || funcname || hash || result7 || libp) ;
03357 }
03358
03359 static int G__G__TMVA4_126_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03360 {
03361 G__letint(result7, 85, (long) ((const TMVA::TNeuron*) G__getstructoffset())->PostLinkAt((Int_t) G__int(libp->para[0])));
03362 return(1 || funcname || hash || result7 || libp) ;
03363 }
03364
03365 static int G__G__TMVA4_126_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03366 {
03367 ((TMVA::TNeuron*) G__getstructoffset())->SetInputNeuron();
03368 G__setnull(result7);
03369 return(1 || funcname || hash || result7 || libp) ;
03370 }
03371
03372 static int G__G__TMVA4_126_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03373 {
03374 ((TMVA::TNeuron*) G__getstructoffset())->SetOutputNeuron();
03375 G__setnull(result7);
03376 return(1 || funcname || hash || result7 || libp) ;
03377 }
03378
03379 static int G__G__TMVA4_126_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03380 {
03381 ((TMVA::TNeuron*) G__getstructoffset())->SetBiasNeuron();
03382 G__setnull(result7);
03383 return(1 || funcname || hash || result7 || libp) ;
03384 }
03385
03386 static int G__G__TMVA4_126_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03387 {
03388 ((TMVA::TNeuron*) G__getstructoffset())->SetDEDw((Double_t) G__double(libp->para[0]));
03389 G__setnull(result7);
03390 return(1 || funcname || hash || result7 || libp) ;
03391 }
03392
03393 static int G__G__TMVA4_126_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03394 {
03395 G__letint(result7, 103, (long) ((const TMVA::TNeuron*) G__getstructoffset())->IsInputNeuron());
03396 return(1 || funcname || hash || result7 || libp) ;
03397 }
03398
03399 static int G__G__TMVA4_126_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03400 {
03401 G__letint(result7, 103, (long) ((const TMVA::TNeuron*) G__getstructoffset())->IsOutputNeuron());
03402 return(1 || funcname || hash || result7 || libp) ;
03403 }
03404
03405 static int G__G__TMVA4_126_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03406 {
03407 ((const TMVA::TNeuron*) G__getstructoffset())->PrintPreLinks();
03408 G__setnull(result7);
03409 return(1 || funcname || hash || result7 || libp) ;
03410 }
03411
03412 static int G__G__TMVA4_126_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03413 {
03414 ((const TMVA::TNeuron*) G__getstructoffset())->PrintPostLinks();
03415 G__setnull(result7);
03416 return(1 || funcname || hash || result7 || libp) ;
03417 }
03418
03419 static int G__G__TMVA4_126_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03420 {
03421 G__letint(result7, 85, (long) TMVA::TNeuron::Class());
03422 return(1 || funcname || hash || result7 || libp) ;
03423 }
03424
03425 static int G__G__TMVA4_126_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03426 {
03427 G__letint(result7, 67, (long) TMVA::TNeuron::Class_Name());
03428 return(1 || funcname || hash || result7 || libp) ;
03429 }
03430
03431 static int G__G__TMVA4_126_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03432 {
03433 G__letint(result7, 115, (long) TMVA::TNeuron::Class_Version());
03434 return(1 || funcname || hash || result7 || libp) ;
03435 }
03436
03437 static int G__G__TMVA4_126_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03438 {
03439 TMVA::TNeuron::Dictionary();
03440 G__setnull(result7);
03441 return(1 || funcname || hash || result7 || libp) ;
03442 }
03443
03444 static int G__G__TMVA4_126_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03445 {
03446 ((TMVA::TNeuron*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03447 G__setnull(result7);
03448 return(1 || funcname || hash || result7 || libp) ;
03449 }
03450
03451 static int G__G__TMVA4_126_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03452 {
03453 G__letint(result7, 67, (long) TMVA::TNeuron::DeclFileName());
03454 return(1 || funcname || hash || result7 || libp) ;
03455 }
03456
03457 static int G__G__TMVA4_126_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03458 {
03459 G__letint(result7, 105, (long) TMVA::TNeuron::ImplFileLine());
03460 return(1 || funcname || hash || result7 || libp) ;
03461 }
03462
03463 static int G__G__TMVA4_126_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03464 {
03465 G__letint(result7, 67, (long) TMVA::TNeuron::ImplFileName());
03466 return(1 || funcname || hash || result7 || libp) ;
03467 }
03468
03469 static int G__G__TMVA4_126_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03470 {
03471 G__letint(result7, 105, (long) TMVA::TNeuron::DeclFileLine());
03472 return(1 || funcname || hash || result7 || libp) ;
03473 }
03474
03475
03476 static int G__G__TMVA4_126_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03477
03478 {
03479 TMVA::TNeuron* p;
03480 void* tmp = (void*) G__int(libp->para[0]);
03481 p = new TMVA::TNeuron(*(TMVA::TNeuron*) tmp);
03482 result7->obj.i = (long) p;
03483 result7->ref = (long) p;
03484 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron));
03485 return(1 || funcname || hash || result7 || libp) ;
03486 }
03487
03488
03489 typedef TMVA::TNeuron G__TTMVAcLcLTNeuron;
03490 static int G__G__TMVA4_126_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03491 {
03492 char* gvp = (char*) G__getgvp();
03493 long soff = G__getstructoffset();
03494 int n = G__getaryconstruct();
03495
03496
03497
03498
03499
03500 if (!soff) {
03501 return(1);
03502 }
03503 if (n) {
03504 if (gvp == (char*)G__PVOID) {
03505 delete[] (TMVA::TNeuron*) soff;
03506 } else {
03507 G__setgvp((long) G__PVOID);
03508 for (int i = n - 1; i >= 0; --i) {
03509 ((TMVA::TNeuron*) (soff+(sizeof(TMVA::TNeuron)*i)))->~G__TTMVAcLcLTNeuron();
03510 }
03511 G__setgvp((long)gvp);
03512 }
03513 } else {
03514 if (gvp == (char*)G__PVOID) {
03515 delete (TMVA::TNeuron*) soff;
03516 } else {
03517 G__setgvp((long) G__PVOID);
03518 ((TMVA::TNeuron*) (soff))->~G__TTMVAcLcLTNeuron();
03519 G__setgvp((long)gvp);
03520 }
03521 }
03522 G__setnull(result7);
03523 return(1 || funcname || hash || result7 || libp) ;
03524 }
03525
03526
03527 static int G__G__TMVA4_126_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03528 {
03529 TMVA::TNeuron* dest = (TMVA::TNeuron*) G__getstructoffset();
03530 *dest = *(TMVA::TNeuron*) libp->para[0].ref;
03531 const TMVA::TNeuron& obj = *dest;
03532 result7->ref = (long) (&obj);
03533 result7->obj.i = (long) (&obj);
03534 return(1 || funcname || hash || result7 || libp) ;
03535 }
03536
03537
03538
03539 static int G__G__TMVA4_127_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03540 {
03541 TMVA::MsgLogger* p = NULL;
03542 char* gvp = (char*) G__getgvp();
03543 switch (libp->paran) {
03544 case 2:
03545
03546 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03547 p = new TMVA::MsgLogger((TObject*) G__int(libp->para[0]), (TMVA::EMsgType) G__int(libp->para[1]));
03548 } else {
03549 p = new((void*) gvp) TMVA::MsgLogger((TObject*) G__int(libp->para[0]), (TMVA::EMsgType) G__int(libp->para[1]));
03550 }
03551 break;
03552 case 1:
03553
03554 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03555 p = new TMVA::MsgLogger((TObject*) G__int(libp->para[0]));
03556 } else {
03557 p = new((void*) gvp) TMVA::MsgLogger((TObject*) G__int(libp->para[0]));
03558 }
03559 break;
03560 }
03561 result7->obj.i = (long) p;
03562 result7->ref = (long) p;
03563 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger));
03564 return(1 || funcname || hash || result7 || libp) ;
03565 }
03566
03567 static int G__G__TMVA4_127_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03568 {
03569 TMVA::MsgLogger* p = NULL;
03570 char* gvp = (char*) G__getgvp();
03571 switch (libp->paran) {
03572 case 2:
03573
03574 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03575 p = new TMVA::MsgLogger(*(string*) libp->para[0].ref, (TMVA::EMsgType) G__int(libp->para[1]));
03576 } else {
03577 p = new((void*) gvp) TMVA::MsgLogger(*(string*) libp->para[0].ref, (TMVA::EMsgType) G__int(libp->para[1]));
03578 }
03579 break;
03580 case 1:
03581
03582 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03583 p = new TMVA::MsgLogger(*(string*) libp->para[0].ref);
03584 } else {
03585 p = new((void*) gvp) TMVA::MsgLogger(*(string*) libp->para[0].ref);
03586 }
03587 break;
03588 }
03589 result7->obj.i = (long) p;
03590 result7->ref = (long) p;
03591 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger));
03592 return(1 || funcname || hash || result7 || libp) ;
03593 }
03594
03595 static int G__G__TMVA4_127_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03596 {
03597 TMVA::MsgLogger* p = NULL;
03598 char* gvp = (char*) G__getgvp();
03599 switch (libp->paran) {
03600 case 1:
03601
03602 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03603 p = new TMVA::MsgLogger((TMVA::EMsgType) G__int(libp->para[0]));
03604 } else {
03605 p = new((void*) gvp) TMVA::MsgLogger((TMVA::EMsgType) G__int(libp->para[0]));
03606 }
03607 break;
03608 case 0:
03609 int n = G__getaryconstruct();
03610 if (n) {
03611 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03612 p = new TMVA::MsgLogger[n];
03613 } else {
03614 p = new((void*) gvp) TMVA::MsgLogger[n];
03615 }
03616 } else {
03617 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03618 p = new TMVA::MsgLogger;
03619 } else {
03620 p = new((void*) gvp) TMVA::MsgLogger;
03621 }
03622 }
03623 break;
03624 }
03625 result7->obj.i = (long) p;
03626 result7->ref = (long) p;
03627 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger));
03628 return(1 || funcname || hash || result7 || libp) ;
03629 }
03630
03631 static int G__G__TMVA4_127_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03632 {
03633 TMVA::MsgLogger* p = NULL;
03634 char* gvp = (char*) G__getgvp();
03635
03636 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03637 p = new TMVA::MsgLogger(*(TMVA::MsgLogger*) libp->para[0].ref);
03638 } else {
03639 p = new((void*) gvp) TMVA::MsgLogger(*(TMVA::MsgLogger*) libp->para[0].ref);
03640 }
03641 result7->obj.i = (long) p;
03642 result7->ref = (long) p;
03643 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger));
03644 return(1 || funcname || hash || result7 || libp) ;
03645 }
03646
03647 static int G__G__TMVA4_127_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03648 {
03649 ((TMVA::MsgLogger*) G__getstructoffset())->SetSource(*(string*) libp->para[0].ref);
03650 G__setnull(result7);
03651 return(1 || funcname || hash || result7 || libp) ;
03652 }
03653
03654 static int G__G__TMVA4_127_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03655 {
03656 G__letint(result7, 105, (long) ((const TMVA::MsgLogger*) G__getstructoffset())->GetMinType());
03657 return(1 || funcname || hash || result7 || libp) ;
03658 }
03659
03660 static int G__G__TMVA4_127_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03661 {
03662 ((TMVA::MsgLogger*) G__getstructoffset())->SetMinType((TMVA::EMsgType) G__int(libp->para[0]));
03663 G__setnull(result7);
03664 return(1 || funcname || hash || result7 || libp) ;
03665 }
03666
03667 static int G__G__TMVA4_127_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03668 {
03669 {
03670 const string* pobj;
03671 const string xobj = ((const TMVA::MsgLogger*) G__getstructoffset())->GetSource();
03672 pobj = new string(xobj);
03673 result7->obj.i = (long) ((void*) pobj);
03674 result7->ref = result7->obj.i;
03675 G__store_tempobject(*result7);
03676 }
03677 return(1 || funcname || hash || result7 || libp) ;
03678 }
03679
03680 static int G__G__TMVA4_127_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03681 {
03682 {
03683 const string* pobj;
03684 const string xobj = ((const TMVA::MsgLogger*) G__getstructoffset())->GetPrintedSource();
03685 pobj = new string(xobj);
03686 result7->obj.i = (long) ((void*) pobj);
03687 result7->ref = result7->obj.i;
03688 G__store_tempobject(*result7);
03689 }
03690 return(1 || funcname || hash || result7 || libp) ;
03691 }
03692
03693 static int G__G__TMVA4_127_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03694 {
03695 {
03696 const string* pobj;
03697 const string xobj = ((const TMVA::MsgLogger*) G__getstructoffset())->GetFormattedSource();
03698 pobj = new string(xobj);
03699 result7->obj.i = (long) ((void*) pobj);
03700 result7->ref = result7->obj.i;
03701 G__store_tempobject(*result7);
03702 }
03703 return(1 || funcname || hash || result7 || libp) ;
03704 }
03705
03706 static int G__G__TMVA4_127_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03707 {
03708 G__letint(result7, 104, (long) TMVA::MsgLogger::GetMaxSourceSize());
03709 return(1 || funcname || hash || result7 || libp) ;
03710 }
03711
03712 static int G__G__TMVA4_127_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03713 {
03714 {
03715 const TMVA::MsgLogger& obj = ((TMVA::MsgLogger*) G__getstructoffset())->operator=(*(TMVA::MsgLogger*) libp->para[0].ref);
03716 result7->ref = (long) (&obj);
03717 result7->obj.i = (long) (&obj);
03718 }
03719 return(1 || funcname || hash || result7 || libp) ;
03720 }
03721
03722 static int G__G__TMVA4_127_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03723 {
03724 {
03725 const TMVA::MsgLogger& obj = TMVA::MsgLogger::Endmsg(*(TMVA::MsgLogger*) libp->para[0].ref);
03726 result7->ref = (long) (&obj);
03727 result7->obj.i = (long) (&obj);
03728 }
03729 return(1 || funcname || hash || result7 || libp) ;
03730 }
03731
03732 static int G__G__TMVA4_127_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03733 {
03734 {
03735 const TMVA::MsgLogger& obj = ((TMVA::MsgLogger*) G__getstructoffset())->operator<<((std::ios& (*)(std::ios&) ) G__int(libp->para[0]));
03736 result7->ref = (long) (&obj);
03737 result7->obj.i = (long) (&obj);
03738 }
03739 return(1 || funcname || hash || result7 || libp) ;
03740 }
03741
03742 static int G__G__TMVA4_127_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03743 {
03744 {
03745 const TMVA::MsgLogger& obj = ((TMVA::MsgLogger*) G__getstructoffset())->operator<<((TMVA::EMsgType) G__int(libp->para[0]));
03746 result7->ref = (long) (&obj);
03747 result7->obj.i = (long) (&obj);
03748 }
03749 return(1 || funcname || hash || result7 || libp) ;
03750 }
03751
03752 static int G__G__TMVA4_127_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03753 {
03754 TMVA::MsgLogger::InhibitOutput();
03755 G__setnull(result7);
03756 return(1 || funcname || hash || result7 || libp) ;
03757 }
03758
03759 static int G__G__TMVA4_127_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03760 {
03761 TMVA::MsgLogger::EnableOutput();
03762 G__setnull(result7);
03763 return(1 || funcname || hash || result7 || libp) ;
03764 }
03765
03766 static int G__G__TMVA4_127_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03767 {
03768 G__letint(result7, 85, (long) TMVA::MsgLogger::Class());
03769 return(1 || funcname || hash || result7 || libp) ;
03770 }
03771
03772 static int G__G__TMVA4_127_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03773 {
03774 G__letint(result7, 67, (long) TMVA::MsgLogger::Class_Name());
03775 return(1 || funcname || hash || result7 || libp) ;
03776 }
03777
03778 static int G__G__TMVA4_127_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03779 {
03780 G__letint(result7, 115, (long) TMVA::MsgLogger::Class_Version());
03781 return(1 || funcname || hash || result7 || libp) ;
03782 }
03783
03784 static int G__G__TMVA4_127_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03785 {
03786 TMVA::MsgLogger::Dictionary();
03787 G__setnull(result7);
03788 return(1 || funcname || hash || result7 || libp) ;
03789 }
03790
03791 static int G__G__TMVA4_127_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03792 {
03793 ((TMVA::MsgLogger*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03794 G__setnull(result7);
03795 return(1 || funcname || hash || result7 || libp) ;
03796 }
03797
03798 static int G__G__TMVA4_127_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03799 {
03800 G__letint(result7, 67, (long) TMVA::MsgLogger::DeclFileName());
03801 return(1 || funcname || hash || result7 || libp) ;
03802 }
03803
03804 static int G__G__TMVA4_127_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03805 {
03806 G__letint(result7, 105, (long) TMVA::MsgLogger::ImplFileLine());
03807 return(1 || funcname || hash || result7 || libp) ;
03808 }
03809
03810 static int G__G__TMVA4_127_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03811 {
03812 G__letint(result7, 67, (long) TMVA::MsgLogger::ImplFileName());
03813 return(1 || funcname || hash || result7 || libp) ;
03814 }
03815
03816 static int G__G__TMVA4_127_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03817 {
03818 G__letint(result7, 105, (long) TMVA::MsgLogger::DeclFileLine());
03819 return(1 || funcname || hash || result7 || libp) ;
03820 }
03821
03822
03823 typedef TMVA::MsgLogger G__TTMVAcLcLMsgLogger;
03824 static int G__G__TMVA4_127_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03825 {
03826 char* gvp = (char*) G__getgvp();
03827 long soff = G__getstructoffset();
03828 int n = G__getaryconstruct();
03829
03830
03831
03832
03833
03834 if (!soff) {
03835 return(1);
03836 }
03837 if (n) {
03838 if (gvp == (char*)G__PVOID) {
03839 delete[] (TMVA::MsgLogger*) soff;
03840 } else {
03841 G__setgvp((long) G__PVOID);
03842 for (int i = n - 1; i >= 0; --i) {
03843 ((TMVA::MsgLogger*) (soff+(sizeof(TMVA::MsgLogger)*i)))->~G__TTMVAcLcLMsgLogger();
03844 }
03845 G__setgvp((long)gvp);
03846 }
03847 } else {
03848 if (gvp == (char*)G__PVOID) {
03849 delete (TMVA::MsgLogger*) soff;
03850 } else {
03851 G__setgvp((long) G__PVOID);
03852 ((TMVA::MsgLogger*) (soff))->~G__TTMVAcLcLMsgLogger();
03853 G__setgvp((long)gvp);
03854 }
03855 }
03856 G__setnull(result7);
03857 return(1 || funcname || hash || result7 || libp) ;
03858 }
03859
03860
03861
03862 static int G__G__TMVA4_128_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03863 {
03864 TMVA::TSynapse* p = NULL;
03865 char* gvp = (char*) G__getgvp();
03866 int n = G__getaryconstruct();
03867 if (n) {
03868 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03869 p = new TMVA::TSynapse[n];
03870 } else {
03871 p = new((void*) gvp) TMVA::TSynapse[n];
03872 }
03873 } else {
03874 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03875 p = new TMVA::TSynapse;
03876 } else {
03877 p = new((void*) gvp) TMVA::TSynapse;
03878 }
03879 }
03880 result7->obj.i = (long) p;
03881 result7->ref = (long) p;
03882 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse));
03883 return(1 || funcname || hash || result7 || libp) ;
03884 }
03885
03886 static int G__G__TMVA4_128_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03887 {
03888 ((TMVA::TSynapse*) G__getstructoffset())->SetWeight((Double_t) G__double(libp->para[0]));
03889 G__setnull(result7);
03890 return(1 || funcname || hash || result7 || libp) ;
03891 }
03892
03893 static int G__G__TMVA4_128_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03894 {
03895 G__letdouble(result7, 100, (double) ((TMVA::TSynapse*) G__getstructoffset())->GetWeight());
03896 return(1 || funcname || hash || result7 || libp) ;
03897 }
03898
03899 static int G__G__TMVA4_128_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03900 {
03901 ((TMVA::TSynapse*) G__getstructoffset())->SetLearningRate((Double_t) G__double(libp->para[0]));
03902 G__setnull(result7);
03903 return(1 || funcname || hash || result7 || libp) ;
03904 }
03905
03906 static int G__G__TMVA4_128_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03907 {
03908 G__letdouble(result7, 100, (double) ((TMVA::TSynapse*) G__getstructoffset())->GetLearningRate());
03909 return(1 || funcname || hash || result7 || libp) ;
03910 }
03911
03912 static int G__G__TMVA4_128_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03913 {
03914 ((TMVA::TSynapse*) G__getstructoffset())->DecayLearningRate((Double_t) G__double(libp->para[0]));
03915 G__setnull(result7);
03916 return(1 || funcname || hash || result7 || libp) ;
03917 }
03918
03919 static int G__G__TMVA4_128_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03920 {
03921 ((TMVA::TSynapse*) G__getstructoffset())->SetPreNeuron((TMVA::TNeuron*) G__int(libp->para[0]));
03922 G__setnull(result7);
03923 return(1 || funcname || hash || result7 || libp) ;
03924 }
03925
03926 static int G__G__TMVA4_128_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03927 {
03928 ((TMVA::TSynapse*) G__getstructoffset())->SetPostNeuron((TMVA::TNeuron*) G__int(libp->para[0]));
03929 G__setnull(result7);
03930 return(1 || funcname || hash || result7 || libp) ;
03931 }
03932
03933 static int G__G__TMVA4_128_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03934 {
03935 G__letdouble(result7, 100, (double) ((TMVA::TSynapse*) G__getstructoffset())->GetWeightedValue());
03936 return(1 || funcname || hash || result7 || libp) ;
03937 }
03938
03939 static int G__G__TMVA4_128_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03940 {
03941 G__letdouble(result7, 100, (double) ((TMVA::TSynapse*) G__getstructoffset())->GetWeightedDelta());
03942 return(1 || funcname || hash || result7 || libp) ;
03943 }
03944
03945 static int G__G__TMVA4_128_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03946 {
03947 ((TMVA::TSynapse*) G__getstructoffset())->AdjustWeight();
03948 G__setnull(result7);
03949 return(1 || funcname || hash || result7 || libp) ;
03950 }
03951
03952 static int G__G__TMVA4_128_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03953 {
03954 ((TMVA::TSynapse*) G__getstructoffset())->CalculateDelta();
03955 G__setnull(result7);
03956 return(1 || funcname || hash || result7 || libp) ;
03957 }
03958
03959 static int G__G__TMVA4_128_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03960 {
03961 ((TMVA::TSynapse*) G__getstructoffset())->InitDelta();
03962 G__setnull(result7);
03963 return(1 || funcname || hash || result7 || libp) ;
03964 }
03965
03966 static int G__G__TMVA4_128_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03967 {
03968 ((TMVA::TSynapse*) G__getstructoffset())->SetDEDw((Double_t) G__double(libp->para[0]));
03969 G__setnull(result7);
03970 return(1 || funcname || hash || result7 || libp) ;
03971 }
03972
03973 static int G__G__TMVA4_128_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03974 {
03975 G__letdouble(result7, 100, (double) ((TMVA::TSynapse*) G__getstructoffset())->GetDEDw());
03976 return(1 || funcname || hash || result7 || libp) ;
03977 }
03978
03979 static int G__G__TMVA4_128_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03980 {
03981 G__letdouble(result7, 100, (double) ((TMVA::TSynapse*) G__getstructoffset())->GetDelta());
03982 return(1 || funcname || hash || result7 || libp) ;
03983 }
03984
03985 static int G__G__TMVA4_128_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03986 {
03987 G__letint(result7, 85, (long) TMVA::TSynapse::Class());
03988 return(1 || funcname || hash || result7 || libp) ;
03989 }
03990
03991 static int G__G__TMVA4_128_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03992 {
03993 G__letint(result7, 67, (long) TMVA::TSynapse::Class_Name());
03994 return(1 || funcname || hash || result7 || libp) ;
03995 }
03996
03997 static int G__G__TMVA4_128_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03998 {
03999 G__letint(result7, 115, (long) TMVA::TSynapse::Class_Version());
04000 return(1 || funcname || hash || result7 || libp) ;
04001 }
04002
04003 static int G__G__TMVA4_128_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04004 {
04005 TMVA::TSynapse::Dictionary();
04006 G__setnull(result7);
04007 return(1 || funcname || hash || result7 || libp) ;
04008 }
04009
04010 static int G__G__TMVA4_128_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04011 {
04012 ((TMVA::TSynapse*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04013 G__setnull(result7);
04014 return(1 || funcname || hash || result7 || libp) ;
04015 }
04016
04017 static int G__G__TMVA4_128_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04018 {
04019 G__letint(result7, 67, (long) TMVA::TSynapse::DeclFileName());
04020 return(1 || funcname || hash || result7 || libp) ;
04021 }
04022
04023 static int G__G__TMVA4_128_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04024 {
04025 G__letint(result7, 105, (long) TMVA::TSynapse::ImplFileLine());
04026 return(1 || funcname || hash || result7 || libp) ;
04027 }
04028
04029 static int G__G__TMVA4_128_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04030 {
04031 G__letint(result7, 67, (long) TMVA::TSynapse::ImplFileName());
04032 return(1 || funcname || hash || result7 || libp) ;
04033 }
04034
04035 static int G__G__TMVA4_128_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04036 {
04037 G__letint(result7, 105, (long) TMVA::TSynapse::DeclFileLine());
04038 return(1 || funcname || hash || result7 || libp) ;
04039 }
04040
04041
04042 static int G__G__TMVA4_128_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04043
04044 {
04045 TMVA::TSynapse* p;
04046 void* tmp = (void*) G__int(libp->para[0]);
04047 p = new TMVA::TSynapse(*(TMVA::TSynapse*) tmp);
04048 result7->obj.i = (long) p;
04049 result7->ref = (long) p;
04050 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse));
04051 return(1 || funcname || hash || result7 || libp) ;
04052 }
04053
04054
04055 typedef TMVA::TSynapse G__TTMVAcLcLTSynapse;
04056 static int G__G__TMVA4_128_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04057 {
04058 char* gvp = (char*) G__getgvp();
04059 long soff = G__getstructoffset();
04060 int n = G__getaryconstruct();
04061
04062
04063
04064
04065
04066 if (!soff) {
04067 return(1);
04068 }
04069 if (n) {
04070 if (gvp == (char*)G__PVOID) {
04071 delete[] (TMVA::TSynapse*) soff;
04072 } else {
04073 G__setgvp((long) G__PVOID);
04074 for (int i = n - 1; i >= 0; --i) {
04075 ((TMVA::TSynapse*) (soff+(sizeof(TMVA::TSynapse)*i)))->~G__TTMVAcLcLTSynapse();
04076 }
04077 G__setgvp((long)gvp);
04078 }
04079 } else {
04080 if (gvp == (char*)G__PVOID) {
04081 delete (TMVA::TSynapse*) soff;
04082 } else {
04083 G__setgvp((long) G__PVOID);
04084 ((TMVA::TSynapse*) (soff))->~G__TTMVAcLcLTSynapse();
04085 G__setgvp((long)gvp);
04086 }
04087 }
04088 G__setnull(result7);
04089 return(1 || funcname || hash || result7 || libp) ;
04090 }
04091
04092
04093 static int G__G__TMVA4_128_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04094 {
04095 TMVA::TSynapse* dest = (TMVA::TSynapse*) G__getstructoffset();
04096 *dest = *(TMVA::TSynapse*) libp->para[0].ref;
04097 const TMVA::TSynapse& obj = *dest;
04098 result7->ref = (long) (&obj);
04099 result7->obj.i = (long) (&obj);
04100 return(1 || funcname || hash || result7 || libp) ;
04101 }
04102
04103
04104
04105 static int G__G__TMVA4_129_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04106 {
04107 G__letdouble(result7, 100, (double) ((TMVA::TActivation*) G__getstructoffset())->Eval((Double_t) G__double(libp->para[0])));
04108 return(1 || funcname || hash || result7 || libp) ;
04109 }
04110
04111 static int G__G__TMVA4_129_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04112 {
04113 G__letdouble(result7, 100, (double) ((TMVA::TActivation*) G__getstructoffset())->EvalDerivative((Double_t) G__double(libp->para[0])));
04114 return(1 || funcname || hash || result7 || libp) ;
04115 }
04116
04117 static int G__G__TMVA4_129_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04118 {
04119 G__letdouble(result7, 100, (double) ((TMVA::TActivation*) G__getstructoffset())->GetMin());
04120 return(1 || funcname || hash || result7 || libp) ;
04121 }
04122
04123 static int G__G__TMVA4_129_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04124 {
04125 G__letdouble(result7, 100, (double) ((TMVA::TActivation*) G__getstructoffset())->GetMax());
04126 return(1 || funcname || hash || result7 || libp) ;
04127 }
04128
04129 static int G__G__TMVA4_129_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04130 {
04131 {
04132 TString* pobj;
04133 TString xobj = ((TMVA::TActivation*) G__getstructoffset())->GetExpression();
04134 pobj = new TString(xobj);
04135 result7->obj.i = (long) ((void*) pobj);
04136 result7->ref = result7->obj.i;
04137 G__store_tempobject(*result7);
04138 }
04139 return(1 || funcname || hash || result7 || libp) ;
04140 }
04141
04142 static int G__G__TMVA4_129_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04143 {
04144 ((TMVA::TActivation*) G__getstructoffset())->MakeFunction(*(ostream*) libp->para[0].ref, *(TString*) libp->para[1].ref);
04145 G__setnull(result7);
04146 return(1 || funcname || hash || result7 || libp) ;
04147 }
04148
04149 static int G__G__TMVA4_129_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04150 {
04151 G__letint(result7, 85, (long) TMVA::TActivation::Class());
04152 return(1 || funcname || hash || result7 || libp) ;
04153 }
04154
04155 static int G__G__TMVA4_129_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04156 {
04157 G__letint(result7, 67, (long) TMVA::TActivation::Class_Name());
04158 return(1 || funcname || hash || result7 || libp) ;
04159 }
04160
04161 static int G__G__TMVA4_129_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04162 {
04163 G__letint(result7, 115, (long) TMVA::TActivation::Class_Version());
04164 return(1 || funcname || hash || result7 || libp) ;
04165 }
04166
04167 static int G__G__TMVA4_129_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04168 {
04169 TMVA::TActivation::Dictionary();
04170 G__setnull(result7);
04171 return(1 || funcname || hash || result7 || libp) ;
04172 }
04173
04174 static int G__G__TMVA4_129_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04175 {
04176 G__letint(result7, 85, (long) ((const TMVA::TActivation*) G__getstructoffset())->IsA());
04177 return(1 || funcname || hash || result7 || libp) ;
04178 }
04179
04180 static int G__G__TMVA4_129_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04181 {
04182 ((TMVA::TActivation*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
04183 G__setnull(result7);
04184 return(1 || funcname || hash || result7 || libp) ;
04185 }
04186
04187 static int G__G__TMVA4_129_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04188 {
04189 ((TMVA::TActivation*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
04190 G__setnull(result7);
04191 return(1 || funcname || hash || result7 || libp) ;
04192 }
04193
04194 static int G__G__TMVA4_129_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04195 {
04196 ((TMVA::TActivation*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04197 G__setnull(result7);
04198 return(1 || funcname || hash || result7 || libp) ;
04199 }
04200
04201 static int G__G__TMVA4_129_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04202 {
04203 G__letint(result7, 67, (long) TMVA::TActivation::DeclFileName());
04204 return(1 || funcname || hash || result7 || libp) ;
04205 }
04206
04207 static int G__G__TMVA4_129_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04208 {
04209 G__letint(result7, 105, (long) TMVA::TActivation::ImplFileLine());
04210 return(1 || funcname || hash || result7 || libp) ;
04211 }
04212
04213 static int G__G__TMVA4_129_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04214 {
04215 G__letint(result7, 67, (long) TMVA::TActivation::ImplFileName());
04216 return(1 || funcname || hash || result7 || libp) ;
04217 }
04218
04219 static int G__G__TMVA4_129_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04220 {
04221 G__letint(result7, 105, (long) TMVA::TActivation::DeclFileLine());
04222 return(1 || funcname || hash || result7 || libp) ;
04223 }
04224
04225
04226 typedef TMVA::TActivation G__TTMVAcLcLTActivation;
04227 static int G__G__TMVA4_129_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04228 {
04229 char* gvp = (char*) G__getgvp();
04230 long soff = G__getstructoffset();
04231 int n = G__getaryconstruct();
04232
04233
04234
04235
04236
04237 if (!soff) {
04238 return(1);
04239 }
04240 if (n) {
04241 if (gvp == (char*)G__PVOID) {
04242 delete[] (TMVA::TActivation*) soff;
04243 } else {
04244 G__setgvp((long) G__PVOID);
04245 for (int i = n - 1; i >= 0; --i) {
04246 ((TMVA::TActivation*) (soff+(sizeof(TMVA::TActivation)*i)))->~G__TTMVAcLcLTActivation();
04247 }
04248 G__setgvp((long)gvp);
04249 }
04250 } else {
04251 if (gvp == (char*)G__PVOID) {
04252 delete (TMVA::TActivation*) soff;
04253 } else {
04254 G__setgvp((long) G__PVOID);
04255 ((TMVA::TActivation*) (soff))->~G__TTMVAcLcLTActivation();
04256 G__setgvp((long)gvp);
04257 }
04258 }
04259 G__setnull(result7);
04260 return(1 || funcname || hash || result7 || libp) ;
04261 }
04262
04263
04264 static int G__G__TMVA4_129_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04265 {
04266 TMVA::TActivation* dest = (TMVA::TActivation*) G__getstructoffset();
04267 *dest = *(TMVA::TActivation*) libp->para[0].ref;
04268 const TMVA::TActivation& obj = *dest;
04269 result7->ref = (long) (&obj);
04270 result7->obj.i = (long) (&obj);
04271 return(1 || funcname || hash || result7 || libp) ;
04272 }
04273
04274
04275
04276 static int G__G__TMVA4_131_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04277 {
04278 {
04279 const TMVA::Types& obj = TMVA::Types::Instance();
04280 result7->ref = (long) (&obj);
04281 result7->obj.i = (long) (&obj);
04282 }
04283 return(1 || funcname || hash || result7 || libp) ;
04284 }
04285
04286 static int G__G__TMVA4_131_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04287 {
04288 TMVA::Types::DestroyInstance();
04289 G__setnull(result7);
04290 return(1 || funcname || hash || result7 || libp) ;
04291 }
04292
04293 static int G__G__TMVA4_131_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04294 {
04295 G__letint(result7, 105, (long) ((const TMVA::Types*) G__getstructoffset())->GetMethodType(*(TString*) libp->para[0].ref));
04296 return(1 || funcname || hash || result7 || libp) ;
04297 }
04298
04299 static int G__G__TMVA4_131_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04300 {
04301 {
04302 const TString* pobj;
04303 const TString xobj = ((const TMVA::Types*) G__getstructoffset())->GetMethodName((TMVA::Types::EMVA) G__int(libp->para[0]));
04304 pobj = new TString(xobj);
04305 result7->obj.i = (long) ((void*) pobj);
04306 result7->ref = result7->obj.i;
04307 G__store_tempobject(*result7);
04308 }
04309 return(1 || funcname || hash || result7 || libp) ;
04310 }
04311
04312 static int G__G__TMVA4_131_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04313 {
04314 G__letint(result7, 103, (long) ((TMVA::Types*) G__getstructoffset())->AddTypeMapping((TMVA::Types::EMVA) G__int(libp->para[0]), *(TString*) libp->para[1].ref));
04315 return(1 || funcname || hash || result7 || libp) ;
04316 }
04317
04318
04319 static int G__G__TMVA4_131_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04320
04321 {
04322 TMVA::Types* p;
04323 void* tmp = (void*) G__int(libp->para[0]);
04324 p = new TMVA::Types(*(TMVA::Types*) tmp);
04325 result7->obj.i = (long) p;
04326 result7->ref = (long) p;
04327 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypes));
04328 return(1 || funcname || hash || result7 || libp) ;
04329 }
04330
04331
04332 typedef TMVA::Types G__TTMVAcLcLTypes;
04333 static int G__G__TMVA4_131_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04334 {
04335 char* gvp = (char*) G__getgvp();
04336 long soff = G__getstructoffset();
04337 int n = G__getaryconstruct();
04338
04339
04340
04341
04342
04343 if (!soff) {
04344 return(1);
04345 }
04346 if (n) {
04347 if (gvp == (char*)G__PVOID) {
04348 delete[] (TMVA::Types*) soff;
04349 } else {
04350 G__setgvp((long) G__PVOID);
04351 for (int i = n - 1; i >= 0; --i) {
04352 ((TMVA::Types*) (soff+(sizeof(TMVA::Types)*i)))->~G__TTMVAcLcLTypes();
04353 }
04354 G__setgvp((long)gvp);
04355 }
04356 } else {
04357 if (gvp == (char*)G__PVOID) {
04358 delete (TMVA::Types*) soff;
04359 } else {
04360 G__setgvp((long) G__PVOID);
04361 ((TMVA::Types*) (soff))->~G__TTMVAcLcLTypes();
04362 G__setgvp((long)gvp);
04363 }
04364 }
04365 G__setnull(result7);
04366 return(1 || funcname || hash || result7 || libp) ;
04367 }
04368
04369
04370 static int G__G__TMVA4_131_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04371 {
04372 TMVA::Types* dest = (TMVA::Types*) G__getstructoffset();
04373 *dest = *(TMVA::Types*) libp->para[0].ref;
04374 const TMVA::Types& obj = *dest;
04375 result7->ref = (long) (&obj);
04376 result7->obj.i = (long) (&obj);
04377 return(1 || funcname || hash || result7 || libp) ;
04378 }
04379
04380
04381
04382 static int G__G__TMVA4_147_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04383 {
04384 G__letdouble(result7, 100, (double) ((const TMVA::TNeuronInput*) G__getstructoffset())->GetInput((TMVA::TNeuron*) G__int(libp->para[0])));
04385 return(1 || funcname || hash || result7 || libp) ;
04386 }
04387
04388 static int G__G__TMVA4_147_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04389 {
04390 {
04391 TString* pobj;
04392 TString xobj = ((TMVA::TNeuronInput*) G__getstructoffset())->GetName();
04393 pobj = new TString(xobj);
04394 result7->obj.i = (long) ((void*) pobj);
04395 result7->ref = result7->obj.i;
04396 G__store_tempobject(*result7);
04397 }
04398 return(1 || funcname || hash || result7 || libp) ;
04399 }
04400
04401 static int G__G__TMVA4_147_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04402 {
04403 G__letint(result7, 85, (long) TMVA::TNeuronInput::Class());
04404 return(1 || funcname || hash || result7 || libp) ;
04405 }
04406
04407 static int G__G__TMVA4_147_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04408 {
04409 G__letint(result7, 67, (long) TMVA::TNeuronInput::Class_Name());
04410 return(1 || funcname || hash || result7 || libp) ;
04411 }
04412
04413 static int G__G__TMVA4_147_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04414 {
04415 G__letint(result7, 115, (long) TMVA::TNeuronInput::Class_Version());
04416 return(1 || funcname || hash || result7 || libp) ;
04417 }
04418
04419 static int G__G__TMVA4_147_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04420 {
04421 TMVA::TNeuronInput::Dictionary();
04422 G__setnull(result7);
04423 return(1 || funcname || hash || result7 || libp) ;
04424 }
04425
04426 static int G__G__TMVA4_147_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04427 {
04428 G__letint(result7, 85, (long) ((const TMVA::TNeuronInput*) G__getstructoffset())->IsA());
04429 return(1 || funcname || hash || result7 || libp) ;
04430 }
04431
04432 static int G__G__TMVA4_147_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04433 {
04434 ((TMVA::TNeuronInput*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
04435 G__setnull(result7);
04436 return(1 || funcname || hash || result7 || libp) ;
04437 }
04438
04439 static int G__G__TMVA4_147_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04440 {
04441 ((TMVA::TNeuronInput*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
04442 G__setnull(result7);
04443 return(1 || funcname || hash || result7 || libp) ;
04444 }
04445
04446 static int G__G__TMVA4_147_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04447 {
04448 ((TMVA::TNeuronInput*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04449 G__setnull(result7);
04450 return(1 || funcname || hash || result7 || libp) ;
04451 }
04452
04453 static int G__G__TMVA4_147_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04454 {
04455 G__letint(result7, 67, (long) TMVA::TNeuronInput::DeclFileName());
04456 return(1 || funcname || hash || result7 || libp) ;
04457 }
04458
04459 static int G__G__TMVA4_147_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04460 {
04461 G__letint(result7, 105, (long) TMVA::TNeuronInput::ImplFileLine());
04462 return(1 || funcname || hash || result7 || libp) ;
04463 }
04464
04465 static int G__G__TMVA4_147_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04466 {
04467 G__letint(result7, 67, (long) TMVA::TNeuronInput::ImplFileName());
04468 return(1 || funcname || hash || result7 || libp) ;
04469 }
04470
04471 static int G__G__TMVA4_147_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04472 {
04473 G__letint(result7, 105, (long) TMVA::TNeuronInput::DeclFileLine());
04474 return(1 || funcname || hash || result7 || libp) ;
04475 }
04476
04477
04478 typedef TMVA::TNeuronInput G__TTMVAcLcLTNeuronInput;
04479 static int G__G__TMVA4_147_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04480 {
04481 char* gvp = (char*) G__getgvp();
04482 long soff = G__getstructoffset();
04483 int n = G__getaryconstruct();
04484
04485
04486
04487
04488
04489 if (!soff) {
04490 return(1);
04491 }
04492 if (n) {
04493 if (gvp == (char*)G__PVOID) {
04494 delete[] (TMVA::TNeuronInput*) soff;
04495 } else {
04496 G__setgvp((long) G__PVOID);
04497 for (int i = n - 1; i >= 0; --i) {
04498 ((TMVA::TNeuronInput*) (soff+(sizeof(TMVA::TNeuronInput)*i)))->~G__TTMVAcLcLTNeuronInput();
04499 }
04500 G__setgvp((long)gvp);
04501 }
04502 } else {
04503 if (gvp == (char*)G__PVOID) {
04504 delete (TMVA::TNeuronInput*) soff;
04505 } else {
04506 G__setgvp((long) G__PVOID);
04507 ((TMVA::TNeuronInput*) (soff))->~G__TTMVAcLcLTNeuronInput();
04508 G__setgvp((long)gvp);
04509 }
04510 }
04511 G__setnull(result7);
04512 return(1 || funcname || hash || result7 || libp) ;
04513 }
04514
04515
04516 static int G__G__TMVA4_147_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04517 {
04518 TMVA::TNeuronInput* dest = (TMVA::TNeuronInput*) G__getstructoffset();
04519 *dest = *(TMVA::TNeuronInput*) libp->para[0].ref;
04520 const TMVA::TNeuronInput& obj = *dest;
04521 result7->ref = (long) (&obj);
04522 result7->obj.i = (long) (&obj);
04523 return(1 || funcname || hash || result7 || libp) ;
04524 }
04525
04526
04527
04528 static int G__G__TMVA4_148_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04529 {
04530 TMVA::TActivationChooser* p = NULL;
04531 char* gvp = (char*) G__getgvp();
04532 int n = G__getaryconstruct();
04533 if (n) {
04534 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04535 p = new TMVA::TActivationChooser[n];
04536 } else {
04537 p = new((void*) gvp) TMVA::TActivationChooser[n];
04538 }
04539 } else {
04540 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04541 p = new TMVA::TActivationChooser;
04542 } else {
04543 p = new((void*) gvp) TMVA::TActivationChooser;
04544 }
04545 }
04546 result7->obj.i = (long) p;
04547 result7->ref = (long) p;
04548 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChooser));
04549 return(1 || funcname || hash || result7 || libp) ;
04550 }
04551
04552 static int G__G__TMVA4_148_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04553 {
04554 G__letint(result7, 85, (long) ((const TMVA::TActivationChooser*) G__getstructoffset())->CreateActivation((TMVA::TActivationChooser::EActivationType) G__int(libp->para[0])));
04555 return(1 || funcname || hash || result7 || libp) ;
04556 }
04557
04558 static int G__G__TMVA4_148_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04559 {
04560 G__letint(result7, 85, (long) ((const TMVA::TActivationChooser*) G__getstructoffset())->CreateActivation(*(TString*) libp->para[0].ref));
04561 return(1 || funcname || hash || result7 || libp) ;
04562 }
04563
04564 static int G__G__TMVA4_148_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04565 {
04566 G__letint(result7, 85, (long) ((const TMVA::TActivationChooser*) G__getstructoffset())->GetAllActivationNames());
04567 return(1 || funcname || hash || result7 || libp) ;
04568 }
04569
04570 static int G__G__TMVA4_148_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04571 {
04572 G__letint(result7, 85, (long) TMVA::TActivationChooser::Class());
04573 return(1 || funcname || hash || result7 || libp) ;
04574 }
04575
04576 static int G__G__TMVA4_148_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04577 {
04578 G__letint(result7, 67, (long) TMVA::TActivationChooser::Class_Name());
04579 return(1 || funcname || hash || result7 || libp) ;
04580 }
04581
04582 static int G__G__TMVA4_148_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04583 {
04584 G__letint(result7, 115, (long) TMVA::TActivationChooser::Class_Version());
04585 return(1 || funcname || hash || result7 || libp) ;
04586 }
04587
04588 static int G__G__TMVA4_148_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04589 {
04590 TMVA::TActivationChooser::Dictionary();
04591 G__setnull(result7);
04592 return(1 || funcname || hash || result7 || libp) ;
04593 }
04594
04595 static int G__G__TMVA4_148_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04596 {
04597 G__letint(result7, 85, (long) ((const TMVA::TActivationChooser*) G__getstructoffset())->IsA());
04598 return(1 || funcname || hash || result7 || libp) ;
04599 }
04600
04601 static int G__G__TMVA4_148_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04602 {
04603 ((TMVA::TActivationChooser*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
04604 G__setnull(result7);
04605 return(1 || funcname || hash || result7 || libp) ;
04606 }
04607
04608 static int G__G__TMVA4_148_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04609 {
04610 ((TMVA::TActivationChooser*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
04611 G__setnull(result7);
04612 return(1 || funcname || hash || result7 || libp) ;
04613 }
04614
04615 static int G__G__TMVA4_148_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04616 {
04617 ((TMVA::TActivationChooser*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04618 G__setnull(result7);
04619 return(1 || funcname || hash || result7 || libp) ;
04620 }
04621
04622 static int G__G__TMVA4_148_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04623 {
04624 G__letint(result7, 67, (long) TMVA::TActivationChooser::DeclFileName());
04625 return(1 || funcname || hash || result7 || libp) ;
04626 }
04627
04628 static int G__G__TMVA4_148_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04629 {
04630 G__letint(result7, 105, (long) TMVA::TActivationChooser::ImplFileLine());
04631 return(1 || funcname || hash || result7 || libp) ;
04632 }
04633
04634 static int G__G__TMVA4_148_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04635 {
04636 G__letint(result7, 67, (long) TMVA::TActivationChooser::ImplFileName());
04637 return(1 || funcname || hash || result7 || libp) ;
04638 }
04639
04640 static int G__G__TMVA4_148_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04641 {
04642 G__letint(result7, 105, (long) TMVA::TActivationChooser::DeclFileLine());
04643 return(1 || funcname || hash || result7 || libp) ;
04644 }
04645
04646
04647 static int G__G__TMVA4_148_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04648
04649 {
04650 TMVA::TActivationChooser* p;
04651 void* tmp = (void*) G__int(libp->para[0]);
04652 p = new TMVA::TActivationChooser(*(TMVA::TActivationChooser*) tmp);
04653 result7->obj.i = (long) p;
04654 result7->ref = (long) p;
04655 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChooser));
04656 return(1 || funcname || hash || result7 || libp) ;
04657 }
04658
04659
04660 typedef TMVA::TActivationChooser G__TTMVAcLcLTActivationChooser;
04661 static int G__G__TMVA4_148_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04662 {
04663 char* gvp = (char*) G__getgvp();
04664 long soff = G__getstructoffset();
04665 int n = G__getaryconstruct();
04666
04667
04668
04669
04670
04671 if (!soff) {
04672 return(1);
04673 }
04674 if (n) {
04675 if (gvp == (char*)G__PVOID) {
04676 delete[] (TMVA::TActivationChooser*) soff;
04677 } else {
04678 G__setgvp((long) G__PVOID);
04679 for (int i = n - 1; i >= 0; --i) {
04680 ((TMVA::TActivationChooser*) (soff+(sizeof(TMVA::TActivationChooser)*i)))->~G__TTMVAcLcLTActivationChooser();
04681 }
04682 G__setgvp((long)gvp);
04683 }
04684 } else {
04685 if (gvp == (char*)G__PVOID) {
04686 delete (TMVA::TActivationChooser*) soff;
04687 } else {
04688 G__setgvp((long) G__PVOID);
04689 ((TMVA::TActivationChooser*) (soff))->~G__TTMVAcLcLTActivationChooser();
04690 G__setgvp((long)gvp);
04691 }
04692 }
04693 G__setnull(result7);
04694 return(1 || funcname || hash || result7 || libp) ;
04695 }
04696
04697
04698 static int G__G__TMVA4_148_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04699 {
04700 TMVA::TActivationChooser* dest = (TMVA::TActivationChooser*) G__getstructoffset();
04701 *dest = *(TMVA::TActivationChooser*) libp->para[0].ref;
04702 const TMVA::TActivationChooser& obj = *dest;
04703 result7->ref = (long) (&obj);
04704 result7->obj.i = (long) (&obj);
04705 return(1 || funcname || hash || result7 || libp) ;
04706 }
04707
04708
04709
04710 static int G__G__TMVA4_154_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04711 {
04712 TMVA::TActivationSigmoid* p = NULL;
04713 char* gvp = (char*) G__getgvp();
04714 int n = G__getaryconstruct();
04715 if (n) {
04716 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04717 p = new TMVA::TActivationSigmoid[n];
04718 } else {
04719 p = new((void*) gvp) TMVA::TActivationSigmoid[n];
04720 }
04721 } else {
04722 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04723 p = new TMVA::TActivationSigmoid;
04724 } else {
04725 p = new((void*) gvp) TMVA::TActivationSigmoid;
04726 }
04727 }
04728 result7->obj.i = (long) p;
04729 result7->ref = (long) p;
04730 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid));
04731 return(1 || funcname || hash || result7 || libp) ;
04732 }
04733
04734 static int G__G__TMVA4_154_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04735 {
04736 G__letint(result7, 85, (long) TMVA::TActivationSigmoid::Class());
04737 return(1 || funcname || hash || result7 || libp) ;
04738 }
04739
04740 static int G__G__TMVA4_154_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04741 {
04742 G__letint(result7, 67, (long) TMVA::TActivationSigmoid::Class_Name());
04743 return(1 || funcname || hash || result7 || libp) ;
04744 }
04745
04746 static int G__G__TMVA4_154_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04747 {
04748 G__letint(result7, 115, (long) TMVA::TActivationSigmoid::Class_Version());
04749 return(1 || funcname || hash || result7 || libp) ;
04750 }
04751
04752 static int G__G__TMVA4_154_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04753 {
04754 TMVA::TActivationSigmoid::Dictionary();
04755 G__setnull(result7);
04756 return(1 || funcname || hash || result7 || libp) ;
04757 }
04758
04759 static int G__G__TMVA4_154_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04760 {
04761 ((TMVA::TActivationSigmoid*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04762 G__setnull(result7);
04763 return(1 || funcname || hash || result7 || libp) ;
04764 }
04765
04766 static int G__G__TMVA4_154_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04767 {
04768 G__letint(result7, 67, (long) TMVA::TActivationSigmoid::DeclFileName());
04769 return(1 || funcname || hash || result7 || libp) ;
04770 }
04771
04772 static int G__G__TMVA4_154_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04773 {
04774 G__letint(result7, 105, (long) TMVA::TActivationSigmoid::ImplFileLine());
04775 return(1 || funcname || hash || result7 || libp) ;
04776 }
04777
04778 static int G__G__TMVA4_154_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04779 {
04780 G__letint(result7, 67, (long) TMVA::TActivationSigmoid::ImplFileName());
04781 return(1 || funcname || hash || result7 || libp) ;
04782 }
04783
04784 static int G__G__TMVA4_154_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04785 {
04786 G__letint(result7, 105, (long) TMVA::TActivationSigmoid::DeclFileLine());
04787 return(1 || funcname || hash || result7 || libp) ;
04788 }
04789
04790
04791 static int G__G__TMVA4_154_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04792
04793 {
04794 TMVA::TActivationSigmoid* p;
04795 void* tmp = (void*) G__int(libp->para[0]);
04796 p = new TMVA::TActivationSigmoid(*(TMVA::TActivationSigmoid*) tmp);
04797 result7->obj.i = (long) p;
04798 result7->ref = (long) p;
04799 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid));
04800 return(1 || funcname || hash || result7 || libp) ;
04801 }
04802
04803
04804 typedef TMVA::TActivationSigmoid G__TTMVAcLcLTActivationSigmoid;
04805 static int G__G__TMVA4_154_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04806 {
04807 char* gvp = (char*) G__getgvp();
04808 long soff = G__getstructoffset();
04809 int n = G__getaryconstruct();
04810
04811
04812
04813
04814
04815 if (!soff) {
04816 return(1);
04817 }
04818 if (n) {
04819 if (gvp == (char*)G__PVOID) {
04820 delete[] (TMVA::TActivationSigmoid*) soff;
04821 } else {
04822 G__setgvp((long) G__PVOID);
04823 for (int i = n - 1; i >= 0; --i) {
04824 ((TMVA::TActivationSigmoid*) (soff+(sizeof(TMVA::TActivationSigmoid)*i)))->~G__TTMVAcLcLTActivationSigmoid();
04825 }
04826 G__setgvp((long)gvp);
04827 }
04828 } else {
04829 if (gvp == (char*)G__PVOID) {
04830 delete (TMVA::TActivationSigmoid*) soff;
04831 } else {
04832 G__setgvp((long) G__PVOID);
04833 ((TMVA::TActivationSigmoid*) (soff))->~G__TTMVAcLcLTActivationSigmoid();
04834 G__setgvp((long)gvp);
04835 }
04836 }
04837 G__setnull(result7);
04838 return(1 || funcname || hash || result7 || libp) ;
04839 }
04840
04841
04842 static int G__G__TMVA4_154_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04843 {
04844 TMVA::TActivationSigmoid* dest = (TMVA::TActivationSigmoid*) G__getstructoffset();
04845 *dest = *(TMVA::TActivationSigmoid*) libp->para[0].ref;
04846 const TMVA::TActivationSigmoid& obj = *dest;
04847 result7->ref = (long) (&obj);
04848 result7->obj.i = (long) (&obj);
04849 return(1 || funcname || hash || result7 || libp) ;
04850 }
04851
04852
04853
04854 static int G__G__TMVA4_155_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04855 {
04856 TMVA::TActivationIdentity* p = NULL;
04857 char* gvp = (char*) G__getgvp();
04858 int n = G__getaryconstruct();
04859 if (n) {
04860 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04861 p = new TMVA::TActivationIdentity[n];
04862 } else {
04863 p = new((void*) gvp) TMVA::TActivationIdentity[n];
04864 }
04865 } else {
04866 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04867 p = new TMVA::TActivationIdentity;
04868 } else {
04869 p = new((void*) gvp) TMVA::TActivationIdentity;
04870 }
04871 }
04872 result7->obj.i = (long) p;
04873 result7->ref = (long) p;
04874 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity));
04875 return(1 || funcname || hash || result7 || libp) ;
04876 }
04877
04878 static int G__G__TMVA4_155_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04879 {
04880 G__letint(result7, 85, (long) TMVA::TActivationIdentity::Class());
04881 return(1 || funcname || hash || result7 || libp) ;
04882 }
04883
04884 static int G__G__TMVA4_155_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04885 {
04886 G__letint(result7, 67, (long) TMVA::TActivationIdentity::Class_Name());
04887 return(1 || funcname || hash || result7 || libp) ;
04888 }
04889
04890 static int G__G__TMVA4_155_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04891 {
04892 G__letint(result7, 115, (long) TMVA::TActivationIdentity::Class_Version());
04893 return(1 || funcname || hash || result7 || libp) ;
04894 }
04895
04896 static int G__G__TMVA4_155_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04897 {
04898 TMVA::TActivationIdentity::Dictionary();
04899 G__setnull(result7);
04900 return(1 || funcname || hash || result7 || libp) ;
04901 }
04902
04903 static int G__G__TMVA4_155_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04904 {
04905 ((TMVA::TActivationIdentity*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04906 G__setnull(result7);
04907 return(1 || funcname || hash || result7 || libp) ;
04908 }
04909
04910 static int G__G__TMVA4_155_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04911 {
04912 G__letint(result7, 67, (long) TMVA::TActivationIdentity::DeclFileName());
04913 return(1 || funcname || hash || result7 || libp) ;
04914 }
04915
04916 static int G__G__TMVA4_155_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04917 {
04918 G__letint(result7, 105, (long) TMVA::TActivationIdentity::ImplFileLine());
04919 return(1 || funcname || hash || result7 || libp) ;
04920 }
04921
04922 static int G__G__TMVA4_155_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04923 {
04924 G__letint(result7, 67, (long) TMVA::TActivationIdentity::ImplFileName());
04925 return(1 || funcname || hash || result7 || libp) ;
04926 }
04927
04928 static int G__G__TMVA4_155_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04929 {
04930 G__letint(result7, 105, (long) TMVA::TActivationIdentity::DeclFileLine());
04931 return(1 || funcname || hash || result7 || libp) ;
04932 }
04933
04934
04935 static int G__G__TMVA4_155_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04936
04937 {
04938 TMVA::TActivationIdentity* p;
04939 void* tmp = (void*) G__int(libp->para[0]);
04940 p = new TMVA::TActivationIdentity(*(TMVA::TActivationIdentity*) tmp);
04941 result7->obj.i = (long) p;
04942 result7->ref = (long) p;
04943 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity));
04944 return(1 || funcname || hash || result7 || libp) ;
04945 }
04946
04947
04948 typedef TMVA::TActivationIdentity G__TTMVAcLcLTActivationIdentity;
04949 static int G__G__TMVA4_155_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04950 {
04951 char* gvp = (char*) G__getgvp();
04952 long soff = G__getstructoffset();
04953 int n = G__getaryconstruct();
04954
04955
04956
04957
04958
04959 if (!soff) {
04960 return(1);
04961 }
04962 if (n) {
04963 if (gvp == (char*)G__PVOID) {
04964 delete[] (TMVA::TActivationIdentity*) soff;
04965 } else {
04966 G__setgvp((long) G__PVOID);
04967 for (int i = n - 1; i >= 0; --i) {
04968 ((TMVA::TActivationIdentity*) (soff+(sizeof(TMVA::TActivationIdentity)*i)))->~G__TTMVAcLcLTActivationIdentity();
04969 }
04970 G__setgvp((long)gvp);
04971 }
04972 } else {
04973 if (gvp == (char*)G__PVOID) {
04974 delete (TMVA::TActivationIdentity*) soff;
04975 } else {
04976 G__setgvp((long) G__PVOID);
04977 ((TMVA::TActivationIdentity*) (soff))->~G__TTMVAcLcLTActivationIdentity();
04978 G__setgvp((long)gvp);
04979 }
04980 }
04981 G__setnull(result7);
04982 return(1 || funcname || hash || result7 || libp) ;
04983 }
04984
04985
04986 static int G__G__TMVA4_155_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04987 {
04988 TMVA::TActivationIdentity* dest = (TMVA::TActivationIdentity*) G__getstructoffset();
04989 *dest = *(TMVA::TActivationIdentity*) libp->para[0].ref;
04990 const TMVA::TActivationIdentity& obj = *dest;
04991 result7->ref = (long) (&obj);
04992 result7->obj.i = (long) (&obj);
04993 return(1 || funcname || hash || result7 || libp) ;
04994 }
04995
04996
04997
04998 static int G__G__TMVA4_156_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04999 {
05000 TMVA::TActivationTanh* p = NULL;
05001 char* gvp = (char*) G__getgvp();
05002 int n = G__getaryconstruct();
05003 if (n) {
05004 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05005 p = new TMVA::TActivationTanh[n];
05006 } else {
05007 p = new((void*) gvp) TMVA::TActivationTanh[n];
05008 }
05009 } else {
05010 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05011 p = new TMVA::TActivationTanh;
05012 } else {
05013 p = new((void*) gvp) TMVA::TActivationTanh;
05014 }
05015 }
05016 result7->obj.i = (long) p;
05017 result7->ref = (long) p;
05018 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh));
05019 return(1 || funcname || hash || result7 || libp) ;
05020 }
05021
05022 static int G__G__TMVA4_156_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05023 {
05024 G__letint(result7, 85, (long) TMVA::TActivationTanh::Class());
05025 return(1 || funcname || hash || result7 || libp) ;
05026 }
05027
05028 static int G__G__TMVA4_156_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05029 {
05030 G__letint(result7, 67, (long) TMVA::TActivationTanh::Class_Name());
05031 return(1 || funcname || hash || result7 || libp) ;
05032 }
05033
05034 static int G__G__TMVA4_156_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05035 {
05036 G__letint(result7, 115, (long) TMVA::TActivationTanh::Class_Version());
05037 return(1 || funcname || hash || result7 || libp) ;
05038 }
05039
05040 static int G__G__TMVA4_156_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05041 {
05042 TMVA::TActivationTanh::Dictionary();
05043 G__setnull(result7);
05044 return(1 || funcname || hash || result7 || libp) ;
05045 }
05046
05047 static int G__G__TMVA4_156_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05048 {
05049 ((TMVA::TActivationTanh*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05050 G__setnull(result7);
05051 return(1 || funcname || hash || result7 || libp) ;
05052 }
05053
05054 static int G__G__TMVA4_156_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05055 {
05056 G__letint(result7, 67, (long) TMVA::TActivationTanh::DeclFileName());
05057 return(1 || funcname || hash || result7 || libp) ;
05058 }
05059
05060 static int G__G__TMVA4_156_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05061 {
05062 G__letint(result7, 105, (long) TMVA::TActivationTanh::ImplFileLine());
05063 return(1 || funcname || hash || result7 || libp) ;
05064 }
05065
05066 static int G__G__TMVA4_156_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05067 {
05068 G__letint(result7, 67, (long) TMVA::TActivationTanh::ImplFileName());
05069 return(1 || funcname || hash || result7 || libp) ;
05070 }
05071
05072 static int G__G__TMVA4_156_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05073 {
05074 G__letint(result7, 105, (long) TMVA::TActivationTanh::DeclFileLine());
05075 return(1 || funcname || hash || result7 || libp) ;
05076 }
05077
05078
05079 static int G__G__TMVA4_156_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05080
05081 {
05082 TMVA::TActivationTanh* p;
05083 void* tmp = (void*) G__int(libp->para[0]);
05084 p = new TMVA::TActivationTanh(*(TMVA::TActivationTanh*) tmp);
05085 result7->obj.i = (long) p;
05086 result7->ref = (long) p;
05087 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh));
05088 return(1 || funcname || hash || result7 || libp) ;
05089 }
05090
05091
05092 typedef TMVA::TActivationTanh G__TTMVAcLcLTActivationTanh;
05093 static int G__G__TMVA4_156_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05094 {
05095 char* gvp = (char*) G__getgvp();
05096 long soff = G__getstructoffset();
05097 int n = G__getaryconstruct();
05098
05099
05100
05101
05102
05103 if (!soff) {
05104 return(1);
05105 }
05106 if (n) {
05107 if (gvp == (char*)G__PVOID) {
05108 delete[] (TMVA::TActivationTanh*) soff;
05109 } else {
05110 G__setgvp((long) G__PVOID);
05111 for (int i = n - 1; i >= 0; --i) {
05112 ((TMVA::TActivationTanh*) (soff+(sizeof(TMVA::TActivationTanh)*i)))->~G__TTMVAcLcLTActivationTanh();
05113 }
05114 G__setgvp((long)gvp);
05115 }
05116 } else {
05117 if (gvp == (char*)G__PVOID) {
05118 delete (TMVA::TActivationTanh*) soff;
05119 } else {
05120 G__setgvp((long) G__PVOID);
05121 ((TMVA::TActivationTanh*) (soff))->~G__TTMVAcLcLTActivationTanh();
05122 G__setgvp((long)gvp);
05123 }
05124 }
05125 G__setnull(result7);
05126 return(1 || funcname || hash || result7 || libp) ;
05127 }
05128
05129
05130 static int G__G__TMVA4_156_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05131 {
05132 TMVA::TActivationTanh* dest = (TMVA::TActivationTanh*) G__getstructoffset();
05133 *dest = *(TMVA::TActivationTanh*) libp->para[0].ref;
05134 const TMVA::TActivationTanh& obj = *dest;
05135 result7->ref = (long) (&obj);
05136 result7->obj.i = (long) (&obj);
05137 return(1 || funcname || hash || result7 || libp) ;
05138 }
05139
05140
05141
05142 static int G__G__TMVA4_157_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05143 {
05144 TMVA::TActivationRadial* p = NULL;
05145 char* gvp = (char*) G__getgvp();
05146 int n = G__getaryconstruct();
05147 if (n) {
05148 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05149 p = new TMVA::TActivationRadial[n];
05150 } else {
05151 p = new((void*) gvp) TMVA::TActivationRadial[n];
05152 }
05153 } else {
05154 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05155 p = new TMVA::TActivationRadial;
05156 } else {
05157 p = new((void*) gvp) TMVA::TActivationRadial;
05158 }
05159 }
05160 result7->obj.i = (long) p;
05161 result7->ref = (long) p;
05162 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial));
05163 return(1 || funcname || hash || result7 || libp) ;
05164 }
05165
05166 static int G__G__TMVA4_157_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05167 {
05168 G__letint(result7, 85, (long) TMVA::TActivationRadial::Class());
05169 return(1 || funcname || hash || result7 || libp) ;
05170 }
05171
05172 static int G__G__TMVA4_157_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05173 {
05174 G__letint(result7, 67, (long) TMVA::TActivationRadial::Class_Name());
05175 return(1 || funcname || hash || result7 || libp) ;
05176 }
05177
05178 static int G__G__TMVA4_157_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05179 {
05180 G__letint(result7, 115, (long) TMVA::TActivationRadial::Class_Version());
05181 return(1 || funcname || hash || result7 || libp) ;
05182 }
05183
05184 static int G__G__TMVA4_157_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05185 {
05186 TMVA::TActivationRadial::Dictionary();
05187 G__setnull(result7);
05188 return(1 || funcname || hash || result7 || libp) ;
05189 }
05190
05191 static int G__G__TMVA4_157_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05192 {
05193 ((TMVA::TActivationRadial*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05194 G__setnull(result7);
05195 return(1 || funcname || hash || result7 || libp) ;
05196 }
05197
05198 static int G__G__TMVA4_157_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05199 {
05200 G__letint(result7, 67, (long) TMVA::TActivationRadial::DeclFileName());
05201 return(1 || funcname || hash || result7 || libp) ;
05202 }
05203
05204 static int G__G__TMVA4_157_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05205 {
05206 G__letint(result7, 105, (long) TMVA::TActivationRadial::ImplFileLine());
05207 return(1 || funcname || hash || result7 || libp) ;
05208 }
05209
05210 static int G__G__TMVA4_157_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05211 {
05212 G__letint(result7, 67, (long) TMVA::TActivationRadial::ImplFileName());
05213 return(1 || funcname || hash || result7 || libp) ;
05214 }
05215
05216 static int G__G__TMVA4_157_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05217 {
05218 G__letint(result7, 105, (long) TMVA::TActivationRadial::DeclFileLine());
05219 return(1 || funcname || hash || result7 || libp) ;
05220 }
05221
05222
05223 static int G__G__TMVA4_157_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05224
05225 {
05226 TMVA::TActivationRadial* p;
05227 void* tmp = (void*) G__int(libp->para[0]);
05228 p = new TMVA::TActivationRadial(*(TMVA::TActivationRadial*) tmp);
05229 result7->obj.i = (long) p;
05230 result7->ref = (long) p;
05231 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial));
05232 return(1 || funcname || hash || result7 || libp) ;
05233 }
05234
05235
05236 typedef TMVA::TActivationRadial G__TTMVAcLcLTActivationRadial;
05237 static int G__G__TMVA4_157_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05238 {
05239 char* gvp = (char*) G__getgvp();
05240 long soff = G__getstructoffset();
05241 int n = G__getaryconstruct();
05242
05243
05244
05245
05246
05247 if (!soff) {
05248 return(1);
05249 }
05250 if (n) {
05251 if (gvp == (char*)G__PVOID) {
05252 delete[] (TMVA::TActivationRadial*) soff;
05253 } else {
05254 G__setgvp((long) G__PVOID);
05255 for (int i = n - 1; i >= 0; --i) {
05256 ((TMVA::TActivationRadial*) (soff+(sizeof(TMVA::TActivationRadial)*i)))->~G__TTMVAcLcLTActivationRadial();
05257 }
05258 G__setgvp((long)gvp);
05259 }
05260 } else {
05261 if (gvp == (char*)G__PVOID) {
05262 delete (TMVA::TActivationRadial*) soff;
05263 } else {
05264 G__setgvp((long) G__PVOID);
05265 ((TMVA::TActivationRadial*) (soff))->~G__TTMVAcLcLTActivationRadial();
05266 G__setgvp((long)gvp);
05267 }
05268 }
05269 G__setnull(result7);
05270 return(1 || funcname || hash || result7 || libp) ;
05271 }
05272
05273
05274 static int G__G__TMVA4_157_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05275 {
05276 TMVA::TActivationRadial* dest = (TMVA::TActivationRadial*) G__getstructoffset();
05277 *dest = *(TMVA::TActivationRadial*) libp->para[0].ref;
05278 const TMVA::TActivationRadial& obj = *dest;
05279 result7->ref = (long) (&obj);
05280 result7->obj.i = (long) (&obj);
05281 return(1 || funcname || hash || result7 || libp) ;
05282 }
05283
05284
05285
05286 static int G__G__TMVA4_158_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05287 {
05288 TMVA::TNeuronInputSum* p = NULL;
05289 char* gvp = (char*) G__getgvp();
05290 int n = G__getaryconstruct();
05291 if (n) {
05292 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05293 p = new TMVA::TNeuronInputSum[n];
05294 } else {
05295 p = new((void*) gvp) TMVA::TNeuronInputSum[n];
05296 }
05297 } else {
05298 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05299 p = new TMVA::TNeuronInputSum;
05300 } else {
05301 p = new((void*) gvp) TMVA::TNeuronInputSum;
05302 }
05303 }
05304 result7->obj.i = (long) p;
05305 result7->ref = (long) p;
05306 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum));
05307 return(1 || funcname || hash || result7 || libp) ;
05308 }
05309
05310 static int G__G__TMVA4_158_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05311 {
05312 G__letint(result7, 85, (long) TMVA::TNeuronInputSum::Class());
05313 return(1 || funcname || hash || result7 || libp) ;
05314 }
05315
05316 static int G__G__TMVA4_158_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05317 {
05318 G__letint(result7, 67, (long) TMVA::TNeuronInputSum::Class_Name());
05319 return(1 || funcname || hash || result7 || libp) ;
05320 }
05321
05322 static int G__G__TMVA4_158_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05323 {
05324 G__letint(result7, 115, (long) TMVA::TNeuronInputSum::Class_Version());
05325 return(1 || funcname || hash || result7 || libp) ;
05326 }
05327
05328 static int G__G__TMVA4_158_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05329 {
05330 TMVA::TNeuronInputSum::Dictionary();
05331 G__setnull(result7);
05332 return(1 || funcname || hash || result7 || libp) ;
05333 }
05334
05335 static int G__G__TMVA4_158_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05336 {
05337 ((TMVA::TNeuronInputSum*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05338 G__setnull(result7);
05339 return(1 || funcname || hash || result7 || libp) ;
05340 }
05341
05342 static int G__G__TMVA4_158_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05343 {
05344 G__letint(result7, 67, (long) TMVA::TNeuronInputSum::DeclFileName());
05345 return(1 || funcname || hash || result7 || libp) ;
05346 }
05347
05348 static int G__G__TMVA4_158_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05349 {
05350 G__letint(result7, 105, (long) TMVA::TNeuronInputSum::ImplFileLine());
05351 return(1 || funcname || hash || result7 || libp) ;
05352 }
05353
05354 static int G__G__TMVA4_158_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05355 {
05356 G__letint(result7, 67, (long) TMVA::TNeuronInputSum::ImplFileName());
05357 return(1 || funcname || hash || result7 || libp) ;
05358 }
05359
05360 static int G__G__TMVA4_158_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05361 {
05362 G__letint(result7, 105, (long) TMVA::TNeuronInputSum::DeclFileLine());
05363 return(1 || funcname || hash || result7 || libp) ;
05364 }
05365
05366
05367 static int G__G__TMVA4_158_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05368
05369 {
05370 TMVA::TNeuronInputSum* p;
05371 void* tmp = (void*) G__int(libp->para[0]);
05372 p = new TMVA::TNeuronInputSum(*(TMVA::TNeuronInputSum*) tmp);
05373 result7->obj.i = (long) p;
05374 result7->ref = (long) p;
05375 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum));
05376 return(1 || funcname || hash || result7 || libp) ;
05377 }
05378
05379
05380 typedef TMVA::TNeuronInputSum G__TTMVAcLcLTNeuronInputSum;
05381 static int G__G__TMVA4_158_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05382 {
05383 char* gvp = (char*) G__getgvp();
05384 long soff = G__getstructoffset();
05385 int n = G__getaryconstruct();
05386
05387
05388
05389
05390
05391 if (!soff) {
05392 return(1);
05393 }
05394 if (n) {
05395 if (gvp == (char*)G__PVOID) {
05396 delete[] (TMVA::TNeuronInputSum*) soff;
05397 } else {
05398 G__setgvp((long) G__PVOID);
05399 for (int i = n - 1; i >= 0; --i) {
05400 ((TMVA::TNeuronInputSum*) (soff+(sizeof(TMVA::TNeuronInputSum)*i)))->~G__TTMVAcLcLTNeuronInputSum();
05401 }
05402 G__setgvp((long)gvp);
05403 }
05404 } else {
05405 if (gvp == (char*)G__PVOID) {
05406 delete (TMVA::TNeuronInputSum*) soff;
05407 } else {
05408 G__setgvp((long) G__PVOID);
05409 ((TMVA::TNeuronInputSum*) (soff))->~G__TTMVAcLcLTNeuronInputSum();
05410 G__setgvp((long)gvp);
05411 }
05412 }
05413 G__setnull(result7);
05414 return(1 || funcname || hash || result7 || libp) ;
05415 }
05416
05417
05418 static int G__G__TMVA4_158_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05419 {
05420 TMVA::TNeuronInputSum* dest = (TMVA::TNeuronInputSum*) G__getstructoffset();
05421 *dest = *(TMVA::TNeuronInputSum*) libp->para[0].ref;
05422 const TMVA::TNeuronInputSum& obj = *dest;
05423 result7->ref = (long) (&obj);
05424 result7->obj.i = (long) (&obj);
05425 return(1 || funcname || hash || result7 || libp) ;
05426 }
05427
05428
05429
05430 static int G__G__TMVA4_159_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05431 {
05432 TMVA::TNeuronInputSqSum* p = NULL;
05433 char* gvp = (char*) G__getgvp();
05434 int n = G__getaryconstruct();
05435 if (n) {
05436 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05437 p = new TMVA::TNeuronInputSqSum[n];
05438 } else {
05439 p = new((void*) gvp) TMVA::TNeuronInputSqSum[n];
05440 }
05441 } else {
05442 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05443 p = new TMVA::TNeuronInputSqSum;
05444 } else {
05445 p = new((void*) gvp) TMVA::TNeuronInputSqSum;
05446 }
05447 }
05448 result7->obj.i = (long) p;
05449 result7->ref = (long) p;
05450 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum));
05451 return(1 || funcname || hash || result7 || libp) ;
05452 }
05453
05454 static int G__G__TMVA4_159_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05455 {
05456 G__letint(result7, 85, (long) TMVA::TNeuronInputSqSum::Class());
05457 return(1 || funcname || hash || result7 || libp) ;
05458 }
05459
05460 static int G__G__TMVA4_159_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05461 {
05462 G__letint(result7, 67, (long) TMVA::TNeuronInputSqSum::Class_Name());
05463 return(1 || funcname || hash || result7 || libp) ;
05464 }
05465
05466 static int G__G__TMVA4_159_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05467 {
05468 G__letint(result7, 115, (long) TMVA::TNeuronInputSqSum::Class_Version());
05469 return(1 || funcname || hash || result7 || libp) ;
05470 }
05471
05472 static int G__G__TMVA4_159_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05473 {
05474 TMVA::TNeuronInputSqSum::Dictionary();
05475 G__setnull(result7);
05476 return(1 || funcname || hash || result7 || libp) ;
05477 }
05478
05479 static int G__G__TMVA4_159_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05480 {
05481 ((TMVA::TNeuronInputSqSum*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05482 G__setnull(result7);
05483 return(1 || funcname || hash || result7 || libp) ;
05484 }
05485
05486 static int G__G__TMVA4_159_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05487 {
05488 G__letint(result7, 67, (long) TMVA::TNeuronInputSqSum::DeclFileName());
05489 return(1 || funcname || hash || result7 || libp) ;
05490 }
05491
05492 static int G__G__TMVA4_159_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05493 {
05494 G__letint(result7, 105, (long) TMVA::TNeuronInputSqSum::ImplFileLine());
05495 return(1 || funcname || hash || result7 || libp) ;
05496 }
05497
05498 static int G__G__TMVA4_159_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05499 {
05500 G__letint(result7, 67, (long) TMVA::TNeuronInputSqSum::ImplFileName());
05501 return(1 || funcname || hash || result7 || libp) ;
05502 }
05503
05504 static int G__G__TMVA4_159_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05505 {
05506 G__letint(result7, 105, (long) TMVA::TNeuronInputSqSum::DeclFileLine());
05507 return(1 || funcname || hash || result7 || libp) ;
05508 }
05509
05510
05511 static int G__G__TMVA4_159_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05512
05513 {
05514 TMVA::TNeuronInputSqSum* p;
05515 void* tmp = (void*) G__int(libp->para[0]);
05516 p = new TMVA::TNeuronInputSqSum(*(TMVA::TNeuronInputSqSum*) tmp);
05517 result7->obj.i = (long) p;
05518 result7->ref = (long) p;
05519 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum));
05520 return(1 || funcname || hash || result7 || libp) ;
05521 }
05522
05523
05524 typedef TMVA::TNeuronInputSqSum G__TTMVAcLcLTNeuronInputSqSum;
05525 static int G__G__TMVA4_159_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05526 {
05527 char* gvp = (char*) G__getgvp();
05528 long soff = G__getstructoffset();
05529 int n = G__getaryconstruct();
05530
05531
05532
05533
05534
05535 if (!soff) {
05536 return(1);
05537 }
05538 if (n) {
05539 if (gvp == (char*)G__PVOID) {
05540 delete[] (TMVA::TNeuronInputSqSum*) soff;
05541 } else {
05542 G__setgvp((long) G__PVOID);
05543 for (int i = n - 1; i >= 0; --i) {
05544 ((TMVA::TNeuronInputSqSum*) (soff+(sizeof(TMVA::TNeuronInputSqSum)*i)))->~G__TTMVAcLcLTNeuronInputSqSum();
05545 }
05546 G__setgvp((long)gvp);
05547 }
05548 } else {
05549 if (gvp == (char*)G__PVOID) {
05550 delete (TMVA::TNeuronInputSqSum*) soff;
05551 } else {
05552 G__setgvp((long) G__PVOID);
05553 ((TMVA::TNeuronInputSqSum*) (soff))->~G__TTMVAcLcLTNeuronInputSqSum();
05554 G__setgvp((long)gvp);
05555 }
05556 }
05557 G__setnull(result7);
05558 return(1 || funcname || hash || result7 || libp) ;
05559 }
05560
05561
05562 static int G__G__TMVA4_159_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05563 {
05564 TMVA::TNeuronInputSqSum* dest = (TMVA::TNeuronInputSqSum*) G__getstructoffset();
05565 *dest = *(TMVA::TNeuronInputSqSum*) libp->para[0].ref;
05566 const TMVA::TNeuronInputSqSum& obj = *dest;
05567 result7->ref = (long) (&obj);
05568 result7->obj.i = (long) (&obj);
05569 return(1 || funcname || hash || result7 || libp) ;
05570 }
05571
05572
05573
05574 static int G__G__TMVA4_160_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05575 {
05576 TMVA::TNeuronInputAbs* p = NULL;
05577 char* gvp = (char*) G__getgvp();
05578 int n = G__getaryconstruct();
05579 if (n) {
05580 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05581 p = new TMVA::TNeuronInputAbs[n];
05582 } else {
05583 p = new((void*) gvp) TMVA::TNeuronInputAbs[n];
05584 }
05585 } else {
05586 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05587 p = new TMVA::TNeuronInputAbs;
05588 } else {
05589 p = new((void*) gvp) TMVA::TNeuronInputAbs;
05590 }
05591 }
05592 result7->obj.i = (long) p;
05593 result7->ref = (long) p;
05594 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs));
05595 return(1 || funcname || hash || result7 || libp) ;
05596 }
05597
05598 static int G__G__TMVA4_160_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05599 {
05600 G__letint(result7, 85, (long) TMVA::TNeuronInputAbs::Class());
05601 return(1 || funcname || hash || result7 || libp) ;
05602 }
05603
05604 static int G__G__TMVA4_160_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05605 {
05606 G__letint(result7, 67, (long) TMVA::TNeuronInputAbs::Class_Name());
05607 return(1 || funcname || hash || result7 || libp) ;
05608 }
05609
05610 static int G__G__TMVA4_160_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05611 {
05612 G__letint(result7, 115, (long) TMVA::TNeuronInputAbs::Class_Version());
05613 return(1 || funcname || hash || result7 || libp) ;
05614 }
05615
05616 static int G__G__TMVA4_160_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05617 {
05618 TMVA::TNeuronInputAbs::Dictionary();
05619 G__setnull(result7);
05620 return(1 || funcname || hash || result7 || libp) ;
05621 }
05622
05623 static int G__G__TMVA4_160_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05624 {
05625 ((TMVA::TNeuronInputAbs*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05626 G__setnull(result7);
05627 return(1 || funcname || hash || result7 || libp) ;
05628 }
05629
05630 static int G__G__TMVA4_160_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05631 {
05632 G__letint(result7, 67, (long) TMVA::TNeuronInputAbs::DeclFileName());
05633 return(1 || funcname || hash || result7 || libp) ;
05634 }
05635
05636 static int G__G__TMVA4_160_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05637 {
05638 G__letint(result7, 105, (long) TMVA::TNeuronInputAbs::ImplFileLine());
05639 return(1 || funcname || hash || result7 || libp) ;
05640 }
05641
05642 static int G__G__TMVA4_160_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05643 {
05644 G__letint(result7, 67, (long) TMVA::TNeuronInputAbs::ImplFileName());
05645 return(1 || funcname || hash || result7 || libp) ;
05646 }
05647
05648 static int G__G__TMVA4_160_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05649 {
05650 G__letint(result7, 105, (long) TMVA::TNeuronInputAbs::DeclFileLine());
05651 return(1 || funcname || hash || result7 || libp) ;
05652 }
05653
05654
05655 static int G__G__TMVA4_160_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05656
05657 {
05658 TMVA::TNeuronInputAbs* p;
05659 void* tmp = (void*) G__int(libp->para[0]);
05660 p = new TMVA::TNeuronInputAbs(*(TMVA::TNeuronInputAbs*) tmp);
05661 result7->obj.i = (long) p;
05662 result7->ref = (long) p;
05663 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs));
05664 return(1 || funcname || hash || result7 || libp) ;
05665 }
05666
05667
05668 typedef TMVA::TNeuronInputAbs G__TTMVAcLcLTNeuronInputAbs;
05669 static int G__G__TMVA4_160_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05670 {
05671 char* gvp = (char*) G__getgvp();
05672 long soff = G__getstructoffset();
05673 int n = G__getaryconstruct();
05674
05675
05676
05677
05678
05679 if (!soff) {
05680 return(1);
05681 }
05682 if (n) {
05683 if (gvp == (char*)G__PVOID) {
05684 delete[] (TMVA::TNeuronInputAbs*) soff;
05685 } else {
05686 G__setgvp((long) G__PVOID);
05687 for (int i = n - 1; i >= 0; --i) {
05688 ((TMVA::TNeuronInputAbs*) (soff+(sizeof(TMVA::TNeuronInputAbs)*i)))->~G__TTMVAcLcLTNeuronInputAbs();
05689 }
05690 G__setgvp((long)gvp);
05691 }
05692 } else {
05693 if (gvp == (char*)G__PVOID) {
05694 delete (TMVA::TNeuronInputAbs*) soff;
05695 } else {
05696 G__setgvp((long) G__PVOID);
05697 ((TMVA::TNeuronInputAbs*) (soff))->~G__TTMVAcLcLTNeuronInputAbs();
05698 G__setgvp((long)gvp);
05699 }
05700 }
05701 G__setnull(result7);
05702 return(1 || funcname || hash || result7 || libp) ;
05703 }
05704
05705
05706 static int G__G__TMVA4_160_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05707 {
05708 TMVA::TNeuronInputAbs* dest = (TMVA::TNeuronInputAbs*) G__getstructoffset();
05709 *dest = *(TMVA::TNeuronInputAbs*) libp->para[0].ref;
05710 const TMVA::TNeuronInputAbs& obj = *dest;
05711 result7->ref = (long) (&obj);
05712 result7->obj.i = (long) (&obj);
05713 return(1 || funcname || hash || result7 || libp) ;
05714 }
05715
05716
05717
05718 static int G__G__TMVA4_161_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05719 {
05720 TMVA::TNeuronInputChooser* p = NULL;
05721 char* gvp = (char*) G__getgvp();
05722 int n = G__getaryconstruct();
05723 if (n) {
05724 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05725 p = new TMVA::TNeuronInputChooser[n];
05726 } else {
05727 p = new((void*) gvp) TMVA::TNeuronInputChooser[n];
05728 }
05729 } else {
05730 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05731 p = new TMVA::TNeuronInputChooser;
05732 } else {
05733 p = new((void*) gvp) TMVA::TNeuronInputChooser;
05734 }
05735 }
05736 result7->obj.i = (long) p;
05737 result7->ref = (long) p;
05738 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser));
05739 return(1 || funcname || hash || result7 || libp) ;
05740 }
05741
05742 static int G__G__TMVA4_161_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05743 {
05744 G__letint(result7, 85, (long) ((const TMVA::TNeuronInputChooser*) G__getstructoffset())->CreateNeuronInput((TMVA::TNeuronInputChooser::ENeuronInputType) G__int(libp->para[0])));
05745 return(1 || funcname || hash || result7 || libp) ;
05746 }
05747
05748 static int G__G__TMVA4_161_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05749 {
05750 G__letint(result7, 85, (long) ((const TMVA::TNeuronInputChooser*) G__getstructoffset())->CreateNeuronInput(*((const TString*) G__int(libp->para[0]))));
05751 return(1 || funcname || hash || result7 || libp) ;
05752 }
05753
05754 static int G__G__TMVA4_161_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05755 {
05756 G__letint(result7, 85, (long) ((const TMVA::TNeuronInputChooser*) G__getstructoffset())->GetAllNeuronInputNames());
05757 return(1 || funcname || hash || result7 || libp) ;
05758 }
05759
05760 static int G__G__TMVA4_161_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05761 {
05762 G__letint(result7, 85, (long) TMVA::TNeuronInputChooser::Class());
05763 return(1 || funcname || hash || result7 || libp) ;
05764 }
05765
05766 static int G__G__TMVA4_161_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05767 {
05768 G__letint(result7, 67, (long) TMVA::TNeuronInputChooser::Class_Name());
05769 return(1 || funcname || hash || result7 || libp) ;
05770 }
05771
05772 static int G__G__TMVA4_161_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05773 {
05774 G__letint(result7, 115, (long) TMVA::TNeuronInputChooser::Class_Version());
05775 return(1 || funcname || hash || result7 || libp) ;
05776 }
05777
05778 static int G__G__TMVA4_161_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05779 {
05780 TMVA::TNeuronInputChooser::Dictionary();
05781 G__setnull(result7);
05782 return(1 || funcname || hash || result7 || libp) ;
05783 }
05784
05785 static int G__G__TMVA4_161_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05786 {
05787 G__letint(result7, 85, (long) ((const TMVA::TNeuronInputChooser*) G__getstructoffset())->IsA());
05788 return(1 || funcname || hash || result7 || libp) ;
05789 }
05790
05791 static int G__G__TMVA4_161_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05792 {
05793 ((TMVA::TNeuronInputChooser*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
05794 G__setnull(result7);
05795 return(1 || funcname || hash || result7 || libp) ;
05796 }
05797
05798 static int G__G__TMVA4_161_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05799 {
05800 ((TMVA::TNeuronInputChooser*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
05801 G__setnull(result7);
05802 return(1 || funcname || hash || result7 || libp) ;
05803 }
05804
05805 static int G__G__TMVA4_161_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05806 {
05807 ((TMVA::TNeuronInputChooser*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05808 G__setnull(result7);
05809 return(1 || funcname || hash || result7 || libp) ;
05810 }
05811
05812 static int G__G__TMVA4_161_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05813 {
05814 G__letint(result7, 67, (long) TMVA::TNeuronInputChooser::DeclFileName());
05815 return(1 || funcname || hash || result7 || libp) ;
05816 }
05817
05818 static int G__G__TMVA4_161_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05819 {
05820 G__letint(result7, 105, (long) TMVA::TNeuronInputChooser::ImplFileLine());
05821 return(1 || funcname || hash || result7 || libp) ;
05822 }
05823
05824 static int G__G__TMVA4_161_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05825 {
05826 G__letint(result7, 67, (long) TMVA::TNeuronInputChooser::ImplFileName());
05827 return(1 || funcname || hash || result7 || libp) ;
05828 }
05829
05830 static int G__G__TMVA4_161_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05831 {
05832 G__letint(result7, 105, (long) TMVA::TNeuronInputChooser::DeclFileLine());
05833 return(1 || funcname || hash || result7 || libp) ;
05834 }
05835
05836
05837 static int G__G__TMVA4_161_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05838
05839 {
05840 TMVA::TNeuronInputChooser* p;
05841 void* tmp = (void*) G__int(libp->para[0]);
05842 p = new TMVA::TNeuronInputChooser(*(TMVA::TNeuronInputChooser*) tmp);
05843 result7->obj.i = (long) p;
05844 result7->ref = (long) p;
05845 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser));
05846 return(1 || funcname || hash || result7 || libp) ;
05847 }
05848
05849
05850 typedef TMVA::TNeuronInputChooser G__TTMVAcLcLTNeuronInputChooser;
05851 static int G__G__TMVA4_161_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05852 {
05853 char* gvp = (char*) G__getgvp();
05854 long soff = G__getstructoffset();
05855 int n = G__getaryconstruct();
05856
05857
05858
05859
05860
05861 if (!soff) {
05862 return(1);
05863 }
05864 if (n) {
05865 if (gvp == (char*)G__PVOID) {
05866 delete[] (TMVA::TNeuronInputChooser*) soff;
05867 } else {
05868 G__setgvp((long) G__PVOID);
05869 for (int i = n - 1; i >= 0; --i) {
05870 ((TMVA::TNeuronInputChooser*) (soff+(sizeof(TMVA::TNeuronInputChooser)*i)))->~G__TTMVAcLcLTNeuronInputChooser();
05871 }
05872 G__setgvp((long)gvp);
05873 }
05874 } else {
05875 if (gvp == (char*)G__PVOID) {
05876 delete (TMVA::TNeuronInputChooser*) soff;
05877 } else {
05878 G__setgvp((long) G__PVOID);
05879 ((TMVA::TNeuronInputChooser*) (soff))->~G__TTMVAcLcLTNeuronInputChooser();
05880 G__setgvp((long)gvp);
05881 }
05882 }
05883 G__setnull(result7);
05884 return(1 || funcname || hash || result7 || libp) ;
05885 }
05886
05887
05888 static int G__G__TMVA4_161_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05889 {
05890 TMVA::TNeuronInputChooser* dest = (TMVA::TNeuronInputChooser*) G__getstructoffset();
05891 *dest = *(TMVA::TNeuronInputChooser*) libp->para[0].ref;
05892 const TMVA::TNeuronInputChooser& obj = *dest;
05893 result7->ref = (long) (&obj);
05894 result7->obj.i = (long) (&obj);
05895 return(1 || funcname || hash || result7 || libp) ;
05896 }
05897
05898
05899
05900 static int G__G__TMVA4_164_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05901 {
05902 TMVA::Ranking* p = NULL;
05903 char* gvp = (char*) G__getgvp();
05904 int n = G__getaryconstruct();
05905 if (n) {
05906 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05907 p = new TMVA::Ranking[n];
05908 } else {
05909 p = new((void*) gvp) TMVA::Ranking[n];
05910 }
05911 } else {
05912 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05913 p = new TMVA::Ranking;
05914 } else {
05915 p = new((void*) gvp) TMVA::Ranking;
05916 }
05917 }
05918 result7->obj.i = (long) p;
05919 result7->ref = (long) p;
05920 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking));
05921 return(1 || funcname || hash || result7 || libp) ;
05922 }
05923
05924 static int G__G__TMVA4_164_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05925 {
05926 TMVA::Ranking* p = NULL;
05927 char* gvp = (char*) G__getgvp();
05928
05929 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05930 p = new TMVA::Ranking(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
05931 } else {
05932 p = new((void*) gvp) TMVA::Ranking(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
05933 }
05934 result7->obj.i = (long) p;
05935 result7->ref = (long) p;
05936 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking));
05937 return(1 || funcname || hash || result7 || libp) ;
05938 }
05939
05940 static int G__G__TMVA4_164_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05941 {
05942 ((TMVA::Ranking*) G__getstructoffset())->AddRank(*(TMVA::Rank*) libp->para[0].ref);
05943 G__setnull(result7);
05944 return(1 || funcname || hash || result7 || libp) ;
05945 }
05946
05947 static int G__G__TMVA4_164_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05948 {
05949 ((const TMVA::Ranking*) G__getstructoffset())->Print();
05950 G__setnull(result7);
05951 return(1 || funcname || hash || result7 || libp) ;
05952 }
05953
05954 static int G__G__TMVA4_164_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05955 {
05956 ((TMVA::Ranking*) G__getstructoffset())->SetContext(*(TString*) libp->para[0].ref);
05957 G__setnull(result7);
05958 return(1 || funcname || hash || result7 || libp) ;
05959 }
05960
05961 static int G__G__TMVA4_164_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05962 {
05963 ((TMVA::Ranking*) G__getstructoffset())->SetDiscrName(*(TString*) libp->para[0].ref);
05964 G__setnull(result7);
05965 return(1 || funcname || hash || result7 || libp) ;
05966 }
05967
05968 static int G__G__TMVA4_164_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05969 {
05970 G__letint(result7, 85, (long) TMVA::Ranking::Class());
05971 return(1 || funcname || hash || result7 || libp) ;
05972 }
05973
05974 static int G__G__TMVA4_164_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05975 {
05976 G__letint(result7, 67, (long) TMVA::Ranking::Class_Name());
05977 return(1 || funcname || hash || result7 || libp) ;
05978 }
05979
05980 static int G__G__TMVA4_164_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05981 {
05982 G__letint(result7, 115, (long) TMVA::Ranking::Class_Version());
05983 return(1 || funcname || hash || result7 || libp) ;
05984 }
05985
05986 static int G__G__TMVA4_164_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05987 {
05988 TMVA::Ranking::Dictionary();
05989 G__setnull(result7);
05990 return(1 || funcname || hash || result7 || libp) ;
05991 }
05992
05993 static int G__G__TMVA4_164_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05994 {
05995 G__letint(result7, 85, (long) ((const TMVA::Ranking*) G__getstructoffset())->IsA());
05996 return(1 || funcname || hash || result7 || libp) ;
05997 }
05998
05999 static int G__G__TMVA4_164_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06000 {
06001 ((TMVA::Ranking*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
06002 G__setnull(result7);
06003 return(1 || funcname || hash || result7 || libp) ;
06004 }
06005
06006 static int G__G__TMVA4_164_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06007 {
06008 ((TMVA::Ranking*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
06009 G__setnull(result7);
06010 return(1 || funcname || hash || result7 || libp) ;
06011 }
06012
06013 static int G__G__TMVA4_164_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06014 {
06015 ((TMVA::Ranking*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06016 G__setnull(result7);
06017 return(1 || funcname || hash || result7 || libp) ;
06018 }
06019
06020 static int G__G__TMVA4_164_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06021 {
06022 G__letint(result7, 67, (long) TMVA::Ranking::DeclFileName());
06023 return(1 || funcname || hash || result7 || libp) ;
06024 }
06025
06026 static int G__G__TMVA4_164_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06027 {
06028 G__letint(result7, 105, (long) TMVA::Ranking::ImplFileLine());
06029 return(1 || funcname || hash || result7 || libp) ;
06030 }
06031
06032 static int G__G__TMVA4_164_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06033 {
06034 G__letint(result7, 67, (long) TMVA::Ranking::ImplFileName());
06035 return(1 || funcname || hash || result7 || libp) ;
06036 }
06037
06038 static int G__G__TMVA4_164_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06039 {
06040 G__letint(result7, 105, (long) TMVA::Ranking::DeclFileLine());
06041 return(1 || funcname || hash || result7 || libp) ;
06042 }
06043
06044
06045 static int G__G__TMVA4_164_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06046
06047 {
06048 TMVA::Ranking* p;
06049 void* tmp = (void*) G__int(libp->para[0]);
06050 p = new TMVA::Ranking(*(TMVA::Ranking*) tmp);
06051 result7->obj.i = (long) p;
06052 result7->ref = (long) p;
06053 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking));
06054 return(1 || funcname || hash || result7 || libp) ;
06055 }
06056
06057
06058 typedef TMVA::Ranking G__TTMVAcLcLRanking;
06059 static int G__G__TMVA4_164_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06060 {
06061 char* gvp = (char*) G__getgvp();
06062 long soff = G__getstructoffset();
06063 int n = G__getaryconstruct();
06064
06065
06066
06067
06068
06069 if (!soff) {
06070 return(1);
06071 }
06072 if (n) {
06073 if (gvp == (char*)G__PVOID) {
06074 delete[] (TMVA::Ranking*) soff;
06075 } else {
06076 G__setgvp((long) G__PVOID);
06077 for (int i = n - 1; i >= 0; --i) {
06078 ((TMVA::Ranking*) (soff+(sizeof(TMVA::Ranking)*i)))->~G__TTMVAcLcLRanking();
06079 }
06080 G__setgvp((long)gvp);
06081 }
06082 } else {
06083 if (gvp == (char*)G__PVOID) {
06084 delete (TMVA::Ranking*) soff;
06085 } else {
06086 G__setgvp((long) G__PVOID);
06087 ((TMVA::Ranking*) (soff))->~G__TTMVAcLcLRanking();
06088 G__setgvp((long)gvp);
06089 }
06090 }
06091 G__setnull(result7);
06092 return(1 || funcname || hash || result7 || libp) ;
06093 }
06094
06095
06096 static int G__G__TMVA4_164_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06097 {
06098 TMVA::Ranking* dest = (TMVA::Ranking*) G__getstructoffset();
06099 *dest = *(TMVA::Ranking*) libp->para[0].ref;
06100 const TMVA::Ranking& obj = *dest;
06101 result7->ref = (long) (&obj);
06102 result7->obj.i = (long) (&obj);
06103 return(1 || funcname || hash || result7 || libp) ;
06104 }
06105
06106
06107
06108 static int G__G__TMVA4_301_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06109 {
06110 TMVA::RuleFit* p = NULL;
06111 char* gvp = (char*) G__getgvp();
06112
06113 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06114 p = new TMVA::RuleFit((TMVA::MethodBase*) G__int(libp->para[0]));
06115 } else {
06116 p = new((void*) gvp) TMVA::RuleFit((TMVA::MethodBase*) G__int(libp->para[0]));
06117 }
06118 result7->obj.i = (long) p;
06119 result7->ref = (long) p;
06120 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFit));
06121 return(1 || funcname || hash || result7 || libp) ;
06122 }
06123
06124 static int G__G__TMVA4_301_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06125 {
06126 TMVA::RuleFit* p = NULL;
06127 char* gvp = (char*) G__getgvp();
06128 int n = G__getaryconstruct();
06129 if (n) {
06130 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06131 p = new TMVA::RuleFit[n];
06132 } else {
06133 p = new((void*) gvp) TMVA::RuleFit[n];
06134 }
06135 } else {
06136 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06137 p = new TMVA::RuleFit;
06138 } else {
06139 p = new((void*) gvp) TMVA::RuleFit;
06140 }
06141 }
06142 result7->obj.i = (long) p;
06143 result7->ref = (long) p;
06144 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFit));
06145 return(1 || funcname || hash || result7 || libp) ;
06146 }
06147
06148 static int G__G__TMVA4_301_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06149 {
06150 ((TMVA::RuleFit*) G__getstructoffset())->InitNEveEff();
06151 G__setnull(result7);
06152 return(1 || funcname || hash || result7 || libp) ;
06153 }
06154
06155 static int G__G__TMVA4_301_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06156 {
06157 ((TMVA::RuleFit*) G__getstructoffset())->InitPtrs((TMVA::MethodBase*) G__int(libp->para[0]));
06158 G__setnull(result7);
06159 return(1 || funcname || hash || result7 || libp) ;
06160 }
06161
06162 static int G__G__TMVA4_301_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06163 {
06164 ((TMVA::RuleFit*) G__getstructoffset())->Initialize((TMVA::MethodBase*) G__int(libp->para[0]));
06165 G__setnull(result7);
06166 return(1 || funcname || hash || result7 || libp) ;
06167 }
06168
06169 static int G__G__TMVA4_301_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06170 {
06171 ((TMVA::RuleFit*) G__getstructoffset())->SetMsgType((TMVA::EMsgType) G__int(libp->para[0]));
06172 G__setnull(result7);
06173 return(1 || funcname || hash || result7 || libp) ;
06174 }
06175
06176 static int G__G__TMVA4_301_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06177 {
06178 ((TMVA::RuleFit*) G__getstructoffset())->SetTrainingEvents(*(vector<TMVA::Event*>*) libp->para[0].ref);
06179 G__setnull(result7);
06180 return(1 || funcname || hash || result7 || libp) ;
06181 }
06182
06183 static int G__G__TMVA4_301_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06184 {
06185 ((TMVA::RuleFit*) G__getstructoffset())->ReshuffleEvents();
06186 G__setnull(result7);
06187 return(1 || funcname || hash || result7 || libp) ;
06188 }
06189
06190 static int G__G__TMVA4_301_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06191 {
06192 ((TMVA::RuleFit*) G__getstructoffset())->SetMethodBase((TMVA::MethodBase*) G__int(libp->para[0]));
06193 G__setnull(result7);
06194 return(1 || funcname || hash || result7 || libp) ;
06195 }
06196
06197 static int G__G__TMVA4_301_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06198 {
06199 ((TMVA::RuleFit*) G__getstructoffset())->MakeForest();
06200 G__setnull(result7);
06201 return(1 || funcname || hash || result7 || libp) ;
06202 }
06203
06204 static int G__G__TMVA4_301_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06205 {
06206 ((TMVA::RuleFit*) G__getstructoffset())->BuildTree((TMVA::DecisionTree*) G__int(libp->para[0]));
06207 G__setnull(result7);
06208 return(1 || funcname || hash || result7 || libp) ;
06209 }
06210
06211 static int G__G__TMVA4_301_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06212 {
06213 ((TMVA::RuleFit*) G__getstructoffset())->SaveEventWeights();
06214 G__setnull(result7);
06215 return(1 || funcname || hash || result7 || libp) ;
06216 }
06217
06218 static int G__G__TMVA4_301_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06219 {
06220 ((TMVA::RuleFit*) G__getstructoffset())->RestoreEventWeights();
06221 G__setnull(result7);
06222 return(1 || funcname || hash || result7 || libp) ;
06223 }
06224
06225 static int G__G__TMVA4_301_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06226 {
06227 ((TMVA::RuleFit*) G__getstructoffset())->Boost((TMVA::DecisionTree*) G__int(libp->para[0]));
06228 G__setnull(result7);
06229 return(1 || funcname || hash || result7 || libp) ;
06230 }
06231
06232 static int G__G__TMVA4_301_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06233 {
06234 ((TMVA::RuleFit*) G__getstructoffset())->ForestStatistics();
06235 G__setnull(result7);
06236 return(1 || funcname || hash || result7 || libp) ;
06237 }
06238
06239 static int G__G__TMVA4_301_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06240 {
06241 G__letdouble(result7, 100, (double) ((TMVA::RuleFit*) G__getstructoffset())->EvalEvent(*(TMVA::Event*) libp->para[0].ref));
06242 return(1 || funcname || hash || result7 || libp) ;
06243 }
06244
06245 static int G__G__TMVA4_301_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06246 {
06247 switch (libp->paran) {
06248 case 2:
06249 G__letdouble(result7, 100, (double) ((TMVA::RuleFit*) G__getstructoffset())->CalcWeightSum((vector<TMVA::Event*>*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
06250 break;
06251 case 1:
06252 G__letdouble(result7, 100, (double) ((TMVA::RuleFit*) G__getstructoffset())->CalcWeightSum((vector<TMVA::Event*>*) G__int(libp->para[0])));
06253 break;
06254 }
06255 return(1 || funcname || hash || result7 || libp) ;
06256 }
06257
06258 static int G__G__TMVA4_301_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06259 {
06260 ((TMVA::RuleFit*) G__getstructoffset())->FitCoefficients();
06261 G__setnull(result7);
06262 return(1 || funcname || hash || result7 || libp) ;
06263 }
06264
06265 static int G__G__TMVA4_301_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06266 {
06267 ((TMVA::RuleFit*) G__getstructoffset())->CalcImportance();
06268 G__setnull(result7);
06269 return(1 || funcname || hash || result7 || libp) ;
06270 }
06271
06272 static int G__G__TMVA4_301_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06273 {
06274 ((TMVA::RuleFit*) G__getstructoffset())->SetModelLinear();
06275 G__setnull(result7);
06276 return(1 || funcname || hash || result7 || libp) ;
06277 }
06278
06279 static int G__G__TMVA4_301_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06280 {
06281 ((TMVA::RuleFit*) G__getstructoffset())->SetModelRules();
06282 G__setnull(result7);
06283 return(1 || funcname || hash || result7 || libp) ;
06284 }
06285
06286 static int G__G__TMVA4_301_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06287 {
06288 ((TMVA::RuleFit*) G__getstructoffset())->SetModelFull();
06289 G__setnull(result7);
06290 return(1 || funcname || hash || result7 || libp) ;
06291 }
06292
06293 static int G__G__TMVA4_301_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06294 {
06295 switch (libp->paran) {
06296 case 1:
06297 ((TMVA::RuleFit*) G__getstructoffset())->SetImportanceCut((Double_t) G__double(libp->para[0]));
06298 G__setnull(result7);
06299 break;
06300 case 0:
06301 ((TMVA::RuleFit*) G__getstructoffset())->SetImportanceCut();
06302 G__setnull(result7);
06303 break;
06304 }
06305 return(1 || funcname || hash || result7 || libp) ;
06306 }
06307
06308 static int G__G__TMVA4_301_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06309 {
06310 ((TMVA::RuleFit*) G__getstructoffset())->SetRuleMinDist((Double_t) G__double(libp->para[0]));
06311 G__setnull(result7);
06312 return(1 || funcname || hash || result7 || libp) ;
06313 }
06314
06315 static int G__G__TMVA4_301_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06316 {
06317 switch (libp->paran) {
06318 case 1:
06319 ((TMVA::RuleFit*) G__getstructoffset())->SetGDTau((Double_t) G__double(libp->para[0]));
06320 G__setnull(result7);
06321 break;
06322 case 0:
06323 ((TMVA::RuleFit*) G__getstructoffset())->SetGDTau();
06324 G__setnull(result7);
06325 break;
06326 }
06327 return(1 || funcname || hash || result7 || libp) ;
06328 }
06329
06330 static int G__G__TMVA4_301_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06331 {
06332 switch (libp->paran) {
06333 case 1:
06334 ((TMVA::RuleFit*) G__getstructoffset())->SetGDPathStep((Double_t) G__double(libp->para[0]));
06335 G__setnull(result7);
06336 break;
06337 case 0:
06338 ((TMVA::RuleFit*) G__getstructoffset())->SetGDPathStep();
06339 G__setnull(result7);
06340 break;
06341 }
06342 return(1 || funcname || hash || result7 || libp) ;
06343 }
06344
06345 static int G__G__TMVA4_301_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06346 {
06347 switch (libp->paran) {
06348 case 1:
06349 ((TMVA::RuleFit*) G__getstructoffset())->SetGDNPathSteps((Int_t) G__int(libp->para[0]));
06350 G__setnull(result7);
06351 break;
06352 case 0:
06353 ((TMVA::RuleFit*) G__getstructoffset())->SetGDNPathSteps();
06354 G__setnull(result7);
06355 break;
06356 }
06357 return(1 || funcname || hash || result7 || libp) ;
06358 }
06359
06360 static int G__G__TMVA4_301_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06361 {
06362 ((TMVA::RuleFit*) G__getstructoffset())->SetVisHistsUseImp((Bool_t) G__int(libp->para[0]));
06363 G__setnull(result7);
06364 return(1 || funcname || hash || result7 || libp) ;
06365 }
06366
06367 static int G__G__TMVA4_301_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06368 {
06369 ((TMVA::RuleFit*) G__getstructoffset())->UseImportanceVisHists();
06370 G__setnull(result7);
06371 return(1 || funcname || hash || result7 || libp) ;
06372 }
06373
06374 static int G__G__TMVA4_301_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06375 {
06376 ((TMVA::RuleFit*) G__getstructoffset())->UseCoefficientsVisHists();
06377 G__setnull(result7);
06378 return(1 || funcname || hash || result7 || libp) ;
06379 }
06380
06381 static int G__G__TMVA4_301_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06382 {
06383 ((TMVA::RuleFit*) G__getstructoffset())->MakeVisHists();
06384 G__setnull(result7);
06385 return(1 || funcname || hash || result7 || libp) ;
06386 }
06387
06388 static int G__G__TMVA4_301_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06389 {
06390 ((TMVA::RuleFit*) G__getstructoffset())->FillVisHistCut((TMVA::Rule*) G__int(libp->para[0]), *(vector<TH2F*>*) libp->para[1].ref);
06391 G__setnull(result7);
06392 return(1 || funcname || hash || result7 || libp) ;
06393 }
06394
06395 static int G__G__TMVA4_301_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06396 {
06397 ((TMVA::RuleFit*) G__getstructoffset())->FillVisHistCorr((TMVA::Rule*) G__int(libp->para[0]), *(vector<TH2F*>*) libp->para[1].ref);
06398 G__setnull(result7);
06399 return(1 || funcname || hash || result7 || libp) ;
06400 }
06401
06402 static int G__G__TMVA4_301_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06403 {
06404 ((TMVA::RuleFit*) G__getstructoffset())->FillCut((TH2F*) G__int(libp->para[0]), (TMVA::Rule*) G__int(libp->para[1])
06405 , (Int_t) G__int(libp->para[2]));
06406 G__setnull(result7);
06407 return(1 || funcname || hash || result7 || libp) ;
06408 }
06409
06410 static int G__G__TMVA4_301_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06411 {
06412 ((TMVA::RuleFit*) G__getstructoffset())->FillLin((TH2F*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06413 G__setnull(result7);
06414 return(1 || funcname || hash || result7 || libp) ;
06415 }
06416
06417 static int G__G__TMVA4_301_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06418 {
06419 ((TMVA::RuleFit*) G__getstructoffset())->FillCorr((TH2F*) G__int(libp->para[0]), (TMVA::Rule*) G__int(libp->para[1])
06420 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
06421 G__setnull(result7);
06422 return(1 || funcname || hash || result7 || libp) ;
06423 }
06424
06425 static int G__G__TMVA4_301_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06426 {
06427 ((TMVA::RuleFit*) G__getstructoffset())->NormVisHists(*(vector<TH2F*>*) libp->para[0].ref);
06428 G__setnull(result7);
06429 return(1 || funcname || hash || result7 || libp) ;
06430 }
06431
06432 static int G__G__TMVA4_301_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06433 {
06434 ((TMVA::RuleFit*) G__getstructoffset())->MakeDebugHists();
06435 G__setnull(result7);
06436 return(1 || funcname || hash || result7 || libp) ;
06437 }
06438
06439 static int G__G__TMVA4_301_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06440 {
06441 G__letint(result7, 103, (long) ((TMVA::RuleFit*) G__getstructoffset())->GetCorrVars(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
06442 , *(TString*) libp->para[2].ref));
06443 return(1 || funcname || hash || result7 || libp) ;
06444 }
06445
06446 static int G__G__TMVA4_301_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06447 {
06448 G__letint(result7, 104, (long) ((const TMVA::RuleFit*) G__getstructoffset())->GetNTreeSample());
06449 return(1 || funcname || hash || result7 || libp) ;
06450 }
06451
06452 static int G__G__TMVA4_301_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06453 {
06454 G__letdouble(result7, 100, (double) ((const TMVA::RuleFit*) G__getstructoffset())->GetNEveEff());
06455 return(1 || funcname || hash || result7 || libp) ;
06456 }
06457
06458 static int G__G__TMVA4_301_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06459 {
06460 G__letint(result7, 85, (long) ((const TMVA::RuleFit*) G__getstructoffset())->GetTrainingEvent((UInt_t) G__int(libp->para[0])));
06461 return(1 || funcname || hash || result7 || libp) ;
06462 }
06463
06464 static int G__G__TMVA4_301_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06465 {
06466 G__letdouble(result7, 100, (double) ((const TMVA::RuleFit*) G__getstructoffset())->GetTrainingEventWeight((UInt_t) G__int(libp->para[0])));
06467 return(1 || funcname || hash || result7 || libp) ;
06468 }
06469
06470 static int G__G__TMVA4_301_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06471 {
06472 {
06473 const vector<TMVA::Event*>& obj = ((const TMVA::RuleFit*) G__getstructoffset())->GetTrainingEvents();
06474 result7->ref = (long) (&obj);
06475 result7->obj.i = (long) (&obj);
06476 }
06477 return(1 || funcname || hash || result7 || libp) ;
06478 }
06479
06480 static int G__G__TMVA4_301_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06481 {
06482 ((TMVA::RuleFit*) G__getstructoffset())->GetRndmSampleEvents(*(vector<const TMVA::Event*>*) libp->para[0].ref, (UInt_t) G__int(libp->para[1]));
06483 G__setnull(result7);
06484 return(1 || funcname || hash || result7 || libp) ;
06485 }
06486
06487 static int G__G__TMVA4_301_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06488 {
06489 {
06490 const vector<const TMVA::DecisionTree*>& obj = ((const TMVA::RuleFit*) G__getstructoffset())->GetForest();
06491 result7->ref = (long) (&obj);
06492 result7->obj.i = (long) (&obj);
06493 }
06494 return(1 || funcname || hash || result7 || libp) ;
06495 }
06496
06497 static int G__G__TMVA4_301_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06498 {
06499 {
06500 const TMVA::RuleEnsemble& obj = ((const TMVA::RuleFit*) G__getstructoffset())->GetRuleEnsemble();
06501 result7->ref = (long) (&obj);
06502 result7->obj.i = (long) (&obj);
06503 }
06504 return(1 || funcname || hash || result7 || libp) ;
06505 }
06506
06507 static int G__G__TMVA4_301_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06508 {
06509 G__letint(result7, 85, (long) ((TMVA::RuleFit*) G__getstructoffset())->GetRuleEnsemblePtr());
06510 return(1 || funcname || hash || result7 || libp) ;
06511 }
06512
06513 static int G__G__TMVA4_301_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06514 {
06515 {
06516 const TMVA::RuleFitParams& obj = ((const TMVA::RuleFit*) G__getstructoffset())->GetRuleFitParams();
06517 result7->ref = (long) (&obj);
06518 result7->obj.i = (long) (&obj);
06519 }
06520 return(1 || funcname || hash || result7 || libp) ;
06521 }
06522
06523 static int G__G__TMVA4_301_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06524 {
06525 G__letint(result7, 85, (long) ((TMVA::RuleFit*) G__getstructoffset())->GetRuleFitParamsPtr());
06526 return(1 || funcname || hash || result7 || libp) ;
06527 }
06528
06529 static int G__G__TMVA4_301_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06530 {
06531 G__letint(result7, 85, (long) ((const TMVA::RuleFit*) G__getstructoffset())->GetMethodRuleFit());
06532 return(1 || funcname || hash || result7 || libp) ;
06533 }
06534
06535 static int G__G__TMVA4_301_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06536 {
06537 G__letint(result7, 85, (long) ((const TMVA::RuleFit*) G__getstructoffset())->GetMethodBase());
06538 return(1 || funcname || hash || result7 || libp) ;
06539 }
06540
06541 static int G__G__TMVA4_301_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06542 {
06543 G__letint(result7, 85, (long) TMVA::RuleFit::Class());
06544 return(1 || funcname || hash || result7 || libp) ;
06545 }
06546
06547 static int G__G__TMVA4_301_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06548 {
06549 G__letint(result7, 67, (long) TMVA::RuleFit::Class_Name());
06550 return(1 || funcname || hash || result7 || libp) ;
06551 }
06552
06553 static int G__G__TMVA4_301_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06554 {
06555 G__letint(result7, 115, (long) TMVA::RuleFit::Class_Version());
06556 return(1 || funcname || hash || result7 || libp) ;
06557 }
06558
06559 static int G__G__TMVA4_301_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06560 {
06561 TMVA::RuleFit::Dictionary();
06562 G__setnull(result7);
06563 return(1 || funcname || hash || result7 || libp) ;
06564 }
06565
06566 static int G__G__TMVA4_301_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06567 {
06568 G__letint(result7, 85, (long) ((const TMVA::RuleFit*) G__getstructoffset())->IsA());
06569 return(1 || funcname || hash || result7 || libp) ;
06570 }
06571
06572 static int G__G__TMVA4_301_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06573 {
06574 ((TMVA::RuleFit*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
06575 G__setnull(result7);
06576 return(1 || funcname || hash || result7 || libp) ;
06577 }
06578
06579 static int G__G__TMVA4_301_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06580 {
06581 ((TMVA::RuleFit*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
06582 G__setnull(result7);
06583 return(1 || funcname || hash || result7 || libp) ;
06584 }
06585
06586 static int G__G__TMVA4_301_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06587 {
06588 ((TMVA::RuleFit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06589 G__setnull(result7);
06590 return(1 || funcname || hash || result7 || libp) ;
06591 }
06592
06593 static int G__G__TMVA4_301_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06594 {
06595 G__letint(result7, 67, (long) TMVA::RuleFit::DeclFileName());
06596 return(1 || funcname || hash || result7 || libp) ;
06597 }
06598
06599 static int G__G__TMVA4_301_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06600 {
06601 G__letint(result7, 105, (long) TMVA::RuleFit::ImplFileLine());
06602 return(1 || funcname || hash || result7 || libp) ;
06603 }
06604
06605 static int G__G__TMVA4_301_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06606 {
06607 G__letint(result7, 67, (long) TMVA::RuleFit::ImplFileName());
06608 return(1 || funcname || hash || result7 || libp) ;
06609 }
06610
06611 static int G__G__TMVA4_301_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06612 {
06613 G__letint(result7, 105, (long) TMVA::RuleFit::DeclFileLine());
06614 return(1 || funcname || hash || result7 || libp) ;
06615 }
06616
06617
06618 typedef TMVA::RuleFit G__TTMVAcLcLRuleFit;
06619 static int G__G__TMVA4_301_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06620 {
06621 char* gvp = (char*) G__getgvp();
06622 long soff = G__getstructoffset();
06623 int n = G__getaryconstruct();
06624
06625
06626
06627
06628
06629 if (!soff) {
06630 return(1);
06631 }
06632 if (n) {
06633 if (gvp == (char*)G__PVOID) {
06634 delete[] (TMVA::RuleFit*) soff;
06635 } else {
06636 G__setgvp((long) G__PVOID);
06637 for (int i = n - 1; i >= 0; --i) {
06638 ((TMVA::RuleFit*) (soff+(sizeof(TMVA::RuleFit)*i)))->~G__TTMVAcLcLRuleFit();
06639 }
06640 G__setgvp((long)gvp);
06641 }
06642 } else {
06643 if (gvp == (char*)G__PVOID) {
06644 delete (TMVA::RuleFit*) soff;
06645 } else {
06646 G__setgvp((long) G__PVOID);
06647 ((TMVA::RuleFit*) (soff))->~G__TTMVAcLcLRuleFit();
06648 G__setgvp((long)gvp);
06649 }
06650 }
06651 G__setnull(result7);
06652 return(1 || funcname || hash || result7 || libp) ;
06653 }
06654
06655
06656
06657 static int G__G__TMVA4_343_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06658 {
06659 TMVA::RuleFitAPI* p = NULL;
06660 char* gvp = (char*) G__getgvp();
06661
06662 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06663 p = new TMVA::RuleFitAPI(
06664 (TMVA::MethodRuleFit*) G__int(libp->para[0]), (TMVA::RuleFit*) G__int(libp->para[1])
06665 , (TMVA::EMsgType) G__int(libp->para[2]));
06666 } else {
06667 p = new((void*) gvp) TMVA::RuleFitAPI(
06668 (TMVA::MethodRuleFit*) G__int(libp->para[0]), (TMVA::RuleFit*) G__int(libp->para[1])
06669 , (TMVA::EMsgType) G__int(libp->para[2]));
06670 }
06671 result7->obj.i = (long) p;
06672 result7->ref = (long) p;
06673 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPI));
06674 return(1 || funcname || hash || result7 || libp) ;
06675 }
06676
06677 static int G__G__TMVA4_343_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06678 {
06679 ((TMVA::RuleFitAPI*) G__getstructoffset())->WelcomeMessage();
06680 G__setnull(result7);
06681 return(1 || funcname || hash || result7 || libp) ;
06682 }
06683
06684 static int G__G__TMVA4_343_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06685 {
06686 ((TMVA::RuleFitAPI*) G__getstructoffset())->HowtoSetupRF();
06687 G__setnull(result7);
06688 return(1 || funcname || hash || result7 || libp) ;
06689 }
06690
06691 static int G__G__TMVA4_343_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06692 {
06693 ((TMVA::RuleFitAPI*) G__getstructoffset())->SetRFWorkDir((const char*) G__int(libp->para[0]));
06694 G__setnull(result7);
06695 return(1 || funcname || hash || result7 || libp) ;
06696 }
06697
06698 static int G__G__TMVA4_343_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06699 {
06700 ((TMVA::RuleFitAPI*) G__getstructoffset())->CheckRFWorkDir();
06701 G__setnull(result7);
06702 return(1 || funcname || hash || result7 || libp) ;
06703 }
06704
06705 static int G__G__TMVA4_343_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06706 {
06707 ((TMVA::RuleFitAPI*) G__getstructoffset())->TrainRuleFit();
06708 G__setnull(result7);
06709 return(1 || funcname || hash || result7 || libp) ;
06710 }
06711
06712 static int G__G__TMVA4_343_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06713 {
06714 ((TMVA::RuleFitAPI*) G__getstructoffset())->TestRuleFit();
06715 G__setnull(result7);
06716 return(1 || funcname || hash || result7 || libp) ;
06717 }
06718
06719 static int G__G__TMVA4_343_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06720 {
06721 ((TMVA::RuleFitAPI*) G__getstructoffset())->VarImp();
06722 G__setnull(result7);
06723 return(1 || funcname || hash || result7 || libp) ;
06724 }
06725
06726 static int G__G__TMVA4_343_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06727 {
06728 G__letint(result7, 103, (long) ((TMVA::RuleFitAPI*) G__getstructoffset())->ReadModelSum());
06729 return(1 || funcname || hash || result7 || libp) ;
06730 }
06731
06732 static int G__G__TMVA4_343_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06733 {
06734 {
06735 const TString* pobj;
06736 const TString xobj = ((const TMVA::RuleFitAPI*) G__getstructoffset())->GetRFWorkDir();
06737 pobj = new TString(xobj);
06738 result7->obj.i = (long) ((void*) pobj);
06739 result7->ref = result7->obj.i;
06740 G__store_tempobject(*result7);
06741 }
06742 return(1 || funcname || hash || result7 || libp) ;
06743 }
06744
06745 static int G__G__TMVA4_343_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06746 {
06747 G__letint(result7, 85, (long) TMVA::RuleFitAPI::Class());
06748 return(1 || funcname || hash || result7 || libp) ;
06749 }
06750
06751 static int G__G__TMVA4_343_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06752 {
06753 G__letint(result7, 67, (long) TMVA::RuleFitAPI::Class_Name());
06754 return(1 || funcname || hash || result7 || libp) ;
06755 }
06756
06757 static int G__G__TMVA4_343_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06758 {
06759 G__letint(result7, 115, (long) TMVA::RuleFitAPI::Class_Version());
06760 return(1 || funcname || hash || result7 || libp) ;
06761 }
06762
06763 static int G__G__TMVA4_343_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06764 {
06765 TMVA::RuleFitAPI::Dictionary();
06766 G__setnull(result7);
06767 return(1 || funcname || hash || result7 || libp) ;
06768 }
06769
06770 static int G__G__TMVA4_343_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06771 {
06772 G__letint(result7, 85, (long) ((const TMVA::RuleFitAPI*) G__getstructoffset())->IsA());
06773 return(1 || funcname || hash || result7 || libp) ;
06774 }
06775
06776 static int G__G__TMVA4_343_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06777 {
06778 ((TMVA::RuleFitAPI*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
06779 G__setnull(result7);
06780 return(1 || funcname || hash || result7 || libp) ;
06781 }
06782
06783 static int G__G__TMVA4_343_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06784 {
06785 ((TMVA::RuleFitAPI*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
06786 G__setnull(result7);
06787 return(1 || funcname || hash || result7 || libp) ;
06788 }
06789
06790 static int G__G__TMVA4_343_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06791 {
06792 ((TMVA::RuleFitAPI*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06793 G__setnull(result7);
06794 return(1 || funcname || hash || result7 || libp) ;
06795 }
06796
06797 static int G__G__TMVA4_343_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06798 {
06799 G__letint(result7, 67, (long) TMVA::RuleFitAPI::DeclFileName());
06800 return(1 || funcname || hash || result7 || libp) ;
06801 }
06802
06803 static int G__G__TMVA4_343_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06804 {
06805 G__letint(result7, 105, (long) TMVA::RuleFitAPI::ImplFileLine());
06806 return(1 || funcname || hash || result7 || libp) ;
06807 }
06808
06809 static int G__G__TMVA4_343_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06810 {
06811 G__letint(result7, 67, (long) TMVA::RuleFitAPI::ImplFileName());
06812 return(1 || funcname || hash || result7 || libp) ;
06813 }
06814
06815 static int G__G__TMVA4_343_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06816 {
06817 G__letint(result7, 105, (long) TMVA::RuleFitAPI::DeclFileLine());
06818 return(1 || funcname || hash || result7 || libp) ;
06819 }
06820
06821
06822 typedef TMVA::RuleFitAPI G__TTMVAcLcLRuleFitAPI;
06823 static int G__G__TMVA4_343_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06824 {
06825 char* gvp = (char*) G__getgvp();
06826 long soff = G__getstructoffset();
06827 int n = G__getaryconstruct();
06828
06829
06830
06831
06832
06833 if (!soff) {
06834 return(1);
06835 }
06836 if (n) {
06837 if (gvp == (char*)G__PVOID) {
06838 delete[] (TMVA::RuleFitAPI*) soff;
06839 } else {
06840 G__setgvp((long) G__PVOID);
06841 for (int i = n - 1; i >= 0; --i) {
06842 ((TMVA::RuleFitAPI*) (soff+(sizeof(TMVA::RuleFitAPI)*i)))->~G__TTMVAcLcLRuleFitAPI();
06843 }
06844 G__setgvp((long)gvp);
06845 }
06846 } else {
06847 if (gvp == (char*)G__PVOID) {
06848 delete (TMVA::RuleFitAPI*) soff;
06849 } else {
06850 G__setgvp((long) G__PVOID);
06851 ((TMVA::RuleFitAPI*) (soff))->~G__TTMVAcLcLRuleFitAPI();
06852 G__setgvp((long)gvp);
06853 }
06854 }
06855 G__setnull(result7);
06856 return(1 || funcname || hash || result7 || libp) ;
06857 }
06858
06859
06860
06861 static int G__G__TMVA4_350_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06862 {
06863 G__letint(result7, 67, (long) ((const TMVA::IMethod*) G__getstructoffset())->GetName());
06864 return(1 || funcname || hash || result7 || libp) ;
06865 }
06866
06867 static int G__G__TMVA4_350_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06868 {
06869 switch (libp->paran) {
06870 case 2:
06871 G__letdouble(result7, 100, (double) ((TMVA::IMethod*) G__getstructoffset())->GetMvaValue((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
06872 break;
06873 case 1:
06874 G__letdouble(result7, 100, (double) ((TMVA::IMethod*) G__getstructoffset())->GetMvaValue((Double_t*) G__int(libp->para[0])));
06875 break;
06876 case 0:
06877 G__letdouble(result7, 100, (double) ((TMVA::IMethod*) G__getstructoffset())->GetMvaValue());
06878 break;
06879 }
06880 return(1 || funcname || hash || result7 || libp) ;
06881 }
06882
06883 static int G__G__TMVA4_350_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06884 {
06885 ((TMVA::IMethod*) G__getstructoffset())->Train();
06886 G__setnull(result7);
06887 return(1 || funcname || hash || result7 || libp) ;
06888 }
06889
06890 static int G__G__TMVA4_350_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06891 {
06892 ((TMVA::IMethod*) G__getstructoffset())->ReadWeightsFromStream(*(istream*) libp->para[0].ref);
06893 G__setnull(result7);
06894 return(1 || funcname || hash || result7 || libp) ;
06895 }
06896
06897 static int G__G__TMVA4_350_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06898 {
06899 ((const TMVA::IMethod*) G__getstructoffset())->WriteMonitoringHistosToFile();
06900 G__setnull(result7);
06901 return(1 || funcname || hash || result7 || libp) ;
06902 }
06903
06904 static int G__G__TMVA4_350_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06905 {
06906 switch (libp->paran) {
06907 case 1:
06908 ((const TMVA::IMethod*) G__getstructoffset())->MakeClass(*(TString*) libp->para[0].ref);
06909 G__setnull(result7);
06910 break;
06911 case 0:
06912 ((const TMVA::IMethod*) G__getstructoffset())->MakeClass();
06913 G__setnull(result7);
06914 break;
06915 }
06916 return(1 || funcname || hash || result7 || libp) ;
06917 }
06918
06919 static int G__G__TMVA4_350_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06920 {
06921 G__letint(result7, 85, (long) ((TMVA::IMethod*) G__getstructoffset())->CreateRanking());
06922 return(1 || funcname || hash || result7 || libp) ;
06923 }
06924
06925 static int G__G__TMVA4_350_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06926 {
06927 ((const TMVA::IMethod*) G__getstructoffset())->PrintHelpMessage();
06928 G__setnull(result7);
06929 return(1 || funcname || hash || result7 || libp) ;
06930 }
06931
06932 static int G__G__TMVA4_350_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06933 {
06934 G__letint(result7, 103, (long) ((TMVA::IMethod*) G__getstructoffset())->MonitorBoost((TMVA::MethodBoost*) G__int(libp->para[0])));
06935 return(1 || funcname || hash || result7 || libp) ;
06936 }
06937
06938 static int G__G__TMVA4_350_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06939 {
06940 ((TMVA::IMethod*) G__getstructoffset())->Init();
06941 G__setnull(result7);
06942 return(1 || funcname || hash || result7 || libp) ;
06943 }
06944
06945 static int G__G__TMVA4_350_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06946 {
06947 ((TMVA::IMethod*) G__getstructoffset())->DeclareOptions();
06948 G__setnull(result7);
06949 return(1 || funcname || hash || result7 || libp) ;
06950 }
06951
06952 static int G__G__TMVA4_350_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06953 {
06954 ((TMVA::IMethod*) G__getstructoffset())->ProcessOptions();
06955 G__setnull(result7);
06956 return(1 || funcname || hash || result7 || libp) ;
06957 }
06958
06959 static int G__G__TMVA4_350_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06960 {
06961 G__letint(result7, 103, (long) ((TMVA::IMethod*) G__getstructoffset())->HasAnalysisType((TMVA::Types::EAnalysisType) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
06962 , (UInt_t) G__int(libp->para[2])));
06963 return(1 || funcname || hash || result7 || libp) ;
06964 }
06965
06966 static int G__G__TMVA4_350_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06967 {
06968 G__letint(result7, 85, (long) TMVA::IMethod::Class());
06969 return(1 || funcname || hash || result7 || libp) ;
06970 }
06971
06972 static int G__G__TMVA4_350_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06973 {
06974 G__letint(result7, 67, (long) TMVA::IMethod::Class_Name());
06975 return(1 || funcname || hash || result7 || libp) ;
06976 }
06977
06978 static int G__G__TMVA4_350_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06979 {
06980 G__letint(result7, 115, (long) TMVA::IMethod::Class_Version());
06981 return(1 || funcname || hash || result7 || libp) ;
06982 }
06983
06984 static int G__G__TMVA4_350_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06985 {
06986 TMVA::IMethod::Dictionary();
06987 G__setnull(result7);
06988 return(1 || funcname || hash || result7 || libp) ;
06989 }
06990
06991 static int G__G__TMVA4_350_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06992 {
06993 G__letint(result7, 85, (long) ((const TMVA::IMethod*) G__getstructoffset())->IsA());
06994 return(1 || funcname || hash || result7 || libp) ;
06995 }
06996
06997 static int G__G__TMVA4_350_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06998 {
06999 ((TMVA::IMethod*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
07000 G__setnull(result7);
07001 return(1 || funcname || hash || result7 || libp) ;
07002 }
07003
07004 static int G__G__TMVA4_350_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07005 {
07006 ((TMVA::IMethod*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
07007 G__setnull(result7);
07008 return(1 || funcname || hash || result7 || libp) ;
07009 }
07010
07011 static int G__G__TMVA4_350_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07012 {
07013 ((TMVA::IMethod*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07014 G__setnull(result7);
07015 return(1 || funcname || hash || result7 || libp) ;
07016 }
07017
07018 static int G__G__TMVA4_350_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07019 {
07020 G__letint(result7, 67, (long) TMVA::IMethod::DeclFileName());
07021 return(1 || funcname || hash || result7 || libp) ;
07022 }
07023
07024 static int G__G__TMVA4_350_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07025 {
07026 G__letint(result7, 105, (long) TMVA::IMethod::ImplFileLine());
07027 return(1 || funcname || hash || result7 || libp) ;
07028 }
07029
07030 static int G__G__TMVA4_350_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07031 {
07032 G__letint(result7, 67, (long) TMVA::IMethod::ImplFileName());
07033 return(1 || funcname || hash || result7 || libp) ;
07034 }
07035
07036 static int G__G__TMVA4_350_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07037 {
07038 G__letint(result7, 105, (long) TMVA::IMethod::DeclFileLine());
07039 return(1 || funcname || hash || result7 || libp) ;
07040 }
07041
07042
07043 typedef TMVA::IMethod G__TTMVAcLcLIMethod;
07044 static int G__G__TMVA4_350_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07045 {
07046 char* gvp = (char*) G__getgvp();
07047 long soff = G__getstructoffset();
07048 int n = G__getaryconstruct();
07049
07050
07051
07052
07053
07054 if (!soff) {
07055 return(1);
07056 }
07057 if (n) {
07058 if (gvp == (char*)G__PVOID) {
07059 delete[] (TMVA::IMethod*) soff;
07060 } else {
07061 G__setgvp((long) G__PVOID);
07062 for (int i = n - 1; i >= 0; --i) {
07063 ((TMVA::IMethod*) (soff+(sizeof(TMVA::IMethod)*i)))->~G__TTMVAcLcLIMethod();
07064 }
07065 G__setgvp((long)gvp);
07066 }
07067 } else {
07068 if (gvp == (char*)G__PVOID) {
07069 delete (TMVA::IMethod*) soff;
07070 } else {
07071 G__setgvp((long) G__PVOID);
07072 ((TMVA::IMethod*) (soff))->~G__TTMVAcLcLIMethod();
07073 G__setgvp((long)gvp);
07074 }
07075 }
07076 G__setnull(result7);
07077 return(1 || funcname || hash || result7 || libp) ;
07078 }
07079
07080
07081 static int G__G__TMVA4_350_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07082 {
07083 TMVA::IMethod* dest = (TMVA::IMethod*) G__getstructoffset();
07084 *dest = *(TMVA::IMethod*) libp->para[0].ref;
07085 const TMVA::IMethod& obj = *dest;
07086 result7->ref = (long) (&obj);
07087 result7->obj.i = (long) (&obj);
07088 return(1 || funcname || hash || result7 || libp) ;
07089 }
07090
07091
07092
07093 static int G__G__TMVA4_400_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07094 {
07095 ((TMVA::VariableTransformBase*) G__getstructoffset())->Initialize();
07096 G__setnull(result7);
07097 return(1 || funcname || hash || result7 || libp) ;
07098 }
07099
07100 static int G__G__TMVA4_400_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07101 {
07102 G__letint(result7, 103, (long) ((TMVA::VariableTransformBase*) G__getstructoffset())->PrepareTransformation(*(vector<TMVA::Event*,allocator<TMVA::Event*> >*) libp->para[0].ref));
07103 return(1 || funcname || hash || result7 || libp) ;
07104 }
07105
07106 static int G__G__TMVA4_400_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07107 {
07108 G__letint(result7, 85, (long) ((const TMVA::VariableTransformBase*) G__getstructoffset())->Transform((TMVA::Event*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
07109 return(1 || funcname || hash || result7 || libp) ;
07110 }
07111
07112 static int G__G__TMVA4_400_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07113 {
07114 G__letint(result7, 85, (long) ((const TMVA::VariableTransformBase*) G__getstructoffset())->InverseTransform((TMVA::Event*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
07115 return(1 || funcname || hash || result7 || libp) ;
07116 }
07117
07118 static int G__G__TMVA4_400_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07119 {
07120 ((TMVA::VariableTransformBase*) G__getstructoffset())->SetEnabled((Bool_t) G__int(libp->para[0]));
07121 G__setnull(result7);
07122 return(1 || funcname || hash || result7 || libp) ;
07123 }
07124
07125 static int G__G__TMVA4_400_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07126 {
07127 ((TMVA::VariableTransformBase*) G__getstructoffset())->SetNormalise((Bool_t) G__int(libp->para[0]));
07128 G__setnull(result7);
07129 return(1 || funcname || hash || result7 || libp) ;
07130 }
07131
07132 static int G__G__TMVA4_400_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07133 {
07134 G__letint(result7, 103, (long) ((const TMVA::VariableTransformBase*) G__getstructoffset())->IsEnabled());
07135 return(1 || funcname || hash || result7 || libp) ;
07136 }
07137
07138 static int G__G__TMVA4_400_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07139 {
07140 G__letint(result7, 103, (long) ((const TMVA::VariableTransformBase*) G__getstructoffset())->IsCreated());
07141 return(1 || funcname || hash || result7 || libp) ;
07142 }
07143
07144 static int G__G__TMVA4_400_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07145 {
07146 G__letint(result7, 103, (long) ((const TMVA::VariableTransformBase*) G__getstructoffset())->IsNormalised());
07147 return(1 || funcname || hash || result7 || libp) ;
07148 }
07149
07150 static int G__G__TMVA4_400_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07151 {
07152 switch (libp->paran) {
07153 case 1:
07154 ((TMVA::VariableTransformBase*) G__getstructoffset())->SetUseSignalTransform((Bool_t) G__int(libp->para[0]));
07155 G__setnull(result7);
07156 break;
07157 case 0:
07158 ((TMVA::VariableTransformBase*) G__getstructoffset())->SetUseSignalTransform();
07159 G__setnull(result7);
07160 break;
07161 }
07162 return(1 || funcname || hash || result7 || libp) ;
07163 }
07164
07165 static int G__G__TMVA4_400_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07166 {
07167 G__letint(result7, 103, (long) ((const TMVA::VariableTransformBase*) G__getstructoffset())->UseSignalTransform());
07168 return(1 || funcname || hash || result7 || libp) ;
07169 }
07170
07171 static int G__G__TMVA4_400_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07172 {
07173 {
07174 const TString* pobj;
07175 const TString xobj = ((const TMVA::VariableTransformBase*) G__getstructoffset())->GetShortName();
07176 pobj = new TString(xobj);
07177 result7->obj.i = (long) ((void*) pobj);
07178 result7->ref = result7->obj.i;
07179 G__store_tempobject(*result7);
07180 }
07181 return(1 || funcname || hash || result7 || libp) ;
07182 }
07183
07184 static int G__G__TMVA4_400_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07185 {
07186 ((const TMVA::VariableTransformBase*) G__getstructoffset())->WriteTransformationToStream(*(ostream*) libp->para[0].ref);
07187 G__setnull(result7);
07188 return(1 || funcname || hash || result7 || libp) ;
07189 }
07190
07191 static int G__G__TMVA4_400_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07192 {
07193 switch (libp->paran) {
07194 case 2:
07195 ((TMVA::VariableTransformBase*) G__getstructoffset())->ReadTransformationFromStream(*(istream*) libp->para[0].ref, *(TString*) libp->para[1].ref);
07196 G__setnull(result7);
07197 break;
07198 case 1:
07199 ((TMVA::VariableTransformBase*) G__getstructoffset())->ReadTransformationFromStream(*(istream*) libp->para[0].ref);
07200 G__setnull(result7);
07201 break;
07202 }
07203 return(1 || funcname || hash || result7 || libp) ;
07204 }
07205
07206 static int G__G__TMVA4_400_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07207 {
07208 ((TMVA::VariableTransformBase*) G__getstructoffset())->AttachXMLTo((void*) G__int(libp->para[0]));
07209 G__setnull(result7);
07210 return(1 || funcname || hash || result7 || libp) ;
07211 }
07212
07213 static int G__G__TMVA4_400_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07214 {
07215 ((TMVA::VariableTransformBase*) G__getstructoffset())->ReadFromXML((void*) G__int(libp->para[0]));
07216 G__setnull(result7);
07217 return(1 || funcname || hash || result7 || libp) ;
07218 }
07219
07220 static int G__G__TMVA4_400_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07221 {
07222 G__letint(result7, 105, (long) ((const TMVA::VariableTransformBase*) G__getstructoffset())->GetVariableTransform());
07223 return(1 || funcname || hash || result7 || libp) ;
07224 }
07225
07226 static int G__G__TMVA4_400_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07227 {
07228 ((TMVA::VariableTransformBase*) G__getstructoffset())->MakeFunction(*(ostream*) libp->para[0].ref, *(TString*) libp->para[1].ref
07229 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
07230 , (Int_t) G__int(libp->para[4]));
07231 G__setnull(result7);
07232 return(1 || funcname || hash || result7 || libp) ;
07233 }
07234
07235 static int G__G__TMVA4_400_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07236 {
07237 G__letint(result7, 85, (long) ((const TMVA::VariableTransformBase*) G__getstructoffset())->GetTransformationStrings((Int_t) G__int(libp->para[0])));
07238 return(1 || funcname || hash || result7 || libp) ;
07239 }
07240
07241 static int G__G__TMVA4_400_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07242 {
07243 ((TMVA::VariableTransformBase*) G__getstructoffset())->PrintTransformation(*(ostream*) libp->para[0].ref);
07244 G__setnull(result7);
07245 return(1 || funcname || hash || result7 || libp) ;
07246 }
07247
07248 static int G__G__TMVA4_400_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07249 {
07250 {
07251 const vector<TMVA::VariableInfo>& obj = ((const TMVA::VariableTransformBase*) G__getstructoffset())->Variables();
07252 result7->ref = (long) (&obj);
07253 result7->obj.i = (long) (&obj);
07254 }
07255 return(1 || funcname || hash || result7 || libp) ;
07256 }
07257
07258 static int G__G__TMVA4_400_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07259 {
07260 {
07261 const vector<TMVA::VariableInfo>& obj = ((const TMVA::VariableTransformBase*) G__getstructoffset())->Targets();
07262 result7->ref = (long) (&obj);
07263 result7->obj.i = (long) (&obj);
07264 }
07265 return(1 || funcname || hash || result7 || libp) ;
07266 }
07267
07268 static int G__G__TMVA4_400_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07269 {
07270 {
07271 const TMVA::MsgLogger& obj = ((const TMVA::VariableTransformBase*) G__getstructoffset())->Log();
07272 result7->ref = (long) (&obj);
07273 result7->obj.i = (long) (&obj);
07274 }
07275 return(1 || funcname || hash || result7 || libp) ;
07276 }
07277
07278 static int G__G__TMVA4_400_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07279 {
07280 ((TMVA::VariableTransformBase*) G__getstructoffset())->SetTMVAVersion((TMVA::TMVAVersion_t) G__int(libp->para[0]));
07281 G__setnull(result7);
07282 return(1 || funcname || hash || result7 || libp) ;
07283 }
07284
07285 static int G__G__TMVA4_400_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07286 {
07287 G__letint(result7, 85, (long) TMVA::VariableTransformBase::Class());
07288 return(1 || funcname || hash || result7 || libp) ;
07289 }
07290
07291 static int G__G__TMVA4_400_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07292 {
07293 G__letint(result7, 67, (long) TMVA::VariableTransformBase::Class_Name());
07294 return(1 || funcname || hash || result7 || libp) ;
07295 }
07296
07297 static int G__G__TMVA4_400_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07298 {
07299 G__letint(result7, 115, (long) TMVA::VariableTransformBase::Class_Version());
07300 return(1 || funcname || hash || result7 || libp) ;
07301 }
07302
07303 static int G__G__TMVA4_400_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07304 {
07305 TMVA::VariableTransformBase::Dictionary();
07306 G__setnull(result7);
07307 return(1 || funcname || hash || result7 || libp) ;
07308 }
07309
07310 static int G__G__TMVA4_400_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07311 {
07312 ((TMVA::VariableTransformBase*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07313 G__setnull(result7);
07314 return(1 || funcname || hash || result7 || libp) ;
07315 }
07316
07317 static int G__G__TMVA4_400_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07318 {
07319 G__letint(result7, 67, (long) TMVA::VariableTransformBase::DeclFileName());
07320 return(1 || funcname || hash || result7 || libp) ;
07321 }
07322
07323 static int G__G__TMVA4_400_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07324 {
07325 G__letint(result7, 105, (long) TMVA::VariableTransformBase::ImplFileLine());
07326 return(1 || funcname || hash || result7 || libp) ;
07327 }
07328
07329 static int G__G__TMVA4_400_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07330 {
07331 G__letint(result7, 67, (long) TMVA::VariableTransformBase::ImplFileName());
07332 return(1 || funcname || hash || result7 || libp) ;
07333 }
07334
07335 static int G__G__TMVA4_400_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07336 {
07337 G__letint(result7, 105, (long) TMVA::VariableTransformBase::DeclFileLine());
07338 return(1 || funcname || hash || result7 || libp) ;
07339 }
07340
07341
07342 typedef TMVA::VariableTransformBase G__TTMVAcLcLVariableTransformBase;
07343 static int G__G__TMVA4_400_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07344 {
07345 char* gvp = (char*) G__getgvp();
07346 long soff = G__getstructoffset();
07347 int n = G__getaryconstruct();
07348
07349
07350
07351
07352
07353 if (!soff) {
07354 return(1);
07355 }
07356 if (n) {
07357 if (gvp == (char*)G__PVOID) {
07358 delete[] (TMVA::VariableTransformBase*) soff;
07359 } else {
07360 G__setgvp((long) G__PVOID);
07361 for (int i = n - 1; i >= 0; --i) {
07362 ((TMVA::VariableTransformBase*) (soff+(sizeof(TMVA::VariableTransformBase)*i)))->~G__TTMVAcLcLVariableTransformBase();
07363 }
07364 G__setgvp((long)gvp);
07365 }
07366 } else {
07367 if (gvp == (char*)G__PVOID) {
07368 delete (TMVA::VariableTransformBase*) soff;
07369 } else {
07370 G__setgvp((long) G__PVOID);
07371 ((TMVA::VariableTransformBase*) (soff))->~G__TTMVAcLcLVariableTransformBase();
07372 G__setgvp((long)gvp);
07373 }
07374 }
07375 G__setnull(result7);
07376 return(1 || funcname || hash || result7 || libp) ;
07377 }
07378
07379
07380
07381 static int G__G__TMVA4_411_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07382 {
07383 TMVA::VariableIdentityTransform* p = NULL;
07384 char* gvp = (char*) G__getgvp();
07385
07386 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07387 p = new TMVA::VariableIdentityTransform(*(TMVA::DataSetInfo*) libp->para[0].ref);
07388 } else {
07389 p = new((void*) gvp) TMVA::VariableIdentityTransform(*(TMVA::DataSetInfo*) libp->para[0].ref);
07390 }
07391 result7->obj.i = (long) p;
07392 result7->ref = (long) p;
07393 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform));
07394 return(1 || funcname || hash || result7 || libp) ;
07395 }
07396
07397 static int G__G__TMVA4_411_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07398 {
07399 G__letint(result7, 85, (long) TMVA::VariableIdentityTransform::Class());
07400 return(1 || funcname || hash || result7 || libp) ;
07401 }
07402
07403 static int G__G__TMVA4_411_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07404 {
07405 G__letint(result7, 67, (long) TMVA::VariableIdentityTransform::Class_Name());
07406 return(1 || funcname || hash || result7 || libp) ;
07407 }
07408
07409 static int G__G__TMVA4_411_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07410 {
07411 G__letint(result7, 115, (long) TMVA::VariableIdentityTransform::Class_Version());
07412 return(1 || funcname || hash || result7 || libp) ;
07413 }
07414
07415 static int G__G__TMVA4_411_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07416 {
07417 TMVA::VariableIdentityTransform::Dictionary();
07418 G__setnull(result7);
07419 return(1 || funcname || hash || result7 || libp) ;
07420 }
07421
07422 static int G__G__TMVA4_411_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07423 {
07424 ((TMVA::VariableIdentityTransform*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07425 G__setnull(result7);
07426 return(1 || funcname || hash || result7 || libp) ;
07427 }
07428
07429 static int G__G__TMVA4_411_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07430 {
07431 G__letint(result7, 67, (long) TMVA::VariableIdentityTransform::DeclFileName());
07432 return(1 || funcname || hash || result7 || libp) ;
07433 }
07434
07435 static int G__G__TMVA4_411_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07436 {
07437 G__letint(result7, 105, (long) TMVA::VariableIdentityTransform::ImplFileLine());
07438 return(1 || funcname || hash || result7 || libp) ;
07439 }
07440
07441 static int G__G__TMVA4_411_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07442 {
07443 G__letint(result7, 67, (long) TMVA::VariableIdentityTransform::ImplFileName());
07444 return(1 || funcname || hash || result7 || libp) ;
07445 }
07446
07447 static int G__G__TMVA4_411_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07448 {
07449 G__letint(result7, 105, (long) TMVA::VariableIdentityTransform::DeclFileLine());
07450 return(1 || funcname || hash || result7 || libp) ;
07451 }
07452
07453
07454 static int G__G__TMVA4_411_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07455
07456 {
07457 TMVA::VariableIdentityTransform* p;
07458 void* tmp = (void*) G__int(libp->para[0]);
07459 p = new TMVA::VariableIdentityTransform(*(TMVA::VariableIdentityTransform*) tmp);
07460 result7->obj.i = (long) p;
07461 result7->ref = (long) p;
07462 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform));
07463 return(1 || funcname || hash || result7 || libp) ;
07464 }
07465
07466
07467 typedef TMVA::VariableIdentityTransform G__TTMVAcLcLVariableIdentityTransform;
07468 static int G__G__TMVA4_411_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07469 {
07470 char* gvp = (char*) G__getgvp();
07471 long soff = G__getstructoffset();
07472 int n = G__getaryconstruct();
07473
07474
07475
07476
07477
07478 if (!soff) {
07479 return(1);
07480 }
07481 if (n) {
07482 if (gvp == (char*)G__PVOID) {
07483 delete[] (TMVA::VariableIdentityTransform*) soff;
07484 } else {
07485 G__setgvp((long) G__PVOID);
07486 for (int i = n - 1; i >= 0; --i) {
07487 ((TMVA::VariableIdentityTransform*) (soff+(sizeof(TMVA::VariableIdentityTransform)*i)))->~G__TTMVAcLcLVariableIdentityTransform();
07488 }
07489 G__setgvp((long)gvp);
07490 }
07491 } else {
07492 if (gvp == (char*)G__PVOID) {
07493 delete (TMVA::VariableIdentityTransform*) soff;
07494 } else {
07495 G__setgvp((long) G__PVOID);
07496 ((TMVA::VariableIdentityTransform*) (soff))->~G__TTMVAcLcLVariableIdentityTransform();
07497 G__setgvp((long)gvp);
07498 }
07499 }
07500 G__setnull(result7);
07501 return(1 || funcname || hash || result7 || libp) ;
07502 }
07503
07504
07505
07506 static int G__G__TMVA4_413_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07507 {
07508 TMVA::VariableDecorrTransform* p = NULL;
07509 char* gvp = (char*) G__getgvp();
07510
07511 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07512 p = new TMVA::VariableDecorrTransform(*(TMVA::DataSetInfo*) libp->para[0].ref);
07513 } else {
07514 p = new((void*) gvp) TMVA::VariableDecorrTransform(*(TMVA::DataSetInfo*) libp->para[0].ref);
07515 }
07516 result7->obj.i = (long) p;
07517 result7->ref = (long) p;
07518 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform));
07519 return(1 || funcname || hash || result7 || libp) ;
07520 }
07521
07522 static int G__G__TMVA4_413_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07523 {
07524 G__letint(result7, 85, (long) TMVA::VariableDecorrTransform::Class());
07525 return(1 || funcname || hash || result7 || libp) ;
07526 }
07527
07528 static int G__G__TMVA4_413_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07529 {
07530 G__letint(result7, 67, (long) TMVA::VariableDecorrTransform::Class_Name());
07531 return(1 || funcname || hash || result7 || libp) ;
07532 }
07533
07534 static int G__G__TMVA4_413_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07535 {
07536 G__letint(result7, 115, (long) TMVA::VariableDecorrTransform::Class_Version());
07537 return(1 || funcname || hash || result7 || libp) ;
07538 }
07539
07540 static int G__G__TMVA4_413_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07541 {
07542 TMVA::VariableDecorrTransform::Dictionary();
07543 G__setnull(result7);
07544 return(1 || funcname || hash || result7 || libp) ;
07545 }
07546
07547 static int G__G__TMVA4_413_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07548 {
07549 ((TMVA::VariableDecorrTransform*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07550 G__setnull(result7);
07551 return(1 || funcname || hash || result7 || libp) ;
07552 }
07553
07554 static int G__G__TMVA4_413_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07555 {
07556 G__letint(result7, 67, (long) TMVA::VariableDecorrTransform::DeclFileName());
07557 return(1 || funcname || hash || result7 || libp) ;
07558 }
07559
07560 static int G__G__TMVA4_413_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07561 {
07562 G__letint(result7, 105, (long) TMVA::VariableDecorrTransform::ImplFileLine());
07563 return(1 || funcname || hash || result7 || libp) ;
07564 }
07565
07566 static int G__G__TMVA4_413_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07567 {
07568 G__letint(result7, 67, (long) TMVA::VariableDecorrTransform::ImplFileName());
07569 return(1 || funcname || hash || result7 || libp) ;
07570 }
07571
07572 static int G__G__TMVA4_413_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07573 {
07574 G__letint(result7, 105, (long) TMVA::VariableDecorrTransform::DeclFileLine());
07575 return(1 || funcname || hash || result7 || libp) ;
07576 }
07577
07578
07579 static int G__G__TMVA4_413_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07580
07581 {
07582 TMVA::VariableDecorrTransform* p;
07583 void* tmp = (void*) G__int(libp->para[0]);
07584 p = new TMVA::VariableDecorrTransform(*(TMVA::VariableDecorrTransform*) tmp);
07585 result7->obj.i = (long) p;
07586 result7->ref = (long) p;
07587 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform));
07588 return(1 || funcname || hash || result7 || libp) ;
07589 }
07590
07591
07592 typedef TMVA::VariableDecorrTransform G__TTMVAcLcLVariableDecorrTransform;
07593 static int G__G__TMVA4_413_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07594 {
07595 char* gvp = (char*) G__getgvp();
07596 long soff = G__getstructoffset();
07597 int n = G__getaryconstruct();
07598
07599
07600
07601
07602
07603 if (!soff) {
07604 return(1);
07605 }
07606 if (n) {
07607 if (gvp == (char*)G__PVOID) {
07608 delete[] (TMVA::VariableDecorrTransform*) soff;
07609 } else {
07610 G__setgvp((long) G__PVOID);
07611 for (int i = n - 1; i >= 0; --i) {
07612 ((TMVA::VariableDecorrTransform*) (soff+(sizeof(TMVA::VariableDecorrTransform)*i)))->~G__TTMVAcLcLVariableDecorrTransform();
07613 }
07614 G__setgvp((long)gvp);
07615 }
07616 } else {
07617 if (gvp == (char*)G__PVOID) {
07618 delete (TMVA::VariableDecorrTransform*) soff;
07619 } else {
07620 G__setgvp((long) G__PVOID);
07621 ((TMVA::VariableDecorrTransform*) (soff))->~G__TTMVAcLcLVariableDecorrTransform();
07622 G__setgvp((long)gvp);
07623 }
07624 }
07625 G__setnull(result7);
07626 return(1 || funcname || hash || result7 || libp) ;
07627 }
07628
07629
07630
07631 static int G__G__TMVA4_476_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07632 {
07633 TMVA::VariablePCATransform* p = NULL;
07634 char* gvp = (char*) G__getgvp();
07635
07636 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07637 p = new TMVA::VariablePCATransform(*(TMVA::DataSetInfo*) libp->para[0].ref);
07638 } else {
07639 p = new((void*) gvp) TMVA::VariablePCATransform(*(TMVA::DataSetInfo*) libp->para[0].ref);
07640 }
07641 result7->obj.i = (long) p;
07642 result7->ref = (long) p;
07643 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform));
07644 return(1 || funcname || hash || result7 || libp) ;
07645 }
07646
07647 static int G__G__TMVA4_476_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07648 {
07649 G__letint(result7, 85, (long) TMVA::VariablePCATransform::Class());
07650 return(1 || funcname || hash || result7 || libp) ;
07651 }
07652
07653 static int G__G__TMVA4_476_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07654 {
07655 G__letint(result7, 67, (long) TMVA::VariablePCATransform::Class_Name());
07656 return(1 || funcname || hash || result7 || libp) ;
07657 }
07658
07659 static int G__G__TMVA4_476_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07660 {
07661 G__letint(result7, 115, (long) TMVA::VariablePCATransform::Class_Version());
07662 return(1 || funcname || hash || result7 || libp) ;
07663 }
07664
07665 static int G__G__TMVA4_476_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07666 {
07667 TMVA::VariablePCATransform::Dictionary();
07668 G__setnull(result7);
07669 return(1 || funcname || hash || result7 || libp) ;
07670 }
07671
07672 static int G__G__TMVA4_476_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07673 {
07674 ((TMVA::VariablePCATransform*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07675 G__setnull(result7);
07676 return(1 || funcname || hash || result7 || libp) ;
07677 }
07678
07679 static int G__G__TMVA4_476_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07680 {
07681 G__letint(result7, 67, (long) TMVA::VariablePCATransform::DeclFileName());
07682 return(1 || funcname || hash || result7 || libp) ;
07683 }
07684
07685 static int G__G__TMVA4_476_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07686 {
07687 G__letint(result7, 105, (long) TMVA::VariablePCATransform::ImplFileLine());
07688 return(1 || funcname || hash || result7 || libp) ;
07689 }
07690
07691 static int G__G__TMVA4_476_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07692 {
07693 G__letint(result7, 67, (long) TMVA::VariablePCATransform::ImplFileName());
07694 return(1 || funcname || hash || result7 || libp) ;
07695 }
07696
07697 static int G__G__TMVA4_476_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07698 {
07699 G__letint(result7, 105, (long) TMVA::VariablePCATransform::DeclFileLine());
07700 return(1 || funcname || hash || result7 || libp) ;
07701 }
07702
07703
07704 static int G__G__TMVA4_476_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07705
07706 {
07707 TMVA::VariablePCATransform* p;
07708 void* tmp = (void*) G__int(libp->para[0]);
07709 p = new TMVA::VariablePCATransform(*(TMVA::VariablePCATransform*) tmp);
07710 result7->obj.i = (long) p;
07711 result7->ref = (long) p;
07712 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform));
07713 return(1 || funcname || hash || result7 || libp) ;
07714 }
07715
07716
07717 typedef TMVA::VariablePCATransform G__TTMVAcLcLVariablePCATransform;
07718 static int G__G__TMVA4_476_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07719 {
07720 char* gvp = (char*) G__getgvp();
07721 long soff = G__getstructoffset();
07722 int n = G__getaryconstruct();
07723
07724
07725
07726
07727
07728 if (!soff) {
07729 return(1);
07730 }
07731 if (n) {
07732 if (gvp == (char*)G__PVOID) {
07733 delete[] (TMVA::VariablePCATransform*) soff;
07734 } else {
07735 G__setgvp((long) G__PVOID);
07736 for (int i = n - 1; i >= 0; --i) {
07737 ((TMVA::VariablePCATransform*) (soff+(sizeof(TMVA::VariablePCATransform)*i)))->~G__TTMVAcLcLVariablePCATransform();
07738 }
07739 G__setgvp((long)gvp);
07740 }
07741 } else {
07742 if (gvp == (char*)G__PVOID) {
07743 delete (TMVA::VariablePCATransform*) soff;
07744 } else {
07745 G__setgvp((long) G__PVOID);
07746 ((TMVA::VariablePCATransform*) (soff))->~G__TTMVAcLcLVariablePCATransform();
07747 G__setgvp((long)gvp);
07748 }
07749 }
07750 G__setnull(result7);
07751 return(1 || funcname || hash || result7 || libp) ;
07752 }
07753
07754
07755
07756 static int G__G__TMVA4_514_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07757 {
07758 TMVA::VariableGaussTransform* p = NULL;
07759 char* gvp = (char*) G__getgvp();
07760 switch (libp->paran) {
07761 case 2:
07762
07763 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07764 p = new TMVA::VariableGaussTransform(*(TMVA::DataSetInfo*) libp->para[0].ref, *((TString*) G__int(libp->para[1])));
07765 } else {
07766 p = new((void*) gvp) TMVA::VariableGaussTransform(*(TMVA::DataSetInfo*) libp->para[0].ref, *((TString*) G__int(libp->para[1])));
07767 }
07768 break;
07769 case 1:
07770
07771 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07772 p = new TMVA::VariableGaussTransform(*(TMVA::DataSetInfo*) libp->para[0].ref);
07773 } else {
07774 p = new((void*) gvp) TMVA::VariableGaussTransform(*(TMVA::DataSetInfo*) libp->para[0].ref);
07775 }
07776 break;
07777 }
07778 result7->obj.i = (long) p;
07779 result7->ref = (long) p;
07780 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform));
07781 return(1 || funcname || hash || result7 || libp) ;
07782 }
07783
07784 static int G__G__TMVA4_514_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07785 {
07786 G__letint(result7, 85, (long) TMVA::VariableGaussTransform::Class());
07787 return(1 || funcname || hash || result7 || libp) ;
07788 }
07789
07790 static int G__G__TMVA4_514_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07791 {
07792 G__letint(result7, 67, (long) TMVA::VariableGaussTransform::Class_Name());
07793 return(1 || funcname || hash || result7 || libp) ;
07794 }
07795
07796 static int G__G__TMVA4_514_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07797 {
07798 G__letint(result7, 115, (long) TMVA::VariableGaussTransform::Class_Version());
07799 return(1 || funcname || hash || result7 || libp) ;
07800 }
07801
07802 static int G__G__TMVA4_514_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07803 {
07804 TMVA::VariableGaussTransform::Dictionary();
07805 G__setnull(result7);
07806 return(1 || funcname || hash || result7 || libp) ;
07807 }
07808
07809 static int G__G__TMVA4_514_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07810 {
07811 ((TMVA::VariableGaussTransform*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07812 G__setnull(result7);
07813 return(1 || funcname || hash || result7 || libp) ;
07814 }
07815
07816 static int G__G__TMVA4_514_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07817 {
07818 G__letint(result7, 67, (long) TMVA::VariableGaussTransform::DeclFileName());
07819 return(1 || funcname || hash || result7 || libp) ;
07820 }
07821
07822 static int G__G__TMVA4_514_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07823 {
07824 G__letint(result7, 105, (long) TMVA::VariableGaussTransform::ImplFileLine());
07825 return(1 || funcname || hash || result7 || libp) ;
07826 }
07827
07828 static int G__G__TMVA4_514_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07829 {
07830 G__letint(result7, 67, (long) TMVA::VariableGaussTransform::ImplFileName());
07831 return(1 || funcname || hash || result7 || libp) ;
07832 }
07833
07834 static int G__G__TMVA4_514_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07835 {
07836 G__letint(result7, 105, (long) TMVA::VariableGaussTransform::DeclFileLine());
07837 return(1 || funcname || hash || result7 || libp) ;
07838 }
07839
07840
07841 static int G__G__TMVA4_514_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07842
07843 {
07844 TMVA::VariableGaussTransform* p;
07845 void* tmp = (void*) G__int(libp->para[0]);
07846 p = new TMVA::VariableGaussTransform(*(TMVA::VariableGaussTransform*) tmp);
07847 result7->obj.i = (long) p;
07848 result7->ref = (long) p;
07849 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform));
07850 return(1 || funcname || hash || result7 || libp) ;
07851 }
07852
07853
07854 typedef TMVA::VariableGaussTransform G__TTMVAcLcLVariableGaussTransform;
07855 static int G__G__TMVA4_514_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07856 {
07857 char* gvp = (char*) G__getgvp();
07858 long soff = G__getstructoffset();
07859 int n = G__getaryconstruct();
07860
07861
07862
07863
07864
07865 if (!soff) {
07866 return(1);
07867 }
07868 if (n) {
07869 if (gvp == (char*)G__PVOID) {
07870 delete[] (TMVA::VariableGaussTransform*) soff;
07871 } else {
07872 G__setgvp((long) G__PVOID);
07873 for (int i = n - 1; i >= 0; --i) {
07874 ((TMVA::VariableGaussTransform*) (soff+(sizeof(TMVA::VariableGaussTransform)*i)))->~G__TTMVAcLcLVariableGaussTransform();
07875 }
07876 G__setgvp((long)gvp);
07877 }
07878 } else {
07879 if (gvp == (char*)G__PVOID) {
07880 delete (TMVA::VariableGaussTransform*) soff;
07881 } else {
07882 G__setgvp((long) G__PVOID);
07883 ((TMVA::VariableGaussTransform*) (soff))->~G__TTMVAcLcLVariableGaussTransform();
07884 G__setgvp((long)gvp);
07885 }
07886 }
07887 G__setnull(result7);
07888 return(1 || funcname || hash || result7 || libp) ;
07889 }
07890
07891
07892
07893 static int G__G__TMVA4_527_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07894 {
07895 TMVA::VariableNormalizeTransform* p = NULL;
07896 char* gvp = (char*) G__getgvp();
07897
07898 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07899 p = new TMVA::VariableNormalizeTransform(*(TMVA::DataSetInfo*) libp->para[0].ref);
07900 } else {
07901 p = new((void*) gvp) TMVA::VariableNormalizeTransform(*(TMVA::DataSetInfo*) libp->para[0].ref);
07902 }
07903 result7->obj.i = (long) p;
07904 result7->ref = (long) p;
07905 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform));
07906 return(1 || funcname || hash || result7 || libp) ;
07907 }
07908
07909 static int G__G__TMVA4_527_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07910 {
07911 ((TMVA::VariableNormalizeTransform*) G__getstructoffset())->BuildTransformationFromVarInfo(*(vector<TMVA::VariableInfo>*) libp->para[0].ref);
07912 G__setnull(result7);
07913 return(1 || funcname || hash || result7 || libp) ;
07914 }
07915
07916 static int G__G__TMVA4_527_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07917 {
07918 G__letint(result7, 85, (long) TMVA::VariableNormalizeTransform::Class());
07919 return(1 || funcname || hash || result7 || libp) ;
07920 }
07921
07922 static int G__G__TMVA4_527_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07923 {
07924 G__letint(result7, 67, (long) TMVA::VariableNormalizeTransform::Class_Name());
07925 return(1 || funcname || hash || result7 || libp) ;
07926 }
07927
07928 static int G__G__TMVA4_527_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07929 {
07930 G__letint(result7, 115, (long) TMVA::VariableNormalizeTransform::Class_Version());
07931 return(1 || funcname || hash || result7 || libp) ;
07932 }
07933
07934 static int G__G__TMVA4_527_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07935 {
07936 TMVA::VariableNormalizeTransform::Dictionary();
07937 G__setnull(result7);
07938 return(1 || funcname || hash || result7 || libp) ;
07939 }
07940
07941 static int G__G__TMVA4_527_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07942 {
07943 ((TMVA::VariableNormalizeTransform*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07944 G__setnull(result7);
07945 return(1 || funcname || hash || result7 || libp) ;
07946 }
07947
07948 static int G__G__TMVA4_527_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07949 {
07950 G__letint(result7, 67, (long) TMVA::VariableNormalizeTransform::DeclFileName());
07951 return(1 || funcname || hash || result7 || libp) ;
07952 }
07953
07954 static int G__G__TMVA4_527_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07955 {
07956 G__letint(result7, 105, (long) TMVA::VariableNormalizeTransform::ImplFileLine());
07957 return(1 || funcname || hash || result7 || libp) ;
07958 }
07959
07960 static int G__G__TMVA4_527_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07961 {
07962 G__letint(result7, 67, (long) TMVA::VariableNormalizeTransform::ImplFileName());
07963 return(1 || funcname || hash || result7 || libp) ;
07964 }
07965
07966 static int G__G__TMVA4_527_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07967 {
07968 G__letint(result7, 105, (long) TMVA::VariableNormalizeTransform::DeclFileLine());
07969 return(1 || funcname || hash || result7 || libp) ;
07970 }
07971
07972
07973 static int G__G__TMVA4_527_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07974
07975 {
07976 TMVA::VariableNormalizeTransform* p;
07977 void* tmp = (void*) G__int(libp->para[0]);
07978 p = new TMVA::VariableNormalizeTransform(*(TMVA::VariableNormalizeTransform*) tmp);
07979 result7->obj.i = (long) p;
07980 result7->ref = (long) p;
07981 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform));
07982 return(1 || funcname || hash || result7 || libp) ;
07983 }
07984
07985
07986 typedef TMVA::VariableNormalizeTransform G__TTMVAcLcLVariableNormalizeTransform;
07987 static int G__G__TMVA4_527_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07988 {
07989 char* gvp = (char*) G__getgvp();
07990 long soff = G__getstructoffset();
07991 int n = G__getaryconstruct();
07992
07993
07994
07995
07996
07997 if (!soff) {
07998 return(1);
07999 }
08000 if (n) {
08001 if (gvp == (char*)G__PVOID) {
08002 delete[] (TMVA::VariableNormalizeTransform*) soff;
08003 } else {
08004 G__setgvp((long) G__PVOID);
08005 for (int i = n - 1; i >= 0; --i) {
08006 ((TMVA::VariableNormalizeTransform*) (soff+(sizeof(TMVA::VariableNormalizeTransform)*i)))->~G__TTMVAcLcLVariableNormalizeTransform();
08007 }
08008 G__setgvp((long)gvp);
08009 }
08010 } else {
08011 if (gvp == (char*)G__PVOID) {
08012 delete (TMVA::VariableNormalizeTransform*) soff;
08013 } else {
08014 G__setgvp((long) G__PVOID);
08015 ((TMVA::VariableNormalizeTransform*) (soff))->~G__TTMVAcLcLVariableNormalizeTransform();
08016 G__setgvp((long)gvp);
08017 }
08018 }
08019 G__setnull(result7);
08020 return(1 || funcname || hash || result7 || libp) ;
08021 }
08022
08023
08024
08025
08026
08027
08028
08029
08030
08031
08032
08033
08034
08035
08036
08037
08038
08039
08040
08041
08042
08043
08044
08045
08046
08047
08048
08049
08050
08051
08052
08053
08054
08055
08056
08057
08058
08059
08060
08061
08062
08063
08064
08065
08066
08067
08068
08069
08070
08071
08072
08073
08074
08075
08076
08077
08078
08079
08080
08081
08082
08083
08084
08085
08086
08087
08088
08089 class G__Sizep2memfuncG__TMVA4 {
08090 public:
08091 G__Sizep2memfuncG__TMVA4(): p(&G__Sizep2memfuncG__TMVA4::sizep2memfunc) {}
08092 size_t sizep2memfunc() { return(sizeof(p)); }
08093 private:
08094 size_t (G__Sizep2memfuncG__TMVA4::*p)();
08095 };
08096
08097 size_t G__get_sizep2memfuncG__TMVA4()
08098 {
08099 G__Sizep2memfuncG__TMVA4 a;
08100 G__setsizep2memfunc((int)a.sizep2memfunc());
08101 return((size_t)a.sizep2memfunc());
08102 }
08103
08104
08105
08106
08107
08108
08109
08110 static long G__2vbo_TMVAcLcLMsgLogger_basic_ioslEcharcOchar_traitslEchargRsPgR_2(long pobject) {
08111 TMVA::MsgLogger *G__Lderived=(TMVA::MsgLogger*)pobject;
08112 basic_ios<char,char_traits<char> > *G__Lbase=G__Lderived;
08113 return((long)G__Lbase-(long)G__Lderived);
08114 }
08115
08116 static long G__2vbo_TMVAcLcLMsgLogger_ios_base_3(long pobject) {
08117 TMVA::MsgLogger *G__Lderived=(TMVA::MsgLogger*)pobject;
08118 ios_base *G__Lbase=G__Lderived;
08119 return((long)G__Lbase-(long)G__Lderived);
08120 }
08121
08122
08123
08124
08125
08126 extern "C" void G__cpp_setup_inheritanceG__TMVA4() {
08127
08128
08129 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron))) {
08130 TMVA::TNeuron *G__Lderived;
08131 G__Lderived=(TMVA::TNeuron*)0x1000;
08132 {
08133 TObject *G__Lpbase=(TObject*)G__Lderived;
08134 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
08135 }
08136 }
08137 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger))) {
08138 TMVA::MsgLogger *G__Lderived;
08139 G__Lderived=(TMVA::MsgLogger*)0x1000;
08140 {
08141 basic_ostringstream<char,char_traits<char>,allocator<char> > *G__Lpbase=(basic_ostringstream<char,char_traits<char>,allocator<char> >*)G__Lderived;
08142 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),G__get_linked_tagnum(&G__G__TMVA4LN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,1);
08143 }
08144 {
08145 basic_ostream<char,char_traits<char> > *G__Lpbase=(basic_ostream<char,char_traits<char> >*)G__Lderived;
08146 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),G__get_linked_tagnum(&G__G__TMVA4LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,0);
08147 }
08148 {
08149 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),G__get_linked_tagnum(&G__G__TMVA4LN_basic_ioslEcharcOchar_traitslEchargRsPgR),(long)G__2vbo_TMVAcLcLMsgLogger_basic_ioslEcharcOchar_traitslEchargRsPgR_2,1,2);
08150 }
08151 {
08152 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),G__get_linked_tagnum(&G__G__TMVA4LN_ios_base),(long)G__2vbo_TMVAcLcLMsgLogger_ios_base_3,1,6);
08153 }
08154 {
08155 TObject *G__Lpbase=(TObject*)G__Lderived;
08156 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
08157 }
08158 }
08159 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse))) {
08160 TMVA::TSynapse *G__Lderived;
08161 G__Lderived=(TMVA::TSynapse*)0x1000;
08162 {
08163 TObject *G__Lpbase=(TObject*)G__Lderived;
08164 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
08165 }
08166 }
08167 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid))) {
08168 TMVA::TActivationSigmoid *G__Lderived;
08169 G__Lderived=(TMVA::TActivationSigmoid*)0x1000;
08170 {
08171 TMVA::TActivation *G__Lpbase=(TMVA::TActivation*)G__Lderived;
08172 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation),(long)G__Lpbase-(long)G__Lderived,1,1);
08173 }
08174 }
08175 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity))) {
08176 TMVA::TActivationIdentity *G__Lderived;
08177 G__Lderived=(TMVA::TActivationIdentity*)0x1000;
08178 {
08179 TMVA::TActivation *G__Lpbase=(TMVA::TActivation*)G__Lderived;
08180 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation),(long)G__Lpbase-(long)G__Lderived,1,1);
08181 }
08182 }
08183 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh))) {
08184 TMVA::TActivationTanh *G__Lderived;
08185 G__Lderived=(TMVA::TActivationTanh*)0x1000;
08186 {
08187 TMVA::TActivation *G__Lpbase=(TMVA::TActivation*)G__Lderived;
08188 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation),(long)G__Lpbase-(long)G__Lderived,1,1);
08189 }
08190 }
08191 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial))) {
08192 TMVA::TActivationRadial *G__Lderived;
08193 G__Lderived=(TMVA::TActivationRadial*)0x1000;
08194 {
08195 TMVA::TActivation *G__Lpbase=(TMVA::TActivation*)G__Lderived;
08196 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation),(long)G__Lpbase-(long)G__Lderived,1,1);
08197 }
08198 }
08199 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum))) {
08200 TMVA::TNeuronInputSum *G__Lderived;
08201 G__Lderived=(TMVA::TNeuronInputSum*)0x1000;
08202 {
08203 TMVA::TNeuronInput *G__Lpbase=(TMVA::TNeuronInput*)G__Lderived;
08204 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput),(long)G__Lpbase-(long)G__Lderived,1,1);
08205 }
08206 }
08207 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum))) {
08208 TMVA::TNeuronInputSqSum *G__Lderived;
08209 G__Lderived=(TMVA::TNeuronInputSqSum*)0x1000;
08210 {
08211 TMVA::TNeuronInput *G__Lpbase=(TMVA::TNeuronInput*)G__Lderived;
08212 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput),(long)G__Lpbase-(long)G__Lderived,1,1);
08213 }
08214 }
08215 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs))) {
08216 TMVA::TNeuronInputAbs *G__Lderived;
08217 G__Lderived=(TMVA::TNeuronInputAbs*)0x1000;
08218 {
08219 TMVA::TNeuronInput *G__Lpbase=(TMVA::TNeuronInput*)G__Lderived;
08220 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput),(long)G__Lpbase-(long)G__Lderived,1,1);
08221 }
08222 }
08223 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase))) {
08224 TMVA::VariableTransformBase *G__Lderived;
08225 G__Lderived=(TMVA::VariableTransformBase*)0x1000;
08226 {
08227 TObject *G__Lpbase=(TObject*)G__Lderived;
08228 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
08229 }
08230 }
08231 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform))) {
08232 TMVA::VariableIdentityTransform *G__Lderived;
08233 G__Lderived=(TMVA::VariableIdentityTransform*)0x1000;
08234 {
08235 TMVA::VariableTransformBase *G__Lpbase=(TMVA::VariableTransformBase*)G__Lderived;
08236 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase),(long)G__Lpbase-(long)G__Lderived,1,1);
08237 }
08238 {
08239 TObject *G__Lpbase=(TObject*)G__Lderived;
08240 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
08241 }
08242 }
08243 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform))) {
08244 TMVA::VariableDecorrTransform *G__Lderived;
08245 G__Lderived=(TMVA::VariableDecorrTransform*)0x1000;
08246 {
08247 TMVA::VariableTransformBase *G__Lpbase=(TMVA::VariableTransformBase*)G__Lderived;
08248 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase),(long)G__Lpbase-(long)G__Lderived,1,1);
08249 }
08250 {
08251 TObject *G__Lpbase=(TObject*)G__Lderived;
08252 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
08253 }
08254 }
08255 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform))) {
08256 TMVA::VariablePCATransform *G__Lderived;
08257 G__Lderived=(TMVA::VariablePCATransform*)0x1000;
08258 {
08259 TMVA::VariableTransformBase *G__Lpbase=(TMVA::VariableTransformBase*)G__Lderived;
08260 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase),(long)G__Lpbase-(long)G__Lderived,1,1);
08261 }
08262 {
08263 TObject *G__Lpbase=(TObject*)G__Lderived;
08264 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
08265 }
08266 }
08267 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform))) {
08268 TMVA::VariableGaussTransform *G__Lderived;
08269 G__Lderived=(TMVA::VariableGaussTransform*)0x1000;
08270 {
08271 TMVA::VariableTransformBase *G__Lpbase=(TMVA::VariableTransformBase*)G__Lderived;
08272 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase),(long)G__Lpbase-(long)G__Lderived,1,1);
08273 }
08274 {
08275 TObject *G__Lpbase=(TObject*)G__Lderived;
08276 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
08277 }
08278 }
08279 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform))) {
08280 TMVA::VariableNormalizeTransform *G__Lderived;
08281 G__Lderived=(TMVA::VariableNormalizeTransform*)0x1000;
08282 {
08283 TMVA::VariableTransformBase *G__Lpbase=(TMVA::VariableTransformBase*)G__Lderived;
08284 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase),(long)G__Lpbase-(long)G__Lderived,1,1);
08285 }
08286 {
08287 TObject *G__Lpbase=(TObject*)G__Lderived;
08288 G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
08289 }
08290 }
08291 }
08292
08293
08294
08295
08296 extern "C" void G__cpp_setup_typetableG__TMVA4() {
08297
08298
08299 G__search_typename2("Int_t",105,-1,0,-1);
08300 G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
08301 G__search_typename2("UInt_t",104,-1,0,-1);
08302 G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
08303 G__search_typename2("Double_t",100,-1,0,-1);
08304 G__setnewtype(-1,"Double 8 bytes",0);
08305 G__search_typename2("Bool_t",103,-1,0,-1);
08306 G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
08307 G__search_typename2("Version_t",115,-1,0,-1);
08308 G__setnewtype(-1,"Class version identifier (short)",0);
08309 G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
08310 G__setnewtype(-1,NULL,0);
08311 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
08312 G__setnewtype(-1,NULL,0);
08313 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
08314 G__setnewtype(-1,NULL,0);
08315 G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
08316 G__setnewtype(-1,NULL,0);
08317 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
08318 G__setnewtype(-1,NULL,0);
08319 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
08320 G__setnewtype(-1,NULL,0);
08321 G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__TMVA4LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
08322 G__setnewtype(-1,NULL,0);
08323 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
08324 G__setnewtype(-1,NULL,0);
08325 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__G__TMVA4LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
08326 G__setnewtype(-1,NULL,0);
08327 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__G__TMVA4LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
08328 G__setnewtype(-1,NULL,0);
08329 G__search_typename2("TMVAVersion_t",104,-1,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVA));
08330 G__setnewtype(-1,NULL,0);
08331 G__search_typename2("map<TString,TMVA::Types::EMVA>",117,G__get_linked_tagnum(&G__G__TMVA4LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR),0,-1);
08332 G__setnewtype(-1,NULL,0);
08333 G__search_typename2("map<TString,TMVA::Types::EMVA,less<TString> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR),0,-1);
08334 G__setnewtype(-1,NULL,0);
08335 G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
08336 G__setnewtype(-1,NULL,0);
08337 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR));
08338 G__setnewtype(-1,NULL,0);
08339 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR));
08340 G__setnewtype(-1,NULL,0);
08341 G__search_typename2("vector<TMVA::Rank>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgR),0,-1);
08342 G__setnewtype(-1,NULL,0);
08343 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgR));
08344 G__setnewtype(-1,NULL,0);
08345 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgR));
08346 G__setnewtype(-1,NULL,0);
08347 G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TVectorTlEfloatgR),0,-1);
08348 G__setnewtype(-1,NULL,0);
08349 G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TVectorTlEdoublegR),0,-1);
08350 G__setnewtype(-1,NULL,0);
08351 G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTBaselEfloatgR),0,-1);
08352 G__setnewtype(-1,NULL,0);
08353 G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTBaselEdoublegR),0,-1);
08354 G__setnewtype(-1,NULL,0);
08355 G__search_typename2("vector<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
08356 G__setnewtype(-1,NULL,0);
08357 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR));
08358 G__setnewtype(-1,NULL,0);
08359 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR));
08360 G__setnewtype(-1,NULL,0);
08361 G__search_typename2("vector<float>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
08362 G__setnewtype(-1,NULL,0);
08363 G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
08364 G__setnewtype(-1,NULL,0);
08365 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
08366 G__setnewtype(-1,NULL,0);
08367 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
08368 G__setnewtype(-1,NULL,0);
08369 G__search_typename2("vector<double>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
08370 G__setnewtype(-1,NULL,0);
08371 G__search_typename2("vector<const TMVA::BinarySearchTreeNode*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR),0,-1);
08372 G__setnewtype(-1,NULL,0);
08373 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR));
08374 G__setnewtype(-1,NULL,0);
08375 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR));
08376 G__setnewtype(-1,NULL,0);
08377 G__search_typename2("vector<TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,-1);
08378 G__setnewtype(-1,NULL,0);
08379 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR));
08380 G__setnewtype(-1,NULL,0);
08381 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR));
08382 G__setnewtype(-1,NULL,0);
08383 G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
08384 G__setnewtype(-1,NULL,0);
08385 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR));
08386 G__setnewtype(-1,NULL,0);
08387 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR));
08388 G__setnewtype(-1,NULL,0);
08389 G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
08390 G__setnewtype(-1,NULL,0);
08391 G__search_typename2("pair<Double_t,const TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR),0,-1);
08392 G__setnewtype(-1,NULL,0);
08393 G__search_typename2("vector<std::pair<Double_t,const TMVA::Event*> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR),0,-1);
08394 G__setnewtype(-1,NULL,0);
08395 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR));
08396 G__setnewtype(-1,NULL,0);
08397 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR));
08398 G__setnewtype(-1,NULL,0);
08399 G__search_typename2("vector<pair<double,const TMVA::Event*> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR),0,-1);
08400 G__setnewtype(-1,NULL,0);
08401 G__search_typename2("vector<Float_t*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR),0,-1);
08402 G__setnewtype(-1,NULL,0);
08403 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR));
08404 G__setnewtype(-1,NULL,0);
08405 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR));
08406 G__setnewtype(-1,NULL,0);
08407 G__search_typename2("vector<float*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR),0,-1);
08408 G__setnewtype(-1,NULL,0);
08409 G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
08410 G__setnewtype(-1,NULL,0);
08411 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
08412 G__setnewtype(-1,NULL,0);
08413 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
08414 G__setnewtype(-1,NULL,0);
08415 G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
08416 G__setnewtype(-1,NULL,0);
08417 G__search_typename2("vector<const TMVA::Node*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR),0,-1);
08418 G__setnewtype(-1,NULL,0);
08419 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR));
08420 G__setnewtype(-1,NULL,0);
08421 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR));
08422 G__setnewtype(-1,NULL,0);
08423 G__search_typename2("vector<Char_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEcharcOallocatorlEchargRsPgR),0,-1);
08424 G__setnewtype(-1,NULL,0);
08425 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEcharcOallocatorlEchargRsPgR));
08426 G__setnewtype(-1,NULL,0);
08427 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEcharcOallocatorlEchargRsPgR));
08428 G__setnewtype(-1,NULL,0);
08429 G__search_typename2("vector<char>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEcharcOallocatorlEchargRsPgR),0,-1);
08430 G__setnewtype(-1,NULL,0);
08431 G__search_typename2("vector<const TMVA::DecisionTree*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR),0,-1);
08432 G__setnewtype(-1,NULL,0);
08433 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR));
08434 G__setnewtype(-1,NULL,0);
08435 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR));
08436 G__setnewtype(-1,NULL,0);
08437 G__search_typename2("vector<TMVA::Rule*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR),0,-1);
08438 G__setnewtype(-1,NULL,0);
08439 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR));
08440 G__setnewtype(-1,NULL,0);
08441 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR));
08442 G__setnewtype(-1,NULL,0);
08443 G__search_typename2("vector<TH1F*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR),0,-1);
08444 G__setnewtype(-1,NULL,0);
08445 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR));
08446 G__setnewtype(-1,NULL,0);
08447 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR));
08448 G__setnewtype(-1,NULL,0);
08449 G__search_typename2("vector<std::vector<UInt_t> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR),0,-1);
08450 G__setnewtype(-1,NULL,0);
08451 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR));
08452 G__setnewtype(-1,NULL,0);
08453 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR));
08454 G__setnewtype(-1,NULL,0);
08455 G__search_typename2("vector<vector<unsigned int,allocator<unsigned int> > >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR),0,-1);
08456 G__setnewtype(-1,NULL,0);
08457 G__search_typename2("vector<std::vector<Double_t> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
08458 G__setnewtype(-1,NULL,0);
08459 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
08460 G__setnewtype(-1,NULL,0);
08461 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
08462 G__setnewtype(-1,NULL,0);
08463 G__search_typename2("vector<vector<double,allocator<double> > >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
08464 G__setnewtype(-1,NULL,0);
08465 G__search_typename2("vector<TH2F*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR),0,-1);
08466 G__setnewtype(-1,NULL,0);
08467 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETH2FmUcOallocatorlETH2FmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR));
08468 G__setnewtype(-1,NULL,0);
08469 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETH2FmUcOallocatorlETH2FmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR));
08470 G__setnewtype(-1,NULL,0);
08471 G__search_typename2("vector<const TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR),0,-1);
08472 G__setnewtype(-1,NULL,0);
08473 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR));
08474 G__setnewtype(-1,NULL,0);
08475 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR));
08476 G__setnewtype(-1,NULL,0);
08477 G__search_typename2("std::ios& (*)(std::ios&) ",49,-1,0,-1);
08478 G__setnewtype(-1,NULL,0);
08479 G__search_typename2("map<EMsgType,std::string>",117,G__get_linked_tagnum(&G__G__TMVA4LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),0,-1);
08480 G__setnewtype(-1,NULL,0);
08481 G__search_typename2("map<TMVA::EMsgType,string>",117,G__get_linked_tagnum(&G__G__TMVA4LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),0,-1);
08482 G__setnewtype(-1,NULL,0);
08483 G__search_typename2("map<TMVA::EMsgType,string,less<TMVA::EMsgType> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),0,-1);
08484 G__setnewtype(-1,NULL,0);
08485 G__search_typename2("IntParms",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLIntParms),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPI));
08486 G__setnewtype(-1,NULL,0);
08487 G__search_typename2("RealParms",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLRealParms),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPI));
08488 G__setnewtype(-1,NULL,0);
08489 G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
08490 G__setnewtype(-1,NULL,0);
08491 G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
08492 G__setnewtype(-1,NULL,0);
08493 G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
08494 G__setnewtype(-1,NULL,0);
08495 G__search_typename2("TMatrixT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTlEdoublegR),0,-1);
08496 G__setnewtype(-1,NULL,0);
08497 G__search_typename2("vector<VariableInfo>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),0,-1);
08498 G__setnewtype(-1,NULL,0);
08499 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR));
08500 G__setnewtype(-1,NULL,0);
08501 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR));
08502 G__setnewtype(-1,NULL,0);
08503 G__search_typename2("vector<TMVA::VariableInfo>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),0,-1);
08504 G__setnewtype(-1,NULL,0);
08505 G__search_typename2("vector<ClassInfo*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR),0,-1);
08506 G__setnewtype(-1,NULL,0);
08507 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR));
08508 G__setnewtype(-1,NULL,0);
08509 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR));
08510 G__setnewtype(-1,NULL,0);
08511 G__search_typename2("vector<TMVA::ClassInfo*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR),0,-1);
08512 G__setnewtype(-1,NULL,0);
08513 G__search_typename2("vector<Event*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase));
08514 G__setnewtype(-1,NULL,0);
08515 G__search_typename2("TMatrixTSym<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSymlEdoublegR),0,-1);
08516 G__setnewtype(-1,NULL,0);
08517 G__search_typename2("vector<TMatrixD*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR),0,-1);
08518 G__setnewtype(-1,NULL,0);
08519 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR));
08520 G__setnewtype(-1,NULL,0);
08521 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR));
08522 G__setnewtype(-1,NULL,0);
08523 G__search_typename2("vector<TMatrixT<double>*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR),0,-1);
08524 G__setnewtype(-1,NULL,0);
08525 G__search_typename2("TMatrixTRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTRow_constlEdoublegR),0,-1);
08526 G__setnewtype(-1,NULL,0);
08527 G__search_typename2("TMatrixTColumn_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTColumn_constlEdoublegR),0,-1);
08528 G__setnewtype(-1,NULL,0);
08529 G__search_typename2("TMatrixTDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTDiag_constlEdoublegR),0,-1);
08530 G__setnewtype(-1,NULL,0);
08531 G__search_typename2("TMatrixTFlat_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTFlat_constlEdoublegR),0,-1);
08532 G__setnewtype(-1,NULL,0);
08533 G__search_typename2("TMatrixTSub_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSub_constlEdoublegR),0,-1);
08534 G__setnewtype(-1,NULL,0);
08535 G__search_typename2("TMatrixTSparseRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSparseRow_constlEdoublegR),0,-1);
08536 G__setnewtype(-1,NULL,0);
08537 G__search_typename2("TMatrixTSparseDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSparseDiag_constlEdoublegR),0,-1);
08538 G__setnewtype(-1,NULL,0);
08539 G__search_typename2("TMatrixTRow<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTRowlEdoublegR),0,-1);
08540 G__setnewtype(-1,NULL,0);
08541 G__search_typename2("TMatrixTColumn<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTColumnlEdoublegR),0,-1);
08542 G__setnewtype(-1,NULL,0);
08543 G__search_typename2("TMatrixTDiag<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTDiaglEdoublegR),0,-1);
08544 G__setnewtype(-1,NULL,0);
08545 G__search_typename2("TMatrixTFlat<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTFlatlEdoublegR),0,-1);
08546 G__setnewtype(-1,NULL,0);
08547 G__search_typename2("TMatrixTSub<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSublEdoublegR),0,-1);
08548 G__setnewtype(-1,NULL,0);
08549 G__search_typename2("TMatrixTSparseRow<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSparseRowlEdoublegR),0,-1);
08550 G__setnewtype(-1,NULL,0);
08551 G__search_typename2("TMatrixTSparseDiag<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSparseDiaglEdoublegR),0,-1);
08552 G__setnewtype(-1,NULL,0);
08553 G__search_typename2("TElementActionT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TElementActionTlEdoublegR),0,-1);
08554 G__setnewtype(-1,NULL,0);
08555 G__search_typename2("TElementPosActionT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TElementPosActionTlEdoublegR),0,-1);
08556 G__setnewtype(-1,NULL,0);
08557 G__search_typename2("TMatrixTSparse<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSparselEdoublegR),0,-1);
08558 G__setnewtype(-1,NULL,0);
08559 G__search_typename2("vector<TVectorD*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR),0,-1);
08560 G__setnewtype(-1,NULL,0);
08561 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR));
08562 G__setnewtype(-1,NULL,0);
08563 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR));
08564 G__setnewtype(-1,NULL,0);
08565 G__search_typename2("vector<TVectorT<double>*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR),0,-1);
08566 G__setnewtype(-1,NULL,0);
08567 G__search_typename2("Option<Bool_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLOptionlEboolgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVA));
08568 G__setnewtype(-1,NULL,0);
08569 G__search_typename2("vector<bool>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEboolcOallocatorlEboolgRsPgR),0,-1);
08570 G__setnewtype(-1,NULL,0);
08571 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEboolcOallocatorlEboolgRsPgR));
08572 G__setnewtype(-1,NULL,0);
08573 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEboolcOallocatorlEboolgRsPgR));
08574 G__setnewtype(-1,NULL,0);
08575 G__search_typename2("Option<Bool_t*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLOptionlEboolmUgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVA));
08576 G__setnewtype(-1,NULL,0);
08577 G__search_typename2("Option<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLOptionlEfloatgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVA));
08578 G__setnewtype(-1,NULL,0);
08579 G__search_typename2("vector<std::vector<TH1F*> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR),0,-1);
08580 G__setnewtype(-1,NULL,0);
08581 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR));
08582 G__setnewtype(-1,NULL,0);
08583 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR));
08584 G__setnewtype(-1,NULL,0);
08585 G__search_typename2("vector<vector<TH1F*,allocator<TH1F*> > >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR),0,-1);
08586 G__setnewtype(-1,NULL,0);
08587 G__search_typename2("vector<PDF*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR),0,-1);
08588 G__setnewtype(-1,NULL,0);
08589 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR));
08590 G__setnewtype(-1,NULL,0);
08591 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR));
08592 G__setnewtype(-1,NULL,0);
08593 G__search_typename2("vector<TMVA::PDF*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR),0,-1);
08594 G__setnewtype(-1,NULL,0);
08595 G__search_typename2("vector<std::vector<PDF*> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR),0,-1);
08596 G__setnewtype(-1,NULL,0);
08597 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR));
08598 G__setnewtype(-1,NULL,0);
08599 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR));
08600 G__setnewtype(-1,NULL,0);
08601 G__search_typename2("vector<vector<TMVA::PDF*,allocator<TMVA::PDF*> > >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR),0,-1);
08602 G__setnewtype(-1,NULL,0);
08603 G__search_typename2("vector<std::vector<Float_t> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,-1);
08604 G__setnewtype(-1,NULL,0);
08605 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR));
08606 G__setnewtype(-1,NULL,0);
08607 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR));
08608 G__setnewtype(-1,NULL,0);
08609 G__search_typename2("vector<vector<float,allocator<float> > >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,-1);
08610 G__setnewtype(-1,NULL,0);
08611 }
08612
08613
08614
08615
08616
08617
08618
08619
08620 static void G__setup_memvarTMVA(void) {
08621 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVA));
08622 {
08623 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kDEBUG=%lldLL",(long long)TMVA::kDEBUG).data(),0,(char*)NULL);
08624 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kVERBOSE=%lldLL",(long long)TMVA::kVERBOSE).data(),0,(char*)NULL);
08625 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kINFO=%lldLL",(long long)TMVA::kINFO).data(),0,(char*)NULL);
08626 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kWARNING=%lldLL",(long long)TMVA::kWARNING).data(),0,(char*)NULL);
08627 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kERROR=%lldLL",(long long)TMVA::kERROR).data(),0,(char*)NULL);
08628 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kFATAL=%lldLL",(long long)TMVA::kFATAL).data(),0,(char*)NULL);
08629 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kSILENT=%lldLL",(long long)TMVA::kSILENT).data(),0,(char*)NULL);
08630 }
08631 G__tag_memvar_reset();
08632 }
08633
08634
08635
08636 static void G__setup_memvarTMVAcLcLTNeuron(void) {
08637 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron));
08638 { TMVA::TNeuron *p; p=(TMVA::TNeuron*)0x1000; if (p) { }
08639 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TObjArray),-1,-1,4,"fLinksIn=",0,"array of input synapses");
08640 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TObjArray),-1,-1,4,"fLinksOut=",0,"array of output synapses");
08641 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fValue=",0,"input value");
08642 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fActivationValue=",0,"activation/output value");
08643 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDelta=",0,"error field of neuron");
08644 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDEDw=",0,"sum of all deltas");
08645 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fError=",0,"error, only set for output neurons");
08646 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fForcedValue=",0,"flag for forced input value");
08647 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation),-1,-1,4,"fActivation=",0,"activation equation");
08648 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput),-1,-1,4,"fInputCalculator=",0,"input calculator");
08649 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-2,4,"fgLogger=",0,"! message logger, static to save resources");
08650 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08651 }
08652 G__tag_memvar_reset();
08653 }
08654
08655
08656
08657 static void G__setup_memvarTMVAcLcLMsgLogger(void) {
08658 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger));
08659 { TMVA::MsgLogger *p; p=(TMVA::MsgLogger*)0x1000; if (p) { }
08660 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TObject),-1,-1,4,"fObjSource=",0,"the source TObject (used for name)");
08661 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_string),-1,-1,4,"fStrSource=",0,"alternative string source");
08662 G__memvar_setup((void*)0,117,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_string),-1,-2,4,"fgPrefix=",0,"the prefix of the source name");
08663 G__memvar_setup((void*)0,117,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_string),-1,-2,4,"fgSuffix=",0,"suffix following source name");
08664 G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEMsgType),-1,-1,4,"fActiveType=",0,"active type");
08665 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,4,"fgMaxSourceSize=",0,"maximum length of source name");
08666 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgOutputSupressed=",0,"disable the output globaly (used by generic booster)");
08667 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgInhibitOutput=",0,"flag to suppress all output");
08668 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgInstanceCounter=",0,"counts open MsgLogger instances");
08669 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),G__defined_typename("map<EMsgType,std::string>"),-2,4,"fgTypeMap=",0,"matches output types with strings");
08670 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),G__defined_typename("map<EMsgType,std::string>"),-2,4,"fgColorMap=",0,"matches output types with terminal colors");
08671 G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEMsgType),-1,-1,4,"fMinType=",0,"minimum type for output");
08672 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08673 }
08674 G__tag_memvar_reset();
08675 }
08676
08677
08678
08679 static void G__setup_memvarTMVAcLcLTSynapse(void) {
08680 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse));
08681 { TMVA::TSynapse *p; p=(TMVA::TSynapse*)0x1000; if (p) { }
08682 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fWeight=",0,"weight of the synapse");
08683 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLearnRate=",0,"learning rate parameter");
08684 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDelta=",0,"local error field");
08685 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDEDw=",0,"sum of deltas");
08686 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCount=",0,"number of updates contributing to error field");
08687 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron),-1,-1,4,"fPreNeuron=",0,"pointer to pre-neuron");
08688 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron),-1,-1,4,"fPostNeuron=",0,"pointer to post-neuron");
08689 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-2,4,"fgLogger=",0,"! message logger, static to save resources");
08690 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08691 }
08692 G__tag_memvar_reset();
08693 }
08694
08695
08696
08697 static void G__setup_memvarTMVAcLcLTActivation(void) {
08698 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation));
08699 { TMVA::TActivation *p; p=(TMVA::TActivation*)0x1000; if (p) { }
08700 G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
08701 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08702 }
08703 G__tag_memvar_reset();
08704 }
08705
08706
08707
08708 static void G__setup_memvarTMVAcLcLTypes(void) {
08709 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypes));
08710 { TMVA::Types *p; p=(TMVA::Types*)0x1000; if (p) { }
08711 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kVariable=%lldLL",(long long)TMVA::Types::kVariable).data(),0,(char*)NULL);
08712 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kCuts=%lldLL",(long long)TMVA::Types::kCuts).data(),0,(char*)NULL);
08713 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kLikelihood=%lldLL",(long long)TMVA::Types::kLikelihood).data(),0,(char*)NULL);
08714 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kPDERS=%lldLL",(long long)TMVA::Types::kPDERS).data(),0,(char*)NULL);
08715 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kHMatrix=%lldLL",(long long)TMVA::Types::kHMatrix).data(),0,(char*)NULL);
08716 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kFisher=%lldLL",(long long)TMVA::Types::kFisher).data(),0,(char*)NULL);
08717 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kKNN=%lldLL",(long long)TMVA::Types::kKNN).data(),0,(char*)NULL);
08718 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kCFMlpANN=%lldLL",(long long)TMVA::Types::kCFMlpANN).data(),0,(char*)NULL);
08719 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kTMlpANN=%lldLL",(long long)TMVA::Types::kTMlpANN).data(),0,(char*)NULL);
08720 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kBDT=%lldLL",(long long)TMVA::Types::kBDT).data(),0,(char*)NULL);
08721 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kDT=%lldLL",(long long)TMVA::Types::kDT).data(),0,(char*)NULL);
08722 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kRuleFit=%lldLL",(long long)TMVA::Types::kRuleFit).data(),0,(char*)NULL);
08723 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kSVM=%lldLL",(long long)TMVA::Types::kSVM).data(),0,(char*)NULL);
08724 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kMLP=%lldLL",(long long)TMVA::Types::kMLP).data(),0,(char*)NULL);
08725 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kBayesClassifier=%lldLL",(long long)TMVA::Types::kBayesClassifier).data(),0,(char*)NULL);
08726 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kFDA=%lldLL",(long long)TMVA::Types::kFDA).data(),0,(char*)NULL);
08727 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kCommittee=%lldLL",(long long)TMVA::Types::kCommittee).data(),0,(char*)NULL);
08728 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kBoost=%lldLL",(long long)TMVA::Types::kBoost).data(),0,(char*)NULL);
08729 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kPDEFoam=%lldLL",(long long)TMVA::Types::kPDEFoam).data(),0,(char*)NULL);
08730 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kLD=%lldLL",(long long)TMVA::Types::kLD).data(),0,(char*)NULL);
08731 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kPlugins=%lldLL",(long long)TMVA::Types::kPlugins).data(),0,(char*)NULL);
08732 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kCategory=%lldLL",(long long)TMVA::Types::kCategory).data(),0,(char*)NULL);
08733 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kMaxMethod=%lldLL",(long long)TMVA::Types::kMaxMethod).data(),0,(char*)NULL);
08734 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kIdentity=%lldLL",(long long)TMVA::Types::kIdentity).data(),0,(char*)NULL);
08735 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kDecorrelated=%lldLL",(long long)TMVA::Types::kDecorrelated).data(),0,(char*)NULL);
08736 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kNormalized=%lldLL",(long long)TMVA::Types::kNormalized).data(),0,(char*)NULL);
08737 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kPCA=%lldLL",(long long)TMVA::Types::kPCA).data(),0,(char*)NULL);
08738 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kGaussDecorr=%lldLL",(long long)TMVA::Types::kGaussDecorr).data(),0,(char*)NULL);
08739 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kGauss=%lldLL",(long long)TMVA::Types::kGauss).data(),0,(char*)NULL);
08740 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kUniform=%lldLL",(long long)TMVA::Types::kUniform).data(),0,(char*)NULL);
08741 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kMaxVariableTransform=%lldLL",(long long)TMVA::Types::kMaxVariableTransform).data(),0,(char*)NULL);
08742 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType),-1,-2,1,G__FastAllocString(2048).Format("kClassification=%lldLL",(long long)TMVA::Types::kClassification).data(),0,(char*)NULL);
08743 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType),-1,-2,1,G__FastAllocString(2048).Format("kRegression=%lldLL",(long long)TMVA::Types::kRegression).data(),0,(char*)NULL);
08744 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType),-1,-2,1,G__FastAllocString(2048).Format("kMulticlass=%lldLL",(long long)TMVA::Types::kMulticlass).data(),0,(char*)NULL);
08745 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType),-1,-2,1,G__FastAllocString(2048).Format("kNoAnalysisType=%lldLL",(long long)TMVA::Types::kNoAnalysisType).data(),0,(char*)NULL);
08746 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType),-1,-2,1,G__FastAllocString(2048).Format("kMaxAnalysisType=%lldLL",(long long)TMVA::Types::kMaxAnalysisType).data(),0,(char*)NULL);
08747 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLESBType),-1,-2,1,G__FastAllocString(2048).Format("kSignal=%lldLL",(long long)TMVA::Types::kSignal).data(),0,(char*)NULL);
08748 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLESBType),-1,-2,1,G__FastAllocString(2048).Format("kBackground=%lldLL",(long long)TMVA::Types::kBackground).data(),0,(char*)NULL);
08749 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLESBType),-1,-2,1,G__FastAllocString(2048).Format("kSBBoth=%lldLL",(long long)TMVA::Types::kSBBoth).data(),0,(char*)NULL);
08750 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLESBType),-1,-2,1,G__FastAllocString(2048).Format("kMaxSBType=%lldLL",(long long)TMVA::Types::kMaxSBType).data(),0,(char*)NULL);
08751 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLESBType),-1,-2,1,G__FastAllocString(2048).Format("kTrueType=%lldLL",(long long)TMVA::Types::kTrueType).data(),0,(char*)NULL);
08752 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType),-1,-2,1,G__FastAllocString(2048).Format("kTraining=%lldLL",(long long)TMVA::Types::kTraining).data(),0,(char*)NULL);
08753 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType),-1,-2,1,G__FastAllocString(2048).Format("kTesting=%lldLL",(long long)TMVA::Types::kTesting).data(),0,(char*)NULL);
08754 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType),-1,-2,1,G__FastAllocString(2048).Format("kMaxTreeType=%lldLL",(long long)TMVA::Types::kMaxTreeType).data(),0,(char*)NULL);
08755 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType),-1,-2,1,G__FastAllocString(2048).Format("kValidation=%lldLL",(long long)TMVA::Types::kValidation).data(),0,(char*)NULL);
08756 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType),-1,-2,1,G__FastAllocString(2048).Format("kTrainingOriginal=%lldLL",(long long)TMVA::Types::kTrainingOriginal).data(),0,(char*)NULL);
08757 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage),-1,-2,1,G__FastAllocString(2048).Format("kBoostProcBegin=%lldLL",(long long)TMVA::Types::kBoostProcBegin).data(),0,(char*)NULL);
08758 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage),-1,-2,1,G__FastAllocString(2048).Format("kBeforeTraining=%lldLL",(long long)TMVA::Types::kBeforeTraining).data(),0,(char*)NULL);
08759 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage),-1,-2,1,G__FastAllocString(2048).Format("kBeforeBoosting=%lldLL",(long long)TMVA::Types::kBeforeBoosting).data(),0,(char*)NULL);
08760 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage),-1,-2,1,G__FastAllocString(2048).Format("kAfterBoosting=%lldLL",(long long)TMVA::Types::kAfterBoosting).data(),0,(char*)NULL);
08761 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage),-1,-2,1,G__FastAllocString(2048).Format("kBoostValidation=%lldLL",(long long)TMVA::Types::kBoostValidation).data(),0,(char*)NULL);
08762 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage),-1,-2,1,G__FastAllocString(2048).Format("kBoostProcEnd=%lldLL",(long long)TMVA::Types::kBoostProcEnd).data(),0,(char*)NULL);
08763 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypes),-1,-2,4,"fgTypesPtr=",0,(char*)NULL);
08764 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR),G__defined_typename("map<TString,TMVA::Types::EMVA>"),-1,4,"fStr2type=",0,"types-to-text map");
08765 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"message logger");
08766 }
08767 G__tag_memvar_reset();
08768 }
08769
08770
08771
08772 static void G__setup_memvarTMVAcLcLTNeuronInput(void) {
08773 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput));
08774 { TMVA::TNeuronInput *p; p=(TMVA::TNeuronInput*)0x1000; if (p) { }
08775 G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
08776 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08777 }
08778 G__tag_memvar_reset();
08779 }
08780
08781
08782
08783 static void G__setup_memvarTMVAcLcLTActivationChooser(void) {
08784 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChooser));
08785 { TMVA::TActivationChooser *p; p=(TMVA::TActivationChooser*)0x1000; if (p) { }
08786 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChoosercLcLEActivationType),-1,-2,1,G__FastAllocString(2048).Format("kLinear=%lldLL",(long long)TMVA::TActivationChooser::kLinear).data(),0,(char*)NULL);
08787 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChoosercLcLEActivationType),-1,-2,1,G__FastAllocString(2048).Format("kSigmoid=%lldLL",(long long)TMVA::TActivationChooser::kSigmoid).data(),0,(char*)NULL);
08788 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChoosercLcLEActivationType),-1,-2,1,G__FastAllocString(2048).Format("kTanh=%lldLL",(long long)TMVA::TActivationChooser::kTanh).data(),0,(char*)NULL);
08789 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChoosercLcLEActivationType),-1,-2,1,G__FastAllocString(2048).Format("kRadial=%lldLL",(long long)TMVA::TActivationChooser::kRadial).data(),0,(char*)NULL);
08790 G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
08791 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fLINEAR=",0,"activation function name");
08792 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fSIGMOID=",0,"activation function name");
08793 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fTANH=",0,"activation function name");
08794 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fRADIAL=",0,"activation function name");
08795 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"! message logger");
08796 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08797 }
08798 G__tag_memvar_reset();
08799 }
08800
08801
08802
08803 static void G__setup_memvarTMVAcLcLTActivationSigmoid(void) {
08804 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid));
08805 { TMVA::TActivationSigmoid *p; p=(TMVA::TActivationSigmoid*)0x1000; if (p) { }
08806 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TFormula),-1,-1,4,"fEqn=",0,"equation of sigmoid");
08807 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TFormula),-1,-1,4,"fEqnDerivative=",0,"equation of sigmoid derivative");
08808 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08809 }
08810 G__tag_memvar_reset();
08811 }
08812
08813
08814
08815 static void G__setup_memvarTMVAcLcLTActivationIdentity(void) {
08816 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity));
08817 { TMVA::TActivationIdentity *p; p=(TMVA::TActivationIdentity*)0x1000; if (p) { }
08818 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08819 }
08820 G__tag_memvar_reset();
08821 }
08822
08823
08824
08825 static void G__setup_memvarTMVAcLcLTActivationTanh(void) {
08826 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh));
08827 { TMVA::TActivationTanh *p; p=(TMVA::TActivationTanh*)0x1000; if (p) { }
08828 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TFormula),-1,-1,4,"fEqn=",0,"equation of tanh sigmoid");
08829 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TFormula),-1,-1,4,"fEqnDerivative=",0,"equation of tanh sigmoid derivative");
08830 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08831 }
08832 G__tag_memvar_reset();
08833 }
08834
08835
08836
08837 static void G__setup_memvarTMVAcLcLTActivationRadial(void) {
08838 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial));
08839 { TMVA::TActivationRadial *p; p=(TMVA::TActivationRadial*)0x1000; if (p) { }
08840 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TFormula),-1,-1,4,"fEqn=",0,"equation of radial basis function");
08841 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TFormula),-1,-1,4,"fEqnDerivative=",0,"equation of derivative");
08842 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08843 }
08844 G__tag_memvar_reset();
08845 }
08846
08847
08848
08849 static void G__setup_memvarTMVAcLcLTNeuronInputSum(void) {
08850 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum));
08851 { TMVA::TNeuronInputSum *p; p=(TMVA::TNeuronInputSum*)0x1000; if (p) { }
08852 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08853 }
08854 G__tag_memvar_reset();
08855 }
08856
08857
08858
08859 static void G__setup_memvarTMVAcLcLTNeuronInputSqSum(void) {
08860 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum));
08861 { TMVA::TNeuronInputSqSum *p; p=(TMVA::TNeuronInputSqSum*)0x1000; if (p) { }
08862 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08863 }
08864 G__tag_memvar_reset();
08865 }
08866
08867
08868
08869 static void G__setup_memvarTMVAcLcLTNeuronInputAbs(void) {
08870 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs));
08871 { TMVA::TNeuronInputAbs *p; p=(TMVA::TNeuronInputAbs*)0x1000; if (p) { }
08872 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08873 }
08874 G__tag_memvar_reset();
08875 }
08876
08877
08878
08879 static void G__setup_memvarTMVAcLcLTNeuronInputChooser(void) {
08880 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser));
08881 { TMVA::TNeuronInputChooser *p; p=(TMVA::TNeuronInputChooser*)0x1000; if (p) { }
08882 G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
08883 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChoosercLcLENeuronInputType),-1,-2,1,G__FastAllocString(2048).Format("kSum=%lldLL",(long long)TMVA::TNeuronInputChooser::kSum).data(),0,(char*)NULL);
08884 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChoosercLcLENeuronInputType),-1,-2,1,G__FastAllocString(2048).Format("kSqSum=%lldLL",(long long)TMVA::TNeuronInputChooser::kSqSum).data(),0,(char*)NULL);
08885 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChoosercLcLENeuronInputType),-1,-2,1,G__FastAllocString(2048).Format("kAbsSum=%lldLL",(long long)TMVA::TNeuronInputChooser::kAbsSum).data(),0,(char*)NULL);
08886 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fSUM=",0,"neuron input type name ");
08887 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fSQSUM=",0,"neuron input type name ");
08888 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fABSSUM=",0,"neuron input type name ");
08889 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08890 }
08891 G__tag_memvar_reset();
08892 }
08893
08894
08895
08896 static void G__setup_memvarTMVAcLcLRanking(void) {
08897 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking));
08898 { TMVA::Ranking *p; p=(TMVA::Ranking*)0x1000; if (p) { }
08899 G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
08900 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgR),G__defined_typename("vector<TMVA::Rank>"),-1,4,"fRanking=",0,"vector of ranks");
08901 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fContext=",0,"the ranking context");
08902 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fRankingDiscriminatorName=",0,"the name of the ranking discriminator");
08903 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"! message logger");
08904 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08905 }
08906 G__tag_memvar_reset();
08907 }
08908
08909
08910
08911 static void G__setup_memvarTMVAcLcLRuleFit(void) {
08912 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFit));
08913 { TMVA::RuleFit *p; p=(TMVA::RuleFit*)0x1000; if (p) { }
08914 G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
08915 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),G__defined_typename("vector<TMVA::Event*>"),-1,4,"fTrainingEvents=",0,"all training events");
08916 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),G__defined_typename("vector<TMVA::Event*>"),-1,4,"fTrainingEventsRndm=",0,"idem, but randomly shuffled");
08917 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fEventWeights=",0,"original weights of the events - follows fTrainingEvents");
08918 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNTreeSample=",0,"number of events in sub sample = frac*neve");
08919 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNEveEffTrain=",0,"reweighted number of events = sum(wi)");
08920 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR),G__defined_typename("vector<const TMVA::DecisionTree*>"),-1,4,"fForest=",0,"the input forest of decision trees");
08921 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleEnsemble),-1,-1,4,"fRuleEnsemble=",0,"the ensemble of rules");
08922 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitParams),-1,-1,4,"fRuleFitParams=",0,"fit rule parameters");
08923 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMethodRuleFit),-1,-1,4,"fMethodRuleFit=",0,"pointer the method which initialized this RuleFit instance");
08924 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMethodBase),-1,-1,4,"fMethodBase=",0,"pointer the method base which initialized this RuleFit instance");
08925 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fVisHistsUseImp=",0,"if true, use importance as weight; else coef in vis hists");
08926 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"message logger");
08927 G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"randSEED=0LL",0,"set to 1 for debugging purposes or to zero for random seeds");
08928 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08929 }
08930 G__tag_memvar_reset();
08931 }
08932
08933
08934
08935 static void G__setup_memvarTMVAcLcLRuleFitAPI(void) {
08936 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPI));
08937 { TMVA::RuleFitAPI *p; p=(TMVA::RuleFitAPI*)0x1000; if (p) { }
08938 G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
08939 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFMode),-1,-2,2,"kRfRegress=1LL",0,(char*)NULL);
08940 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFMode),-1,-2,2,"kRfClass=2LL",0,(char*)NULL);
08941 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLEModel),-1,-2,2,"kRfLinear=0LL",0,(char*)NULL);
08942 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLEModel),-1,-2,2,"kRfRules=1LL",0,(char*)NULL);
08943 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLEModel),-1,-2,2,"kRfBoth=2LL",0,(char*)NULL);
08944 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFProgram),-1,-2,2,"kRfTrain=0LL",0,(char*)NULL);
08945 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFProgram),-1,-2,2,"kRfPredict=1LL",0,(char*)NULL);
08946 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFProgram),-1,-2,2,"kRfVarimp=2LL",0,(char*)NULL);
08947 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMethodRuleFit),-1,-1,4,"fMethodRuleFit=",0,"parent method - set in constructor");
08948 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFit),-1,-1,4,"fRuleFit=",0,"non const ptr to RuleFit class in MethodRuleFit");
08949 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fRFYhat=",0,"score results from test sample");
08950 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fRFVarImp=",0,"variable importances");
08951 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"fRFVarImpInd=",0,"variable index");
08952 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fRFWorkDir=",0,"working directory");
08953 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLIntParms),G__defined_typename("IntParms"),-1,4,"fRFIntParms=",0,"integer parameters");
08954 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLRealParms),G__defined_typename("RealParms"),-1,4,"fRFRealParms=",0,"real parameters");
08955 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"fRFLx=",0,"variable selector");
08956 G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFProgram),-1,-1,4,"fRFProgram=",0,"what to run");
08957 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fModelType=",0,"model type string");
08958 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"message logger");
08959 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08960 }
08961 G__tag_memvar_reset();
08962 }
08963
08964
08965
08966 static void G__setup_memvarTMVAcLcLIMethod(void) {
08967 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLIMethod));
08968 { TMVA::IMethod *p; p=(TMVA::IMethod*)0x1000; if (p) { }
08969 G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
08970 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08971 }
08972 G__tag_memvar_reset();
08973 }
08974
08975
08976
08977 static void G__setup_memvarTMVAcLcLVariableTransformBase(void) {
08978 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase));
08979 { TMVA::VariableTransformBase *p; p=(TMVA::VariableTransformBase*)0x1000; if (p) { }
08980 G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLDataSetInfo),-1,-1,2,"fDsi=",0,(char*)NULL);
08981 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent),-1,-1,2,"fTransformedEvent=",0,"holds the current transformed event");
08982 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent),-1,-1,2,"fBackTransformedEvent=",0,"holds the current back-transformed event");
08983 G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-1,4,"fVariableTransform=",0,"Decorrelation, PCA, etc.");
08984 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseSignalTransform=",0,"true if transformation bases on signal data");
08985 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fEnabled=",0,"has been enabled");
08986 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCreated=",0,"has been created");
08987 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNormalise=",0,"normalise input variables");
08988 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNVars=",0,"number of variables");
08989 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fTransformName=",0,"name of transformation");
08990 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),G__defined_typename("vector<TMVA::VariableInfo>"),-1,4,"fVariables=",0,"event variables [saved to weight file]");
08991 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),G__defined_typename("vector<TMVA::VariableInfo>"),-1,4,"fTargets=",0,"event targets [saved to weight file --> TODO ]");
08992 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("TMVAVersion_t"),-1,2,"fTMVAVersion=",0,(char*)NULL);
08993 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-1,2,"fLogger=",0,"! message logger");
08994 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08995 }
08996 G__tag_memvar_reset();
08997 }
08998
08999
09000
09001 static void G__setup_memvarTMVAcLcLVariableIdentityTransform(void) {
09002 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform));
09003 { TMVA::VariableIdentityTransform *p; p=(TMVA::VariableIdentityTransform*)0x1000; if (p) { }
09004 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
09005 }
09006 G__tag_memvar_reset();
09007 }
09008
09009
09010
09011 static void G__setup_memvarTMVAcLcLVariableDecorrTransform(void) {
09012 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform));
09013 { TMVA::VariableDecorrTransform *p; p=(TMVA::VariableDecorrTransform*)0x1000; if (p) { }
09014 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR),G__defined_typename("vector<TMatrixD*>"),-1,4,"fDecorrMatrices=",0,"! Decorrelation matrix [class0/class1/.../all classes]");
09015 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
09016 }
09017 G__tag_memvar_reset();
09018 }
09019
09020
09021
09022 static void G__setup_memvarTMVAcLcLVariablePCATransform(void) {
09023 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform));
09024 { TMVA::VariablePCATransform *p; p=(TMVA::VariablePCATransform*)0x1000; if (p) { }
09025 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR),G__defined_typename("vector<TVectorD*>"),-1,4,"fMeanValues=",0,"mean values");
09026 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR),G__defined_typename("vector<TMatrixD*>"),-1,4,"fEigenVectors=",0,"eigenvectors");
09027 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
09028 }
09029 G__tag_memvar_reset();
09030 }
09031
09032
09033
09034 static void G__setup_memvarTMVAcLcLVariableGaussTransform(void) {
09035 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform));
09036 { TMVA::VariableGaussTransform *p; p=(TMVA::VariableGaussTransform*)0x1000; if (p) { }
09037 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFlatNotGauss=",0,(char*)NULL);
09038 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPdfMinSmooth=",0,(char*)NULL);
09039 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPdfMaxSmooth=",0,(char*)NULL);
09040 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR),G__defined_typename("vector<std::vector<TH1F*> >"),-1,4,"fCumulativeDist=",0,"! The Cummulative distributions ");
09041 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR),G__defined_typename("vector<std::vector<PDF*> >"),-1,4,"fCumulativePDF=",0,"The cumulative PDF");
09042 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fElementsperbin=",0,"av number of events stored per bin in cum dist");
09043 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
09044 }
09045 G__tag_memvar_reset();
09046 }
09047
09048
09049
09050 static void G__setup_memvarTMVAcLcLVariableNormalizeTransform(void) {
09051 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform));
09052 { TMVA::VariableNormalizeTransform *p; p=(TMVA::VariableNormalizeTransform*)0x1000; if (p) { }
09053 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),G__defined_typename("vector<std::vector<Float_t> >"),-1,4,"fMin=",0,"! Min of source range");
09054 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),G__defined_typename("vector<std::vector<Float_t> >"),-1,4,"fMax=",0,"! Max of source range");
09055 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
09056 }
09057 G__tag_memvar_reset();
09058 }
09059
09060 extern "C" void G__cpp_setup_memvarG__TMVA4() {
09061 }
09062
09063
09064
09065
09066
09067
09068
09069
09070
09071
09072
09073
09074 static void G__setup_memfuncTMVA(void) {
09075
09076 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVA));
09077 G__memfunc_setup("operator<<",996,G__G__TMVA4_125_0_1, 117, G__get_linked_tagnum(&G__G__TMVA4LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0,
09078 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::Node' - 11 - node", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::Node&))(&TMVA::operator<<) ), 0);
09079 G__memfunc_setup("operator<<",996,G__G__TMVA4_125_0_2, 117, G__get_linked_tagnum(&G__G__TMVA4LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0,
09080 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os U 'TMVA::Node' - 10 - node", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::Node*))(&TMVA::operator<<) ), 0);
09081 G__memfunc_setup("operator<<",996,G__G__TMVA4_125_0_3, 117, G__get_linked_tagnum(&G__G__TMVA4LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0,
09082 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::BinaryTree' - 11 - tree", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::BinaryTree&))(&TMVA::operator<<) ), 0);
09083 G__memfunc_setup("operator>>",1000,G__G__TMVA4_125_0_4, 117, G__get_linked_tagnum(&G__G__TMVA4LN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0,
09084 "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr u 'TMVA::BinaryTree' - 1 - tree", (char*)NULL, (void*) G__func2void( (istream& (*)(istream&, TMVA::BinaryTree&))(&TMVA::operator>>) ), 0);
09085 G__memfunc_setup("operator<<",996,G__G__TMVA4_125_0_5, 117, G__get_linked_tagnum(&G__G__TMVA4LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0,
09086 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::Event' - 11 - event", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::Event&))(&TMVA::operator<<) ), 0);
09087 G__memfunc_setup("operator<<",996,G__G__TMVA4_125_0_6, 117, G__get_linked_tagnum(&G__G__TMVA4LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0,
09088 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::Rule' - 11 - rule", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::Rule&))(&TMVA::operator<<) ), 0);
09089 G__memfunc_setup("operator<<",996,G__G__TMVA4_125_0_7, 117, G__get_linked_tagnum(&G__G__TMVA4LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0,
09090 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::RuleEnsemble' - 11 - event", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::RuleEnsemble&))(&TMVA::operator<<) ), 0);
09091 G__memfunc_setup("operator<<",996,G__G__TMVA4_125_0_8, 117, G__get_linked_tagnum(&G__G__TMVA4LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0,
09092 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::PDF' - 11 - tree", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::PDF&))(&TMVA::operator<<) ), 0);
09093 G__memfunc_setup("operator>>",1000,G__G__TMVA4_125_0_9, 117, G__get_linked_tagnum(&G__G__TMVA4LN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0,
09094 "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr u 'TMVA::PDF' - 1 - tree", (char*)NULL, (void*) G__func2void( (istream& (*)(istream&, TMVA::PDF&))(&TMVA::operator>>) ), 0);
09095 G__tag_memfunc_reset();
09096 }
09097
09098 static void G__setup_memfuncTMVAcLcLTNeuron(void) {
09099
09100 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron));
09101 G__memfunc_setup("TNeuron",715,G__G__TMVA4_126_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09102 G__memfunc_setup("ForceValue",1004,G__G__TMVA4_126_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 0);
09103 G__memfunc_setup("CalculateValue",1419,G__G__TMVA4_126_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09104 G__memfunc_setup("CalculateActivationValue",2461,G__G__TMVA4_126_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09105 G__memfunc_setup("CalculateDelta",1400,G__G__TMVA4_126_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09106 G__memfunc_setup("SetActivationEqn",1634,G__G__TMVA4_126_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::TActivation' - 0 - activation", (char*)NULL, (void*) NULL, 0);
09107 G__memfunc_setup("SetInputCalculator",1862,G__G__TMVA4_126_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::TNeuronInput' - 0 - calculator", (char*)NULL, (void*) NULL, 0);
09108 G__memfunc_setup("AddPreLink",958,G__G__TMVA4_126_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::TSynapse' - 0 - pre", (char*)NULL, (void*) NULL, 0);
09109 G__memfunc_setup("AddPostLink",1085,G__G__TMVA4_126_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::TSynapse' - 0 - post", (char*)NULL, (void*) NULL, 0);
09110 G__memfunc_setup("DeletePreLinks",1403,G__G__TMVA4_126_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09111 G__memfunc_setup("SetError",822,G__G__TMVA4_126_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - error", (char*)NULL, (void*) NULL, 0);
09112 G__memfunc_setup("UpdateSynapsesBatch",1947,G__G__TMVA4_126_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09113 G__memfunc_setup("UpdateSynapsesSequential",2516,G__G__TMVA4_126_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09114 G__memfunc_setup("AdjustSynapseWeights",2089,G__G__TMVA4_126_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09115 G__memfunc_setup("InitSynapseDeltas",1748,G__G__TMVA4_126_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09116 G__memfunc_setup("PrintActivationEqn",1859,G__G__TMVA4_126_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09117 G__memfunc_setup("GetValue",797,G__G__TMVA4_126_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09118 G__memfunc_setup("GetActivationValue",1839,G__G__TMVA4_126_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09119 G__memfunc_setup("GetDelta",778,G__G__TMVA4_126_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09120 G__memfunc_setup("GetDEDw",612,G__G__TMVA4_126_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09121 G__memfunc_setup("NumPreLinks",1112,G__G__TMVA4_126_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09122 G__memfunc_setup("NumPostLinks",1239,G__G__TMVA4_126_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09123 G__memfunc_setup("PreLinkAt",874,G__G__TMVA4_126_0_23, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
09124 G__memfunc_setup("PostLinkAt",1001,G__G__TMVA4_126_0_24, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
09125 G__memfunc_setup("SetInputNeuron",1459,G__G__TMVA4_126_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09126 G__memfunc_setup("SetOutputNeuron",1588,G__G__TMVA4_126_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09127 G__memfunc_setup("SetBiasNeuron",1314,G__G__TMVA4_126_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09128 G__memfunc_setup("SetDEDw",624,G__G__TMVA4_126_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - DEDw", (char*)NULL, (void*) NULL, 0);
09129 G__memfunc_setup("IsInputNeuron",1347,G__G__TMVA4_126_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09130 G__memfunc_setup("IsOutputNeuron",1476,G__G__TMVA4_126_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09131 G__memfunc_setup("PrintPreLinks",1333,G__G__TMVA4_126_0_31, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09132 G__memfunc_setup("PrintPostLinks",1460,G__G__TMVA4_126_0_32, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09133 G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
09134 G__memfunc_setup("InitNeuron",1035,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
09135 G__memfunc_setup("DeleteLinksArray",1619,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TObjArray' - 1 - links", (char*)NULL, (void*) NULL, 0);
09136 G__memfunc_setup("PrintLinks",1038,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "U 'TObjArray' - 0 - links", (char*)NULL, (void*) NULL, 0);
09137 G__memfunc_setup("PrintMessage",1234,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0,
09138 "i 'TMVA::EMsgType' - 0 - - u 'TString' - 0 - message", (char*)NULL, (void*) NULL, 0);
09139 G__memfunc_setup("NumLinks",817,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 8, "U 'TObjArray' - 0 - links", (char*)NULL, (void*) NULL, 0);
09140 G__memfunc_setup("NullifyLinks",1252,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TObjArray' - 1 - links", (char*)NULL, (void*) NULL, 0);
09141 G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
09142 G__memfunc_setup("Class",502,G__G__TMVA4_126_0_41, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TNeuron::Class) ), 0);
09143 G__memfunc_setup("Class_Name",982,G__G__TMVA4_126_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuron::Class_Name) ), 0);
09144 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_126_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TNeuron::Class_Version) ), 0);
09145 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_126_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TNeuron::Dictionary) ), 0);
09146 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09147 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09148 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09149 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_126_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09150 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_126_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuron::DeclFileName) ), 0);
09151 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_126_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuron::ImplFileLine) ), 0);
09152 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_126_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuron::ImplFileName) ), 0);
09153 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_126_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuron::DeclFileLine) ), 0);
09154
09155 G__memfunc_setup("TNeuron", 715, G__G__TMVA4_126_0_53, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron), -1, 0, 1, 1, 1, 0, "u 'TMVA::TNeuron' - 11 - -", (char*) NULL, (void*) NULL, 0);
09156
09157 G__memfunc_setup("~TNeuron", 841, G__G__TMVA4_126_0_54, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09158
09159 G__memfunc_setup("operator=", 937, G__G__TMVA4_126_0_55, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron), -1, 1, 1, 1, 1, 0, "u 'TMVA::TNeuron' - 11 - -", (char*) NULL, (void*) NULL, 0);
09160 G__tag_memfunc_reset();
09161 }
09162
09163 static void G__setup_memfuncTMVAcLcLMsgLogger(void) {
09164
09165 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger));
09166 G__memfunc_setup("MsgLogger",903,G__G__TMVA4_127_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 0, 2, 1, 1, 0,
09167 "U 'TObject' - 10 - source i 'TMVA::EMsgType' - 0 'kINFO' minType", (char*)NULL, (void*) NULL, 0);
09168 G__memfunc_setup("MsgLogger",903,G__G__TMVA4_127_0_2, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 0, 2, 1, 1, 0,
09169 "u 'string' - 11 - source i 'TMVA::EMsgType' - 0 'kINFO' minType", (char*)NULL, (void*) NULL, 0);
09170 G__memfunc_setup("MsgLogger",903,G__G__TMVA4_127_0_3, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 0, 1, 1, 1, 0, "i 'TMVA::EMsgType' - 0 'kINFO' minType", (char*)NULL, (void*) NULL, 0);
09171 G__memfunc_setup("MsgLogger",903,G__G__TMVA4_127_0_4, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 0, 1, 1, 1, 0, "u 'TMVA::MsgLogger' - 11 - parent", (char*)NULL, (void*) NULL, 0);
09172 G__memfunc_setup("SetSource",925,G__G__TMVA4_127_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - source", (char*)NULL, (void*) NULL, 0);
09173 G__memfunc_setup("GetMinType",998,G__G__TMVA4_127_0_6, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEMsgType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09174 G__memfunc_setup("SetMinType",1010,G__G__TMVA4_127_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TMVA::EMsgType' - 0 - minType", (char*)NULL, (void*) NULL, 0);
09175 G__memfunc_setup("GetSource",913,G__G__TMVA4_127_0_8, 117, G__get_linked_tagnum(&G__G__TMVA4LN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09176 G__memfunc_setup("GetPrintedSource",1639,G__G__TMVA4_127_0_9, 117, G__get_linked_tagnum(&G__G__TMVA4LN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09177 G__memfunc_setup("GetFormattedSource",1847,G__G__TMVA4_127_0_10, 117, G__get_linked_tagnum(&G__G__TMVA4LN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09178 G__memfunc_setup("GetMaxSourceSize",1618,G__G__TMVA4_127_0_11, 104, -1, G__defined_typename("UInt_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (UInt_t (*)())(&TMVA::MsgLogger::GetMaxSourceSize) ), 0);
09179 G__memfunc_setup("operator=",937,G__G__TMVA4_127_0_12, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 1, 1, 1, 0, "u 'TMVA::MsgLogger' - 11 - parent", (char*)NULL, (void*) NULL, 0);
09180 G__memfunc_setup("Endmsg",606,G__G__TMVA4_127_0_13, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 1, 3, 1, 0, "u 'TMVA::MsgLogger' - 1 - logger", (char*)NULL, (void*) G__func2void( (TMVA::MsgLogger& (*)(TMVA::MsgLogger&))(&TMVA::MsgLogger::Endmsg) ), 0);
09181 G__memfunc_setup("operator<<",996,G__G__TMVA4_127_0_14, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 1, 1, 1, 0, "1 - 'std::ios& (*)(std::ios&) ' 0 - _f", (char*)NULL, (void*) NULL, 0);
09182 G__memfunc_setup("operator<<",996,G__G__TMVA4_127_0_15, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 1, 1, 1, 0, "i 'TMVA::EMsgType' - 0 - type", (char*)NULL, (void*) NULL, 0);
09183 G__memfunc_setup("InhibitOutput",1368,G__G__TMVA4_127_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MsgLogger::InhibitOutput) ), 0);
09184 G__memfunc_setup("EnableOutput",1240,G__G__TMVA4_127_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MsgLogger::EnableOutput) ), 0);
09185 G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
09186 G__memfunc_setup("InitMaps",805,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
09187 G__memfunc_setup("WriteMsg",818,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8,
09188 "i 'TMVA::EMsgType' - 0 - type u 'string' - 11 - line", (char*)NULL, (void*) NULL, 0);
09189 G__memfunc_setup("Class",502,G__G__TMVA4_127_0_21, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MsgLogger::Class) ), 0);
09190 G__memfunc_setup("Class_Name",982,G__G__TMVA4_127_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MsgLogger::Class_Name) ), 0);
09191 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_127_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MsgLogger::Class_Version) ), 0);
09192 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_127_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MsgLogger::Dictionary) ), 0);
09193 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09194 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09195 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09196 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_127_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09197 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_127_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MsgLogger::DeclFileName) ), 0);
09198 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_127_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MsgLogger::ImplFileLine) ), 0);
09199 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_127_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MsgLogger::ImplFileName) ), 0);
09200 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_127_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MsgLogger::DeclFileLine) ), 0);
09201
09202 G__memfunc_setup("~MsgLogger", 1029, G__G__TMVA4_127_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09203 G__tag_memfunc_reset();
09204 }
09205
09206 static void G__setup_memfuncTMVAcLcLTSynapse(void) {
09207
09208 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse));
09209 G__memfunc_setup("TSynapse",823,G__G__TMVA4_128_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09210 G__memfunc_setup("SetWeight",916,G__G__TMVA4_128_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - weight", (char*)NULL, (void*) NULL, 0);
09211 G__memfunc_setup("GetWeight",904,G__G__TMVA4_128_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09212 G__memfunc_setup("SetLearningRate",1512,G__G__TMVA4_128_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - rate", (char*)NULL, (void*) NULL, 0);
09213 G__memfunc_setup("GetLearningRate",1500,G__G__TMVA4_128_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09214 G__memfunc_setup("DecayLearningRate",1698,G__G__TMVA4_128_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - rate", (char*)NULL, (void*) NULL, 0);
09215 G__memfunc_setup("SetPreNeuron",1226,G__G__TMVA4_128_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::TNeuron' - 0 - pre", (char*)NULL, (void*) NULL, 0);
09216 G__memfunc_setup("SetPostNeuron",1353,G__G__TMVA4_128_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::TNeuron' - 0 - post", (char*)NULL, (void*) NULL, 0);
09217 G__memfunc_setup("GetWeightedValue",1614,G__G__TMVA4_128_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09218 G__memfunc_setup("GetWeightedDelta",1595,G__G__TMVA4_128_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09219 G__memfunc_setup("AdjustWeight",1235,G__G__TMVA4_128_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09220 G__memfunc_setup("CalculateDelta",1400,G__G__TMVA4_128_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09221 G__memfunc_setup("InitDelta",894,G__G__TMVA4_128_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09222 G__memfunc_setup("SetDEDw",624,G__G__TMVA4_128_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - DEDw", (char*)NULL, (void*) NULL, 0);
09223 G__memfunc_setup("GetDEDw",612,G__G__TMVA4_128_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09224 G__memfunc_setup("GetDelta",778,G__G__TMVA4_128_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09225 G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
09226 G__memfunc_setup("Class",502,G__G__TMVA4_128_0_18, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TSynapse::Class) ), 0);
09227 G__memfunc_setup("Class_Name",982,G__G__TMVA4_128_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TSynapse::Class_Name) ), 0);
09228 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_128_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TSynapse::Class_Version) ), 0);
09229 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_128_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TSynapse::Dictionary) ), 0);
09230 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09231 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09232 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09233 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_128_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09234 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_128_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TSynapse::DeclFileName) ), 0);
09235 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_128_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TSynapse::ImplFileLine) ), 0);
09236 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_128_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TSynapse::ImplFileName) ), 0);
09237 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_128_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TSynapse::DeclFileLine) ), 0);
09238
09239 G__memfunc_setup("TSynapse", 823, G__G__TMVA4_128_0_30, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse), -1, 0, 1, 1, 1, 0, "u 'TMVA::TSynapse' - 11 - -", (char*) NULL, (void*) NULL, 0);
09240
09241 G__memfunc_setup("~TSynapse", 949, G__G__TMVA4_128_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09242
09243 G__memfunc_setup("operator=", 937, G__G__TMVA4_128_0_32, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse), -1, 1, 1, 1, 1, 0, "u 'TMVA::TSynapse' - 11 - -", (char*) NULL, (void*) NULL, 0);
09244 G__tag_memfunc_reset();
09245 }
09246
09247 static void G__setup_memfuncTMVAcLcLTActivation(void) {
09248
09249 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation));
09250 G__memfunc_setup("Eval",392,G__G__TMVA4_129_0_2, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 3);
09251 G__memfunc_setup("EvalDerivative",1435,G__G__TMVA4_129_0_3, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 3);
09252 G__memfunc_setup("GetMin",580,G__G__TMVA4_129_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
09253 G__memfunc_setup("GetMax",582,G__G__TMVA4_129_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
09254 G__memfunc_setup("GetExpression",1360,G__G__TMVA4_129_0_6, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
09255 G__memfunc_setup("MakeFunction",1220,G__G__TMVA4_129_0_7, 121, -1, -1, 0, 2, 1, 1, 0,
09256 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName", (char*)NULL, (void*) NULL, 3);
09257 G__memfunc_setup("Class",502,G__G__TMVA4_129_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TActivation::Class) ), 0);
09258 G__memfunc_setup("Class_Name",982,G__G__TMVA4_129_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivation::Class_Name) ), 0);
09259 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_129_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TActivation::Class_Version) ), 0);
09260 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_129_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TActivation::Dictionary) ), 0);
09261 G__memfunc_setup("IsA",253,G__G__TMVA4_129_0_12, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09262 G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_129_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09263 G__memfunc_setup("Streamer",835,G__G__TMVA4_129_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09264 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_129_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09265 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_129_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivation::DeclFileName) ), 0);
09266 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_129_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivation::ImplFileLine) ), 0);
09267 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_129_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivation::ImplFileName) ), 0);
09268 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_129_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivation::DeclFileLine) ), 0);
09269
09270 G__memfunc_setup("~TActivation", 1252, G__G__TMVA4_129_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09271
09272 G__memfunc_setup("operator=", 937, G__G__TMVA4_129_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation), -1, 1, 1, 1, 1, 0, "u 'TMVA::TActivation' - 11 - -", (char*) NULL, (void*) NULL, 0);
09273 G__tag_memfunc_reset();
09274 }
09275
09276 static void G__setup_memfuncTMVAcLcLTypes(void) {
09277
09278 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypes));
09279 G__memfunc_setup("Instance",821,G__G__TMVA4_131_0_1, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypes), -1, 1, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TMVA::Types& (*)())(&TMVA::Types::Instance) ), 0);
09280 G__memfunc_setup("DestroyInstance",1567,G__G__TMVA4_131_0_2, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Types::DestroyInstance) ), 0);
09281 G__memfunc_setup("GetMethodType",1315,G__G__TMVA4_131_0_3, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA), -1, 0, 1, 1, 1, 8, "u 'TString' - 11 - method", (char*)NULL, (void*) NULL, 0);
09282 G__memfunc_setup("GetMethodName",1282,G__G__TMVA4_131_0_4, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 1, 1, 1, 8, "i 'TMVA::Types::EMVA' - 0 - method", (char*)NULL, (void*) NULL, 0);
09283 G__memfunc_setup("AddTypeMapping",1399,G__G__TMVA4_131_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
09284 "i 'TMVA::Types::EMVA' - 0 - method u 'TString' - 11 - methodname", (char*)NULL, (void*) NULL, 0);
09285 G__memfunc_setup("Types",533,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypes), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
09286 G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
09287
09288 G__memfunc_setup("Types", 533, G__G__TMVA4_131_0_8, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypes), -1, 0, 1, 1, 1, 0, "u 'TMVA::Types' - 11 - -", (char*) NULL, (void*) NULL, 0);
09289
09290 G__memfunc_setup("~Types", 659, G__G__TMVA4_131_0_9, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
09291
09292 G__memfunc_setup("operator=", 937, G__G__TMVA4_131_0_10, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypes), -1, 1, 1, 1, 1, 0, "u 'TMVA::Types' - 11 - -", (char*) NULL, (void*) NULL, 0);
09293 G__tag_memfunc_reset();
09294 }
09295
09296 static void G__setup_memfuncTMVAcLcLTNeuronInput(void) {
09297
09298 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput));
09299 G__memfunc_setup("GetInput",816,G__G__TMVA4_147_0_2, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "U 'TMVA::TNeuron' - 10 - neuron", (char*)NULL, (void*) NULL, 3);
09300 G__memfunc_setup("GetName",673,G__G__TMVA4_147_0_3, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
09301 G__memfunc_setup("Class",502,G__G__TMVA4_147_0_4, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TNeuronInput::Class) ), 0);
09302 G__memfunc_setup("Class_Name",982,G__G__TMVA4_147_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInput::Class_Name) ), 0);
09303 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_147_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TNeuronInput::Class_Version) ), 0);
09304 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_147_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TNeuronInput::Dictionary) ), 0);
09305 G__memfunc_setup("IsA",253,G__G__TMVA4_147_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09306 G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_147_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09307 G__memfunc_setup("Streamer",835,G__G__TMVA4_147_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09308 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_147_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09309 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_147_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInput::DeclFileName) ), 0);
09310 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_147_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInput::ImplFileLine) ), 0);
09311 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_147_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInput::ImplFileName) ), 0);
09312 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_147_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInput::DeclFileLine) ), 0);
09313
09314 G__memfunc_setup("~TNeuronInput", 1369, G__G__TMVA4_147_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09315
09316 G__memfunc_setup("operator=", 937, G__G__TMVA4_147_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput), -1, 1, 1, 1, 1, 0, "u 'TMVA::TNeuronInput' - 11 - -", (char*) NULL, (void*) NULL, 0);
09317 G__tag_memfunc_reset();
09318 }
09319
09320 static void G__setup_memfuncTMVAcLcLTActivationChooser(void) {
09321
09322 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChooser));
09323 G__memfunc_setup("TActivationChooser",1849,G__G__TMVA4_148_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChooser), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09324 G__memfunc_setup("CreateActivation",1638,G__G__TMVA4_148_0_2, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation), -1, 0, 1, 1, 1, 8, "i 'TMVA::TActivationChooser::EActivationType' - 0 - type", (char*)NULL, (void*) NULL, 0);
09325 G__memfunc_setup("CreateActivation",1638,G__G__TMVA4_148_0_3, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation), -1, 0, 1, 1, 1, 8, "u 'TString' - 11 - type", (char*)NULL, (void*) NULL, 0);
09326 G__memfunc_setup("GetAllActivationNames",2111,G__G__TMVA4_148_0_4, 85, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR), G__defined_typename("vector<TString>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09327 G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
09328 G__memfunc_setup("Class",502,G__G__TMVA4_148_0_6, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TActivationChooser::Class) ), 0);
09329 G__memfunc_setup("Class_Name",982,G__G__TMVA4_148_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationChooser::Class_Name) ), 0);
09330 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_148_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TActivationChooser::Class_Version) ), 0);
09331 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_148_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TActivationChooser::Dictionary) ), 0);
09332 G__memfunc_setup("IsA",253,G__G__TMVA4_148_0_10, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09333 G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_148_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09334 G__memfunc_setup("Streamer",835,G__G__TMVA4_148_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09335 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_148_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09336 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_148_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationChooser::DeclFileName) ), 0);
09337 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_148_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationChooser::ImplFileLine) ), 0);
09338 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_148_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationChooser::ImplFileName) ), 0);
09339 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_148_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationChooser::DeclFileLine) ), 0);
09340
09341 G__memfunc_setup("TActivationChooser", 1849, G__G__TMVA4_148_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChooser), -1, 0, 1, 1, 1, 0, "u 'TMVA::TActivationChooser' - 11 - -", (char*) NULL, (void*) NULL, 0);
09342
09343 G__memfunc_setup("~TActivationChooser", 1975, G__G__TMVA4_148_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09344
09345 G__memfunc_setup("operator=", 937, G__G__TMVA4_148_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChooser), -1, 1, 1, 1, 1, 0, "u 'TMVA::TActivationChooser' - 11 - -", (char*) NULL, (void*) NULL, 0);
09346 G__tag_memfunc_reset();
09347 }
09348
09349 static void G__setup_memfuncTMVAcLcLTActivationSigmoid(void) {
09350
09351 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid));
09352 G__memfunc_setup("TActivationSigmoid",1842,G__G__TMVA4_154_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09353 G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 1);
09354 G__memfunc_setup("EvalDerivative",1435,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 1);
09355 G__memfunc_setup("GetMin",580,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09356 G__memfunc_setup("GetMax",582,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09357 G__memfunc_setup("GetExpression",1360,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09358 G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
09359 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName", (char*)NULL, (void*) NULL, 1);
09360 G__memfunc_setup("Class",502,G__G__TMVA4_154_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TActivationSigmoid::Class) ), 0);
09361 G__memfunc_setup("Class_Name",982,G__G__TMVA4_154_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationSigmoid::Class_Name) ), 0);
09362 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_154_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TActivationSigmoid::Class_Version) ), 0);
09363 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_154_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TActivationSigmoid::Dictionary) ), 0);
09364 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09365 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09366 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09367 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_154_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09368 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_154_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationSigmoid::DeclFileName) ), 0);
09369 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_154_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationSigmoid::ImplFileLine) ), 0);
09370 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_154_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationSigmoid::ImplFileName) ), 0);
09371 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_154_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationSigmoid::DeclFileLine) ), 0);
09372
09373 G__memfunc_setup("TActivationSigmoid", 1842, G__G__TMVA4_154_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid), -1, 0, 1, 1, 1, 0, "u 'TMVA::TActivationSigmoid' - 11 - -", (char*) NULL, (void*) NULL, 0);
09374
09375 G__memfunc_setup("~TActivationSigmoid", 1968, G__G__TMVA4_154_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09376
09377 G__memfunc_setup("operator=", 937, G__G__TMVA4_154_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid), -1, 1, 1, 1, 1, 0, "u 'TMVA::TActivationSigmoid' - 11 - -", (char*) NULL, (void*) NULL, 0);
09378 G__tag_memfunc_reset();
09379 }
09380
09381 static void G__setup_memfuncTMVAcLcLTActivationIdentity(void) {
09382
09383 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity));
09384 G__memfunc_setup("TActivationIdentity",1968,G__G__TMVA4_155_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09385 G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", "f(x) = x", (void*) NULL, 1);
09386 G__memfunc_setup("EvalDerivative",1435,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
09387 G__memfunc_setup("GetMin",580,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", "these should never be called", (void*) NULL, 1);
09388 G__memfunc_setup("GetMax",582,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", "these should never be called", (void*) NULL, 1);
09389 G__memfunc_setup("GetExpression",1360,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09390 G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
09391 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName", (char*)NULL, (void*) NULL, 1);
09392 G__memfunc_setup("Class",502,G__G__TMVA4_155_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TActivationIdentity::Class) ), 0);
09393 G__memfunc_setup("Class_Name",982,G__G__TMVA4_155_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationIdentity::Class_Name) ), 0);
09394 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_155_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TActivationIdentity::Class_Version) ), 0);
09395 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_155_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TActivationIdentity::Dictionary) ), 0);
09396 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09397 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09398 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09399 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_155_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09400 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_155_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationIdentity::DeclFileName) ), 0);
09401 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_155_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationIdentity::ImplFileLine) ), 0);
09402 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_155_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationIdentity::ImplFileName) ), 0);
09403 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_155_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationIdentity::DeclFileLine) ), 0);
09404
09405 G__memfunc_setup("TActivationIdentity", 1968, G__G__TMVA4_155_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity), -1, 0, 1, 1, 1, 0, "u 'TMVA::TActivationIdentity' - 11 - -", (char*) NULL, (void*) NULL, 0);
09406
09407 G__memfunc_setup("~TActivationIdentity", 2094, G__G__TMVA4_155_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09408
09409 G__memfunc_setup("operator=", 937, G__G__TMVA4_155_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity), -1, 1, 1, 1, 1, 0, "u 'TMVA::TActivationIdentity' - 11 - -", (char*) NULL, (void*) NULL, 0);
09410 G__tag_memfunc_reset();
09411 }
09412
09413 static void G__setup_memfuncTMVAcLcLTActivationTanh(void) {
09414
09415 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh));
09416 G__memfunc_setup("TActivationTanh",1521,G__G__TMVA4_156_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09417 G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 1);
09418 G__memfunc_setup("EvalDerivative",1435,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 1);
09419 G__memfunc_setup("GetMin",580,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09420 G__memfunc_setup("GetMax",582,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09421 G__memfunc_setup("GetExpression",1360,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09422 G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
09423 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName", (char*)NULL, (void*) NULL, 1);
09424 G__memfunc_setup("Class",502,G__G__TMVA4_156_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TActivationTanh::Class) ), 0);
09425 G__memfunc_setup("Class_Name",982,G__G__TMVA4_156_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationTanh::Class_Name) ), 0);
09426 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_156_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TActivationTanh::Class_Version) ), 0);
09427 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_156_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TActivationTanh::Dictionary) ), 0);
09428 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09429 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09430 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09431 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_156_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09432 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_156_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationTanh::DeclFileName) ), 0);
09433 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_156_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationTanh::ImplFileLine) ), 0);
09434 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_156_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationTanh::ImplFileName) ), 0);
09435 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_156_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationTanh::DeclFileLine) ), 0);
09436
09437 G__memfunc_setup("TActivationTanh", 1521, G__G__TMVA4_156_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh), -1, 0, 1, 1, 1, 0, "u 'TMVA::TActivationTanh' - 11 - -", (char*) NULL, (void*) NULL, 0);
09438
09439 G__memfunc_setup("~TActivationTanh", 1647, G__G__TMVA4_156_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09440
09441 G__memfunc_setup("operator=", 937, G__G__TMVA4_156_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh), -1, 1, 1, 1, 1, 0, "u 'TMVA::TActivationTanh' - 11 - -", (char*) NULL, (void*) NULL, 0);
09442 G__tag_memfunc_reset();
09443 }
09444
09445 static void G__setup_memfuncTMVAcLcLTActivationRadial(void) {
09446
09447 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial));
09448 G__memfunc_setup("TActivationRadial",1715,G__G__TMVA4_157_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09449 G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 1);
09450 G__memfunc_setup("EvalDerivative",1435,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 1);
09451 G__memfunc_setup("GetMin",580,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09452 G__memfunc_setup("GetMax",582,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09453 G__memfunc_setup("GetExpression",1360,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09454 G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
09455 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName", (char*)NULL, (void*) NULL, 1);
09456 G__memfunc_setup("Class",502,G__G__TMVA4_157_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TActivationRadial::Class) ), 0);
09457 G__memfunc_setup("Class_Name",982,G__G__TMVA4_157_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationRadial::Class_Name) ), 0);
09458 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_157_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TActivationRadial::Class_Version) ), 0);
09459 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_157_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TActivationRadial::Dictionary) ), 0);
09460 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09461 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09462 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09463 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_157_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09464 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_157_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationRadial::DeclFileName) ), 0);
09465 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_157_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationRadial::ImplFileLine) ), 0);
09466 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_157_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationRadial::ImplFileName) ), 0);
09467 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_157_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationRadial::DeclFileLine) ), 0);
09468
09469 G__memfunc_setup("TActivationRadial", 1715, G__G__TMVA4_157_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial), -1, 0, 1, 1, 1, 0, "u 'TMVA::TActivationRadial' - 11 - -", (char*) NULL, (void*) NULL, 0);
09470
09471 G__memfunc_setup("~TActivationRadial", 1841, G__G__TMVA4_157_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09472
09473 G__memfunc_setup("operator=", 937, G__G__TMVA4_157_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial), -1, 1, 1, 1, 1, 0, "u 'TMVA::TActivationRadial' - 11 - -", (char*) NULL, (void*) NULL, 0);
09474 G__tag_memfunc_reset();
09475 }
09476
09477 static void G__setup_memfuncTMVAcLcLTNeuronInputSum(void) {
09478
09479 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum));
09480 G__memfunc_setup("TNeuronInputSum",1552,G__G__TMVA4_158_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09481 G__memfunc_setup("GetInput",816,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "U 'TMVA::TNeuron' - 10 - neuron", (char*)NULL, (void*) NULL, 1);
09482 G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09483 G__memfunc_setup("Class",502,G__G__TMVA4_158_0_4, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TNeuronInputSum::Class) ), 0);
09484 G__memfunc_setup("Class_Name",982,G__G__TMVA4_158_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputSum::Class_Name) ), 0);
09485 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_158_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TNeuronInputSum::Class_Version) ), 0);
09486 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_158_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TNeuronInputSum::Dictionary) ), 0);
09487 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09488 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09489 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09490 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_158_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09491 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_158_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputSum::DeclFileName) ), 0);
09492 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_158_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputSum::ImplFileLine) ), 0);
09493 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_158_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputSum::ImplFileName) ), 0);
09494 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_158_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputSum::DeclFileLine) ), 0);
09495
09496 G__memfunc_setup("TNeuronInputSum", 1552, G__G__TMVA4_158_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum), -1, 0, 1, 1, 1, 0, "u 'TMVA::TNeuronInputSum' - 11 - -", (char*) NULL, (void*) NULL, 0);
09497
09498 G__memfunc_setup("~TNeuronInputSum", 1678, G__G__TMVA4_158_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09499
09500 G__memfunc_setup("operator=", 937, G__G__TMVA4_158_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum), -1, 1, 1, 1, 1, 0, "u 'TMVA::TNeuronInputSum' - 11 - -", (char*) NULL, (void*) NULL, 0);
09501 G__tag_memfunc_reset();
09502 }
09503
09504 static void G__setup_memfuncTMVAcLcLTNeuronInputSqSum(void) {
09505
09506 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum));
09507 G__memfunc_setup("TNeuronInputSqSum",1748,G__G__TMVA4_159_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09508 G__memfunc_setup("GetInput",816,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "U 'TMVA::TNeuron' - 10 - neuron", (char*)NULL, (void*) NULL, 1);
09509 G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09510 G__memfunc_setup("Class",502,G__G__TMVA4_159_0_4, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TNeuronInputSqSum::Class) ), 0);
09511 G__memfunc_setup("Class_Name",982,G__G__TMVA4_159_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputSqSum::Class_Name) ), 0);
09512 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_159_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TNeuronInputSqSum::Class_Version) ), 0);
09513 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_159_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TNeuronInputSqSum::Dictionary) ), 0);
09514 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09515 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09516 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09517 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_159_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09518 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_159_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputSqSum::DeclFileName) ), 0);
09519 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_159_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputSqSum::ImplFileLine) ), 0);
09520 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_159_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputSqSum::ImplFileName) ), 0);
09521 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_159_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputSqSum::DeclFileLine) ), 0);
09522
09523 G__memfunc_setup("TNeuronInputSqSum", 1748, G__G__TMVA4_159_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum), -1, 0, 1, 1, 1, 0, "u 'TMVA::TNeuronInputSqSum' - 11 - -", (char*) NULL, (void*) NULL, 0);
09524
09525 G__memfunc_setup("~TNeuronInputSqSum", 1874, G__G__TMVA4_159_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09526
09527 G__memfunc_setup("operator=", 937, G__G__TMVA4_159_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum), -1, 1, 1, 1, 1, 0, "u 'TMVA::TNeuronInputSqSum' - 11 - -", (char*) NULL, (void*) NULL, 0);
09528 G__tag_memfunc_reset();
09529 }
09530
09531 static void G__setup_memfuncTMVAcLcLTNeuronInputAbs(void) {
09532
09533 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs));
09534 G__memfunc_setup("TNeuronInputAbs",1521,G__G__TMVA4_160_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09535 G__memfunc_setup("GetInput",816,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "U 'TMVA::TNeuron' - 10 - neuron", (char*)NULL, (void*) NULL, 1);
09536 G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09537 G__memfunc_setup("Class",502,G__G__TMVA4_160_0_4, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TNeuronInputAbs::Class) ), 0);
09538 G__memfunc_setup("Class_Name",982,G__G__TMVA4_160_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputAbs::Class_Name) ), 0);
09539 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_160_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TNeuronInputAbs::Class_Version) ), 0);
09540 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_160_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TNeuronInputAbs::Dictionary) ), 0);
09541 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09542 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09543 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09544 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_160_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09545 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_160_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputAbs::DeclFileName) ), 0);
09546 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_160_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputAbs::ImplFileLine) ), 0);
09547 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_160_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputAbs::ImplFileName) ), 0);
09548 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_160_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputAbs::DeclFileLine) ), 0);
09549
09550 G__memfunc_setup("TNeuronInputAbs", 1521, G__G__TMVA4_160_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs), -1, 0, 1, 1, 1, 0, "u 'TMVA::TNeuronInputAbs' - 11 - -", (char*) NULL, (void*) NULL, 0);
09551
09552 G__memfunc_setup("~TNeuronInputAbs", 1647, G__G__TMVA4_160_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09553
09554 G__memfunc_setup("operator=", 937, G__G__TMVA4_160_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs), -1, 1, 1, 1, 1, 0, "u 'TMVA::TNeuronInputAbs' - 11 - -", (char*) NULL, (void*) NULL, 0);
09555 G__tag_memfunc_reset();
09556 }
09557
09558 static void G__setup_memfuncTMVAcLcLTNeuronInputChooser(void) {
09559
09560 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser));
09561 G__memfunc_setup("TNeuronInputChooser",1966,G__G__TMVA4_161_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09562 G__memfunc_setup("CreateNeuronInput",1755,G__G__TMVA4_161_0_2, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput), -1, 0, 1, 1, 1, 8, "i 'TMVA::TNeuronInputChooser::ENeuronInputType' - 0 - type", (char*)NULL, (void*) NULL, 0);
09563 G__memfunc_setup("CreateNeuronInput",1755,G__G__TMVA4_161_0_3, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput), -1, 0, 1, 1, 1, 8, "u 'TString' - 10 - type", (char*)NULL, (void*) NULL, 0);
09564 G__memfunc_setup("GetAllNeuronInputNames",2228,G__G__TMVA4_161_0_4, 85, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR), G__defined_typename("vector<TString>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09565 G__memfunc_setup("Class",502,G__G__TMVA4_161_0_5, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TNeuronInputChooser::Class) ), 0);
09566 G__memfunc_setup("Class_Name",982,G__G__TMVA4_161_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputChooser::Class_Name) ), 0);
09567 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_161_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TNeuronInputChooser::Class_Version) ), 0);
09568 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_161_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TNeuronInputChooser::Dictionary) ), 0);
09569 G__memfunc_setup("IsA",253,G__G__TMVA4_161_0_9, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09570 G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_161_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09571 G__memfunc_setup("Streamer",835,G__G__TMVA4_161_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09572 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_161_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09573 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_161_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputChooser::DeclFileName) ), 0);
09574 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_161_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputChooser::ImplFileLine) ), 0);
09575 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_161_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputChooser::ImplFileName) ), 0);
09576 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_161_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputChooser::DeclFileLine) ), 0);
09577
09578 G__memfunc_setup("TNeuronInputChooser", 1966, G__G__TMVA4_161_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser), -1, 0, 1, 1, 1, 0, "u 'TMVA::TNeuronInputChooser' - 11 - -", (char*) NULL, (void*) NULL, 0);
09579
09580 G__memfunc_setup("~TNeuronInputChooser", 2092, G__G__TMVA4_161_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09581
09582 G__memfunc_setup("operator=", 937, G__G__TMVA4_161_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser), -1, 1, 1, 1, 1, 0, "u 'TMVA::TNeuronInputChooser' - 11 - -", (char*) NULL, (void*) NULL, 0);
09583 G__tag_memfunc_reset();
09584 }
09585
09586 static void G__setup_memfuncTMVAcLcLRanking(void) {
09587
09588 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking));
09589 G__memfunc_setup("Ranking",714,G__G__TMVA4_164_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09590 G__memfunc_setup("Ranking",714,G__G__TMVA4_164_0_2, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking), -1, 0, 2, 1, 1, 0,
09591 "u 'TString' - 11 - context u 'TString' - 11 - rankingDiscriminatorName", (char*)NULL, (void*) NULL, 0);
09592 G__memfunc_setup("AddRank",661,G__G__TMVA4_164_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMVA::Rank' - 11 - rank", (char*)NULL, (void*) NULL, 1);
09593 G__memfunc_setup("Print",525,G__G__TMVA4_164_0_4, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09594 G__memfunc_setup("SetContext",1041,G__G__TMVA4_164_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - context", (char*)NULL, (void*) NULL, 0);
09595 G__memfunc_setup("SetDiscrName",1186,G__G__TMVA4_164_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - discrName", (char*)NULL, (void*) NULL, 0);
09596 G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
09597 G__memfunc_setup("Class",502,G__G__TMVA4_164_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::Ranking::Class) ), 0);
09598 G__memfunc_setup("Class_Name",982,G__G__TMVA4_164_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Ranking::Class_Name) ), 0);
09599 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_164_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::Ranking::Class_Version) ), 0);
09600 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_164_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Ranking::Dictionary) ), 0);
09601 G__memfunc_setup("IsA",253,G__G__TMVA4_164_0_12, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09602 G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_164_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09603 G__memfunc_setup("Streamer",835,G__G__TMVA4_164_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09604 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_164_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09605 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_164_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Ranking::DeclFileName) ), 0);
09606 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_164_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Ranking::ImplFileLine) ), 0);
09607 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_164_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Ranking::ImplFileName) ), 0);
09608 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_164_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Ranking::DeclFileLine) ), 0);
09609
09610 G__memfunc_setup("Ranking", 714, G__G__TMVA4_164_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking), -1, 0, 1, 1, 1, 0, "u 'TMVA::Ranking' - 11 - -", (char*) NULL, (void*) NULL, 0);
09611
09612 G__memfunc_setup("~Ranking", 840, G__G__TMVA4_164_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09613
09614 G__memfunc_setup("operator=", 937, G__G__TMVA4_164_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking), -1, 1, 1, 1, 1, 0, "u 'TMVA::Ranking' - 11 - -", (char*) NULL, (void*) NULL, 0);
09615 G__tag_memfunc_reset();
09616 }
09617
09618 static void G__setup_memfuncTMVAcLcLRuleFit(void) {
09619
09620 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFit));
09621 G__memfunc_setup("RuleFit",699,G__G__TMVA4_301_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFit), -1, 0, 1, 1, 1, 0, "U 'TMVA::MethodBase' - 10 - rfbase", (char*)NULL, (void*) NULL, 0);
09622 G__memfunc_setup("RuleFit",699,G__G__TMVA4_301_0_2, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09623 G__memfunc_setup("InitNEveEff",1043,G__G__TMVA4_301_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09624 G__memfunc_setup("InitPtrs",829,G__G__TMVA4_301_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::MethodBase' - 10 - rfbase", (char*)NULL, (void*) NULL, 0);
09625 G__memfunc_setup("Initialize",1042,G__G__TMVA4_301_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::MethodBase' - 10 - rfbase", (char*)NULL, (void*) NULL, 0);
09626 G__memfunc_setup("SetMsgType",1013,G__G__TMVA4_301_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TMVA::EMsgType' - 0 - t", (char*)NULL, (void*) NULL, 0);
09627 G__memfunc_setup("SetTrainingEvents",1757,G__G__TMVA4_301_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' 'vector<TMVA::Event*>' 11 - el", (char*)NULL, (void*) NULL, 0);
09628 G__memfunc_setup("ReshuffleEvents",1561,G__G__TMVA4_301_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09629 G__memfunc_setup("SetMethodBase",1288,G__G__TMVA4_301_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::MethodBase' - 10 - rfbase", (char*)NULL, (void*) NULL, 0);
09630 G__memfunc_setup("MakeForest",1009,G__G__TMVA4_301_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09631 G__memfunc_setup("BuildTree",896,G__G__TMVA4_301_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::DecisionTree' - 0 - dt", (char*)NULL, (void*) NULL, 0);
09632 G__memfunc_setup("SaveEventWeights",1644,G__G__TMVA4_301_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09633 G__memfunc_setup("RestoreEventWeights",1985,G__G__TMVA4_301_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09634 G__memfunc_setup("Boost",519,G__G__TMVA4_301_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::DecisionTree' - 0 - dt", (char*)NULL, (void*) NULL, 0);
09635 G__memfunc_setup("ForestStatistics",1694,G__G__TMVA4_301_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09636 G__memfunc_setup("EvalEvent",906,G__G__TMVA4_301_0_16, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'TMVA::Event' - 11 - e", (char*)NULL, (void*) NULL, 0);
09637 G__memfunc_setup("CalcWeightSum",1296,G__G__TMVA4_301_0_17, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0,
09638 "U 'vector<TMVA::Event*,allocator<TMVA::Event*> >' 'vector<TMVA::Event*>' 10 - events h - 'UInt_t' 0 '0' neve", (char*)NULL, (void*) NULL, 0);
09639 G__memfunc_setup("FitCoefficients",1525,G__G__TMVA4_301_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09640 G__memfunc_setup("CalcImportance",1413,G__G__TMVA4_301_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09641 G__memfunc_setup("SetModelLinear",1400,G__G__TMVA4_301_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09642 G__memfunc_setup("SetModelRules",1320,G__G__TMVA4_301_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09643 G__memfunc_setup("SetModelFull",1200,G__G__TMVA4_301_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09644 G__memfunc_setup("SetImportanceCut",1642,G__G__TMVA4_301_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0' minimp", (char*)NULL, (void*) NULL, 0);
09645 G__memfunc_setup("SetRuleMinDist",1404,G__G__TMVA4_301_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - d", (char*)NULL, (void*) NULL, 0);
09646 G__memfunc_setup("SetGDTau",737,G__G__TMVA4_301_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.0' t", (char*)NULL, (void*) NULL, 0);
09647 G__memfunc_setup("SetGDPathStep",1248,G__G__TMVA4_301_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.01' s", (char*)NULL, (void*) NULL, 0);
09648 G__memfunc_setup("SetGDNPathSteps",1441,G__G__TMVA4_301_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '100' n", (char*)NULL, (void*) NULL, 0);
09649 G__memfunc_setup("SetVisHistsUseImp",1724,G__G__TMVA4_301_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - f", (char*)NULL, (void*) NULL, 0);
09650 G__memfunc_setup("UseImportanceVisHists",2172,G__G__TMVA4_301_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09651 G__memfunc_setup("UseCoefficientsVisHists",2364,G__G__TMVA4_301_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09652 G__memfunc_setup("MakeVisHists",1211,G__G__TMVA4_301_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09653 G__memfunc_setup("FillVisHistCut",1405,G__G__TMVA4_301_0_32, 121, -1, -1, 0, 2, 1, 1, 0,
09654 "U 'TMVA::Rule' - 10 - rule u 'vector<TH2F*,allocator<TH2F*> >' 'vector<TH2F*>' 1 - hlist", (char*)NULL, (void*) NULL, 0);
09655 G__memfunc_setup("FillVisHistCorr",1511,G__G__TMVA4_301_0_33, 121, -1, -1, 0, 2, 1, 1, 0,
09656 "U 'TMVA::Rule' - 10 - rule u 'vector<TH2F*,allocator<TH2F*> >' 'vector<TH2F*>' 1 - hlist", (char*)NULL, (void*) NULL, 0);
09657 G__memfunc_setup("FillCut",691,G__G__TMVA4_301_0_34, 121, -1, -1, 0, 3, 1, 1, 0,
09658 "U 'TH2F' - 0 - h2 U 'TMVA::Rule' - 10 - rule "
09659 "i - 'Int_t' 0 - vind", (char*)NULL, (void*) NULL, 0);
09660 G__memfunc_setup("FillLin",682,G__G__TMVA4_301_0_35, 121, -1, -1, 0, 2, 1, 1, 0,
09661 "U 'TH2F' - 0 - h2 i - 'Int_t' 0 - vind", (char*)NULL, (void*) NULL, 0);
09662 G__memfunc_setup("FillCorr",797,G__G__TMVA4_301_0_36, 121, -1, -1, 0, 4, 1, 1, 0,
09663 "U 'TH2F' - 0 - h2 U 'TMVA::Rule' - 10 - rule "
09664 "i - 'Int_t' 0 - v1 i - 'Int_t' 0 - v2", (char*)NULL, (void*) NULL, 0);
09665 G__memfunc_setup("NormVisHists",1241,G__G__TMVA4_301_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<TH2F*,allocator<TH2F*> >' 'vector<TH2F*>' 1 - hlist", (char*)NULL, (void*) NULL, 0);
09666 G__memfunc_setup("MakeDebugHists",1392,G__G__TMVA4_301_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09667 G__memfunc_setup("GetCorrVars",1106,G__G__TMVA4_301_0_39, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
09668 "u 'TString' - 1 - title u 'TString' - 1 - var1 "
09669 "u 'TString' - 1 - var2", (char*)NULL, (void*) NULL, 0);
09670 G__memfunc_setup("GetNTreeSample",1376,G__G__TMVA4_301_0_40, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09671 G__memfunc_setup("GetNEveEff",927,G__G__TMVA4_301_0_41, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "reweighted number of events = sum(wi)", (void*) NULL, 0);
09672 G__memfunc_setup("GetTrainingEvent",1630,G__G__TMVA4_301_0_42, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 1, 1, 1, 9, "h - 'UInt_t' 0 - i", (char*)NULL, (void*) NULL, 0);
09673 G__memfunc_setup("GetTrainingEventWeight",2246,G__G__TMVA4_301_0_43, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - i", (char*)NULL, (void*) NULL, 0);
09674 G__memfunc_setup("GetTrainingEvents",1745,G__G__TMVA4_301_0_44, 117, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR), G__defined_typename("vector<TMVA::Event*>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
09675 G__memfunc_setup("GetRndmSampleEvents",1928,G__G__TMVA4_301_0_45, 121, -1, -1, 0, 2, 1, 1, 0,
09676 "u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 1 - evevec h - 'UInt_t' 0 - nevents", (char*)NULL, (void*) NULL, 0);
09677 G__memfunc_setup("GetForest",915,G__G__TMVA4_301_0_46, 117, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR), G__defined_typename("vector<const TMVA::DecisionTree*>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
09678 G__memfunc_setup("GetRuleEnsemble",1507,G__G__TMVA4_301_0_47, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleEnsemble), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
09679 G__memfunc_setup("GetRuleEnsemblePtr",1817,G__G__TMVA4_301_0_48, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleEnsemble), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09680 G__memfunc_setup("GetRuleFitParams",1599,G__G__TMVA4_301_0_49, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitParams), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
09681 G__memfunc_setup("GetRuleFitParamsPtr",1909,G__G__TMVA4_301_0_50, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitParams), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09682 G__memfunc_setup("GetMethodRuleFit",1596,G__G__TMVA4_301_0_51, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMethodRuleFit), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
09683 G__memfunc_setup("GetMethodBase",1276,G__G__TMVA4_301_0_52, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMethodBase), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
09684 G__memfunc_setup("RuleFit",699,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFit), -1, 0, 1, 1, 4, 0, "u 'TMVA::RuleFit' - 11 - other", (char*)NULL, (void*) NULL, 0);
09685 G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TMVA::RuleFit' - 11 - other", (char*)NULL, (void*) NULL, 0);
09686 G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
09687 G__memfunc_setup("Class",502,G__G__TMVA4_301_0_56, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::RuleFit::Class) ), 0);
09688 G__memfunc_setup("Class_Name",982,G__G__TMVA4_301_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RuleFit::Class_Name) ), 0);
09689 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_301_0_58, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::RuleFit::Class_Version) ), 0);
09690 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_301_0_59, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::RuleFit::Dictionary) ), 0);
09691 G__memfunc_setup("IsA",253,G__G__TMVA4_301_0_60, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09692 G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_301_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09693 G__memfunc_setup("Streamer",835,G__G__TMVA4_301_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09694 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_301_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09695 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_301_0_64, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RuleFit::DeclFileName) ), 0);
09696 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_301_0_65, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::RuleFit::ImplFileLine) ), 0);
09697 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_301_0_66, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RuleFit::ImplFileName) ), 0);
09698 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_301_0_67, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::RuleFit::DeclFileLine) ), 0);
09699
09700 G__memfunc_setup("~RuleFit", 825, G__G__TMVA4_301_0_68, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09701 G__tag_memfunc_reset();
09702 }
09703
09704 static void G__setup_memfuncTMVAcLcLRuleFitAPI(void) {
09705
09706 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPI));
09707 G__memfunc_setup("RuleFitAPI",917,G__G__TMVA4_343_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPI), -1, 0, 3, 1, 1, 0,
09708 "U 'TMVA::MethodRuleFit' - 10 - rfbase U 'TMVA::RuleFit' - 0 - rulefit "
09709 "i 'TMVA::EMsgType' - 0 - minType", (char*)NULL, (void*) NULL, 0);
09710 G__memfunc_setup("WelcomeMessage",1425,G__G__TMVA4_343_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09711 G__memfunc_setup("HowtoSetupRF",1210,G__G__TMVA4_343_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09712 G__memfunc_setup("SetRFWorkDir",1158,G__G__TMVA4_343_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - wdir", (char*)NULL, (void*) NULL, 0);
09713 G__memfunc_setup("CheckRFWorkDir",1336,G__G__TMVA4_343_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09714 G__memfunc_setup("TrainRuleFit",1209,G__G__TMVA4_343_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09715 G__memfunc_setup("TestRuleFit",1115,G__G__TMVA4_343_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09716 G__memfunc_setup("VarImp",591,G__G__TMVA4_343_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09717 G__memfunc_setup("ReadModelSum",1186,G__G__TMVA4_343_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
09718 G__memfunc_setup("GetRFWorkDir",1146,G__G__TMVA4_343_0_10, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
09719 G__memfunc_setup("InitRuleFit",1103,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09720 G__memfunc_setup("FillRealParmsDef",1565,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09721 G__memfunc_setup("FillIntParmsDef",1476,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09722 G__memfunc_setup("ImportSetup",1164,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09723 G__memfunc_setup("SetTrainParms",1325,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09724 G__memfunc_setup("SetTestParms",1231,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09725 G__memfunc_setup("RunRuleFit",1008,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09726 G__memfunc_setup("SetRFTrain",962,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09727 G__memfunc_setup("SetRFPredict",1167,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09728 G__memfunc_setup("SetRFVarimp",1075,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09729 G__memfunc_setup("GetRFName",825,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 1, 1, 2, 0, "u 'TString' - 0 - name", (char*)NULL, (void*) NULL, 0);
09730 G__memfunc_setup("OpenRFile",868,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0,
09731 "u 'TString' - 0 - name u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - f", (char*)NULL, (void*) NULL, 0);
09732 G__memfunc_setup("OpenRFile",868,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0,
09733 "u 'TString' - 0 - name u 'basic_ifstream<char,char_traits<char> >' 'ifstream' 1 - f", (char*)NULL, (void*) NULL, 0);
09734 G__memfunc_setup("WriteInt",822,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 2, 0,
09735 "u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - f I - 'Int_t' 10 - v "
09736 "i - 'Int_t' 0 '1' n", (char*)NULL, (void*) NULL, 0);
09737 G__memfunc_setup("WriteFloat",1025,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 2, 0,
09738 "u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - f F - 'Float_t' 10 - v "
09739 "i - 'Int_t' 0 '1' n", (char*)NULL, (void*) NULL, 0);
09740 G__memfunc_setup("ReadInt",679,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 8,
09741 "u 'basic_ifstream<char,char_traits<char> >' 'ifstream' 1 - f I - 'Int_t' 0 - v "
09742 "i - 'Int_t' 0 '1' n", (char*)NULL, (void*) NULL, 0);
09743 G__memfunc_setup("ReadFloat",882,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 8,
09744 "u 'basic_ifstream<char,char_traits<char> >' 'ifstream' 1 - f F - 'Float_t' 0 - v "
09745 "i - 'Int_t' 0 '1' n", (char*)NULL, (void*) NULL, 0);
09746 G__memfunc_setup("WriteAll",804,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09747 G__memfunc_setup("WriteIntParms",1337,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09748 G__memfunc_setup("WriteRealParms",1426,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09749 G__memfunc_setup("WriteLx",719,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09750 G__memfunc_setup("WriteProgram",1251,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09751 G__memfunc_setup("WriteRealVarImp",1502,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09752 G__memfunc_setup("WriteRfOut",1019,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09753 G__memfunc_setup("WriteRfStatus",1351,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09754 G__memfunc_setup("WriteRuleFitMod",1510,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09755 G__memfunc_setup("WriteRuleFitSum",1531,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09756 G__memfunc_setup("WriteTrain",1033,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09757 G__memfunc_setup("WriteVarNames",1320,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09758 G__memfunc_setup("WriteVarImp",1114,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09759 G__memfunc_setup("WriteYhat",929,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09760 G__memfunc_setup("WriteTest",939,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09761 G__memfunc_setup("ReadYhat",786,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09762 G__memfunc_setup("ReadIntParms",1194,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09763 G__memfunc_setup("ReadRealParms",1283,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09764 G__memfunc_setup("ReadLx",576,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09765 G__memfunc_setup("ReadProgram",1108,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09766 G__memfunc_setup("ReadRealVarImp",1359,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09767 G__memfunc_setup("ReadRfOut",876,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09768 G__memfunc_setup("ReadRfStatus",1208,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09769 G__memfunc_setup("ReadRuleFitMod",1367,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09770 G__memfunc_setup("ReadRuleFitSum",1388,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09771 G__memfunc_setup("ReadTrainX",978,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09772 G__memfunc_setup("ReadTrainY",979,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09773 G__memfunc_setup("ReadTrainW",977,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09774 G__memfunc_setup("ReadVarNames",1177,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09775 G__memfunc_setup("ReadVarImp",971,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09776 G__memfunc_setup("RuleFitAPI",917,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPI), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
09777 G__memfunc_setup("Class",502,G__G__TMVA4_343_0_59, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::RuleFitAPI::Class) ), 0);
09778 G__memfunc_setup("Class_Name",982,G__G__TMVA4_343_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RuleFitAPI::Class_Name) ), 0);
09779 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_343_0_61, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::RuleFitAPI::Class_Version) ), 0);
09780 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_343_0_62, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::RuleFitAPI::Dictionary) ), 0);
09781 G__memfunc_setup("IsA",253,G__G__TMVA4_343_0_63, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09782 G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_343_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09783 G__memfunc_setup("Streamer",835,G__G__TMVA4_343_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09784 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_343_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09785 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_343_0_67, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RuleFitAPI::DeclFileName) ), 0);
09786 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_343_0_68, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::RuleFitAPI::ImplFileLine) ), 0);
09787 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_343_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RuleFitAPI::ImplFileName) ), 0);
09788 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_343_0_70, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::RuleFitAPI::DeclFileLine) ), 0);
09789
09790 G__memfunc_setup("~RuleFitAPI", 1043, G__G__TMVA4_343_0_71, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09791 G__tag_memfunc_reset();
09792 }
09793
09794 static void G__setup_memfuncTMVAcLcLIMethod(void) {
09795
09796 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLIMethod));
09797 G__memfunc_setup("GetName",673,G__G__TMVA4_350_0_2, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
09798 G__memfunc_setup("GetMvaValue",1089,G__G__TMVA4_350_0_3, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0,
09799 "D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 3);
09800 G__memfunc_setup("Train",510,G__G__TMVA4_350_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
09801 G__memfunc_setup("ReadWeightsFromStream",2135,G__G__TMVA4_350_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - -", (char*)NULL, (void*) NULL, 3);
09802 G__memfunc_setup("WriteMonitoringHistosToFile",2798,G__G__TMVA4_350_0_6, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
09803 G__memfunc_setup("MakeClass",884,G__G__TMVA4_350_0_7, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TString' - 11 'TString(\"\")' classFileName", (char*)NULL, (void*) NULL, 3);
09804 G__memfunc_setup("CreateRanking",1310,G__G__TMVA4_350_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 3);
09805 G__memfunc_setup("PrintHelpMessage",1627,G__G__TMVA4_350_0_9, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
09806 G__memfunc_setup("MonitorBoost",1263,G__G__TMVA4_350_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TMVA::MethodBoost' - 0 - boost", (char*)NULL, (void*) NULL, 3);
09807 G__memfunc_setup("Init",404,G__G__TMVA4_350_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
09808 G__memfunc_setup("DeclareOptions",1436,G__G__TMVA4_350_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
09809 G__memfunc_setup("ProcessOptions",1483,G__G__TMVA4_350_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
09810 G__memfunc_setup("HasAnalysisType",1538,G__G__TMVA4_350_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
09811 "i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
09812 "h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 3);
09813 G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8,
09814 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 3);
09815 G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 3);
09816 G__memfunc_setup("Class",502,G__G__TMVA4_350_0_17, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::IMethod::Class) ), 0);
09817 G__memfunc_setup("Class_Name",982,G__G__TMVA4_350_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::IMethod::Class_Name) ), 0);
09818 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_350_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::IMethod::Class_Version) ), 0);
09819 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_350_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::IMethod::Dictionary) ), 0);
09820 G__memfunc_setup("IsA",253,G__G__TMVA4_350_0_21, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09821 G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_350_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09822 G__memfunc_setup("Streamer",835,G__G__TMVA4_350_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09823 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_350_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09824 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_350_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::IMethod::DeclFileName) ), 0);
09825 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_350_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::IMethod::ImplFileLine) ), 0);
09826 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_350_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::IMethod::ImplFileName) ), 0);
09827 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_350_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::IMethod::DeclFileLine) ), 0);
09828
09829 G__memfunc_setup("~IMethod", 808, G__G__TMVA4_350_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09830
09831 G__memfunc_setup("operator=", 937, G__G__TMVA4_350_0_30, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLIMethod), -1, 1, 1, 1, 1, 0, "u 'TMVA::IMethod' - 11 - -", (char*) NULL, (void*) NULL, 0);
09832 G__tag_memfunc_reset();
09833 }
09834
09835 static void G__setup_memfuncTMVAcLcLVariableTransformBase(void) {
09836
09837 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase));
09838 G__memfunc_setup("Initialize",1042,G__G__TMVA4_400_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
09839 G__memfunc_setup("PrepareTransformation",2214,G__G__TMVA4_400_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 3);
09840 G__memfunc_setup("Transform",956,G__G__TMVA4_400_0_4, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9,
09841 "U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 3);
09842 G__memfunc_setup("InverseTransform",1688,G__G__TMVA4_400_0_5, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9,
09843 "U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 3);
09844 G__memfunc_setup("SetEnabled",983,G__G__TMVA4_400_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - e", (char*)NULL, (void*) NULL, 0);
09845 G__memfunc_setup("SetNormalise",1238,G__G__TMVA4_400_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - n", (char*)NULL, (void*) NULL, 0);
09846 G__memfunc_setup("IsEnabled",871,G__G__TMVA4_400_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09847 G__memfunc_setup("IsCreated",884,G__G__TMVA4_400_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09848 G__memfunc_setup("IsNormalised",1226,G__G__TMVA4_400_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09849 G__memfunc_setup("SetUseSignalTransform",2163,G__G__TMVA4_400_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' e", (char*)NULL, (void*) NULL, 0);
09850 G__memfunc_setup("UseSignalTransform",1863,G__G__TMVA4_400_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09851 G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
09852 G__memfunc_setup("GetShortName",1201,G__G__TMVA4_400_0_14, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09853 G__memfunc_setup("WriteTransformationToStream",2833,G__G__TMVA4_400_0_15, 121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o", (char*)NULL, (void*) NULL, 3);
09854 G__memfunc_setup("ReadTransformationFromStream",2899,G__G__TMVA4_400_0_16, 121, -1, -1, 0, 2, 1, 1, 0,
09855 "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr u 'TString' - 11 '\"\"' classname", (char*)NULL, (void*) NULL, 3);
09856 G__memfunc_setup("AttachXMLTo",1033,G__G__TMVA4_400_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 3);
09857 G__memfunc_setup("ReadFromXML",1025,G__G__TMVA4_400_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - trfnode", (char*)NULL, (void*) NULL, 3);
09858 G__memfunc_setup("GetVariableTransform",2050,G__G__TMVA4_400_0_19, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09859 G__memfunc_setup("MakeFunction",1220,G__G__TMVA4_400_0_20, 121, -1, -1, 0, 5, 1, 1, 0,
09860 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName "
09861 "i - 'Int_t' 0 - part h - 'UInt_t' 0 - trCounter "
09862 "i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 3);
09863 G__memfunc_setup("GetTransformationStrings",2529,G__G__TMVA4_400_0_21, 85, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR), G__defined_typename("vector<TString>"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
09864 G__memfunc_setup("PrintTransformation",2020,G__G__TMVA4_400_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 1);
09865 G__memfunc_setup("Variables",921,G__G__TMVA4_400_0_23, 117, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR), G__defined_typename("vector<TMVA::VariableInfo>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
09866 G__memfunc_setup("Targets",730,G__G__TMVA4_400_0_24, 117, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR), G__defined_typename("vector<TMVA::VariableInfo>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
09867 G__memfunc_setup("Log",290,G__G__TMVA4_400_0_25, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
09868 G__memfunc_setup("SetTMVAVersion",1354,G__G__TMVA4_400_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'TMVA::TMVAVersion_t' 0 - v", (char*)NULL, (void*) NULL, 0);
09869 G__memfunc_setup("CalcNorm",783,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 0);
09870 G__memfunc_setup("SetCreated",996,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' c", (char*)NULL, (void*) NULL, 0);
09871 G__memfunc_setup("SetNVariables",1299,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "h - 'UInt_t' 0 - i", (char*)NULL, (void*) NULL, 0);
09872 G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TString' - 11 - c", (char*)NULL, (void*) NULL, 0);
09873 G__memfunc_setup("GetNVariables",1287,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
09874 G__memfunc_setup("GetNTargets",1096,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
09875 G__memfunc_setup("Variables",921,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR), G__defined_typename("vector<TMVA::VariableInfo>"), 1, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09876 G__memfunc_setup("Targets",730,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR), G__defined_typename("vector<TMVA::VariableInfo>"), 1, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
09877 G__memfunc_setup("GetNClasses",1084,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
09878 G__memfunc_setup("UpdateNorm",1023,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0,
09879 "i - 'Int_t' 0 - ivar d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
09880 G__memfunc_setup("Class",502,G__G__TMVA4_400_0_37, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::VariableTransformBase::Class) ), 0);
09881 G__memfunc_setup("Class_Name",982,G__G__TMVA4_400_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableTransformBase::Class_Name) ), 0);
09882 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_400_0_39, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::VariableTransformBase::Class_Version) ), 0);
09883 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_400_0_40, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::VariableTransformBase::Dictionary) ), 0);
09884 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09885 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09886 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09887 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_400_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09888 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_400_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableTransformBase::DeclFileName) ), 0);
09889 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_400_0_46, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableTransformBase::ImplFileLine) ), 0);
09890 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_400_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableTransformBase::ImplFileName) ), 0);
09891 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_400_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableTransformBase::DeclFileLine) ), 0);
09892
09893 G__memfunc_setup("~VariableTransformBase", 2267, G__G__TMVA4_400_0_49, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09894 G__tag_memfunc_reset();
09895 }
09896
09897 static void G__setup_memfuncTMVAcLcLVariableIdentityTransform(void) {
09898
09899 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform));
09900 G__memfunc_setup("VariableIdentityTransform",2604,G__G__TMVA4_411_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::DataSetInfo' - 1 - dsi", (char*)NULL, (void*) NULL, 0);
09901 G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09902 G__memfunc_setup("PrepareTransformation",2214,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 1);
09903 G__memfunc_setup("WriteTransformationToStream",2833,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 1);
09904 G__memfunc_setup("ReadTransformationFromStream",2899,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
09905 "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
09906 G__memfunc_setup("AttachXMLTo",1033,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
09907 G__memfunc_setup("ReadFromXML",1025,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - trfnode", (char*)NULL, (void*) NULL, 1);
09908 G__memfunc_setup("Transform",956,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9,
09909 "U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
09910 G__memfunc_setup("InverseTransform",1688,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9,
09911 "U 'TMVA::Event' - 50 - ev i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
09912 G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0,
09913 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName "
09914 "i - 'Int_t' 0 - part h - 'UInt_t' 0 - trCounter "
09915 "i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
09916 G__memfunc_setup("Class",502,G__G__TMVA4_411_0_11, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::VariableIdentityTransform::Class) ), 0);
09917 G__memfunc_setup("Class_Name",982,G__G__TMVA4_411_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableIdentityTransform::Class_Name) ), 0);
09918 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_411_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::VariableIdentityTransform::Class_Version) ), 0);
09919 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_411_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::VariableIdentityTransform::Dictionary) ), 0);
09920 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09921 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09922 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09923 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_411_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09924 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_411_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableIdentityTransform::DeclFileName) ), 0);
09925 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_411_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableIdentityTransform::ImplFileLine) ), 0);
09926 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_411_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableIdentityTransform::ImplFileName) ), 0);
09927 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_411_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableIdentityTransform::DeclFileLine) ), 0);
09928
09929 G__memfunc_setup("VariableIdentityTransform", 2604, G__G__TMVA4_411_0_23, (int) ('i'),
09930 G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::VariableIdentityTransform' - 11 - -", (char*) NULL, (void*) NULL, 0);
09931
09932 G__memfunc_setup("~VariableIdentityTransform", 2730, G__G__TMVA4_411_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09933 G__tag_memfunc_reset();
09934 }
09935
09936 static void G__setup_memfuncTMVAcLcLVariableDecorrTransform(void) {
09937
09938 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform));
09939 G__memfunc_setup("VariableDecorrTransform",2369,G__G__TMVA4_413_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::DataSetInfo' - 1 - dsi", (char*)NULL, (void*) NULL, 0);
09940 G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09941 G__memfunc_setup("PrepareTransformation",2214,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 1);
09942 G__memfunc_setup("Transform",956,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9,
09943 "U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
09944 G__memfunc_setup("InverseTransform",1688,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9,
09945 "U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
09946 G__memfunc_setup("WriteTransformationToStream",2833,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 1);
09947 G__memfunc_setup("ReadTransformationFromStream",2899,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
09948 "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
09949 G__memfunc_setup("AttachXMLTo",1033,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
09950 G__memfunc_setup("ReadFromXML",1025,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - trfnode", (char*)NULL, (void*) NULL, 1);
09951 G__memfunc_setup("PrintTransformation",2020,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o", (char*)NULL, (void*) NULL, 1);
09952 G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0,
09953 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName "
09954 "i - 'Int_t' 0 - part h - 'UInt_t' 0 - trCounter "
09955 "i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
09956 G__memfunc_setup("GetTransformationStrings",2529,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR), G__defined_typename("vector<TString>"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
09957 G__memfunc_setup("CalcSQRMats",1022,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0,
09958 "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - - i - 'Int_t' 0 - maxCls", (char*)NULL, (void*) NULL, 0);
09959 G__memfunc_setup("Class",502,G__G__TMVA4_413_0_14, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::VariableDecorrTransform::Class) ), 0);
09960 G__memfunc_setup("Class_Name",982,G__G__TMVA4_413_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableDecorrTransform::Class_Name) ), 0);
09961 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_413_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::VariableDecorrTransform::Class_Version) ), 0);
09962 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_413_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::VariableDecorrTransform::Dictionary) ), 0);
09963 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
09964 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
09965 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
09966 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_413_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
09967 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_413_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableDecorrTransform::DeclFileName) ), 0);
09968 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_413_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableDecorrTransform::ImplFileLine) ), 0);
09969 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_413_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableDecorrTransform::ImplFileName) ), 0);
09970 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_413_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableDecorrTransform::DeclFileLine) ), 0);
09971
09972 G__memfunc_setup("VariableDecorrTransform", 2369, G__G__TMVA4_413_0_26, (int) ('i'),
09973 G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::VariableDecorrTransform' - 11 - -", (char*) NULL, (void*) NULL, 0);
09974
09975 G__memfunc_setup("~VariableDecorrTransform", 2495, G__G__TMVA4_413_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
09976 G__tag_memfunc_reset();
09977 }
09978
09979 static void G__setup_memfuncTMVAcLcLVariablePCATransform(void) {
09980
09981 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform));
09982 G__memfunc_setup("VariablePCATransform",1974,G__G__TMVA4_476_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::DataSetInfo' - 1 - dsi", (char*)NULL, (void*) NULL, 0);
09983 G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
09984 G__memfunc_setup("PrepareTransformation",2214,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 1);
09985 G__memfunc_setup("Transform",956,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9,
09986 "U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
09987 G__memfunc_setup("InverseTransform",1688,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9,
09988 "U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
09989 G__memfunc_setup("WriteTransformationToStream",2833,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 1);
09990 G__memfunc_setup("ReadTransformationFromStream",2899,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
09991 "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
09992 G__memfunc_setup("AttachXMLTo",1033,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
09993 G__memfunc_setup("ReadFromXML",1025,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - trfnode", (char*)NULL, (void*) NULL, 1);
09994 G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0,
09995 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName "
09996 "i - 'Int_t' 0 - part h - 'UInt_t' 0 - trCounter "
09997 "i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
09998 G__memfunc_setup("CalculatePrincipalComponents",2902,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 0);
09999 G__memfunc_setup("X2P",218,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 2, 1, 4, 8,
10000 "u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 0);
10001 G__memfunc_setup("Class",502,G__G__TMVA4_476_0_13, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::VariablePCATransform::Class) ), 0);
10002 G__memfunc_setup("Class_Name",982,G__G__TMVA4_476_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariablePCATransform::Class_Name) ), 0);
10003 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_476_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::VariablePCATransform::Class_Version) ), 0);
10004 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_476_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::VariablePCATransform::Dictionary) ), 0);
10005 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
10006 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
10007 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
10008 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_476_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
10009 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_476_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariablePCATransform::DeclFileName) ), 0);
10010 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_476_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariablePCATransform::ImplFileLine) ), 0);
10011 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_476_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariablePCATransform::ImplFileName) ), 0);
10012 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_476_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariablePCATransform::DeclFileLine) ), 0);
10013
10014 G__memfunc_setup("VariablePCATransform", 1974, G__G__TMVA4_476_0_25, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::VariablePCATransform' - 11 - -", (char*) NULL, (void*) NULL, 0);
10015
10016 G__memfunc_setup("~VariablePCATransform", 2100, G__G__TMVA4_476_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
10017 G__tag_memfunc_reset();
10018 }
10019
10020 static void G__setup_memfuncTMVAcLcLVariableGaussTransform(void) {
10021
10022 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform));
10023 G__memfunc_setup("VariableGaussTransform",2277,G__G__TMVA4_514_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform), -1, 0, 2, 1, 1, 0,
10024 "u 'TMVA::DataSetInfo' - 1 - dsi u 'TString' - 0 '\"\"' strcor", (char*)NULL, (void*) NULL, 0);
10025 G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
10026 G__memfunc_setup("PrepareTransformation",2214,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 1);
10027 G__memfunc_setup("Transform",956,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9,
10028 "U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
10029 G__memfunc_setup("InverseTransform",1688,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9,
10030 "U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
10031 G__memfunc_setup("WriteTransformationToStream",2833,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 1);
10032 G__memfunc_setup("ReadTransformationFromStream",2899,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
10033 "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
10034 G__memfunc_setup("AttachXMLTo",1033,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
10035 G__memfunc_setup("ReadFromXML",1025,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - trfnode", (char*)NULL, (void*) NULL, 1);
10036 G__memfunc_setup("PrintTransformation",2020,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o", (char*)NULL, (void*) NULL, 1);
10037 G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0,
10038 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName "
10039 "i - 'Int_t' 0 - part h - 'UInt_t' 0 - trCounter "
10040 "i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
10041 G__memfunc_setup("GetCumulativeDist",1747,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 0);
10042 G__memfunc_setup("CleanUpCumulativeArrays",2361,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TString' - 0 '\"ALL\"' opt", (char*)NULL, (void*) NULL, 0);
10043 G__memfunc_setup("OldCumulant",1128,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 8,
10044 "f - 'Float_t' 0 - x U 'TH1' - 0 - h", (char*)NULL, (void*) NULL, 0);
10045 G__memfunc_setup("Class",502,G__G__TMVA4_514_0_15, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::VariableGaussTransform::Class) ), 0);
10046 G__memfunc_setup("Class_Name",982,G__G__TMVA4_514_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableGaussTransform::Class_Name) ), 0);
10047 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_514_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::VariableGaussTransform::Class_Version) ), 0);
10048 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_514_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::VariableGaussTransform::Dictionary) ), 0);
10049 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
10050 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
10051 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
10052 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_514_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
10053 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_514_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableGaussTransform::DeclFileName) ), 0);
10054 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_514_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableGaussTransform::ImplFileLine) ), 0);
10055 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_514_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableGaussTransform::ImplFileName) ), 0);
10056 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_514_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableGaussTransform::DeclFileLine) ), 0);
10057
10058 G__memfunc_setup("VariableGaussTransform", 2277, G__G__TMVA4_514_0_27, (int) ('i'),
10059 G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::VariableGaussTransform' - 11 - -", (char*) NULL, (void*) NULL, 0);
10060
10061 G__memfunc_setup("~VariableGaussTransform", 2403, G__G__TMVA4_514_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
10062 G__tag_memfunc_reset();
10063 }
10064
10065 static void G__setup_memfuncTMVAcLcLVariableNormalizeTransform(void) {
10066
10067 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform));
10068 G__memfunc_setup("VariableNormalizeTransform",2707,G__G__TMVA4_527_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::DataSetInfo' - 1 - dsi", (char*)NULL, (void*) NULL, 0);
10069 G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
10070 G__memfunc_setup("PrepareTransformation",2214,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 1);
10071 G__memfunc_setup("Transform",956,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9,
10072 "U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
10073 G__memfunc_setup("InverseTransform",1688,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9,
10074 "U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
10075 G__memfunc_setup("WriteTransformationToStream",2833,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 1);
10076 G__memfunc_setup("ReadTransformationFromStream",2899,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
10077 "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
10078 G__memfunc_setup("BuildTransformationFromVarInfo",3088,G__G__TMVA4_527_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<TMVA::VariableInfo,allocator<TMVA::VariableInfo> >' 'vector<TMVA::VariableInfo>' 11 - var", (char*)NULL, (void*) NULL, 0);
10079 G__memfunc_setup("AttachXMLTo",1033,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
10080 G__memfunc_setup("ReadFromXML",1025,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - trfnode", (char*)NULL, (void*) NULL, 1);
10081 G__memfunc_setup("PrintTransformation",2020,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o", (char*)NULL, (void*) NULL, 1);
10082 G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0,
10083 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName "
10084 "i - 'Int_t' 0 - part h - 'UInt_t' 0 - trCounter "
10085 "i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
10086 G__memfunc_setup("GetTransformationStrings",2529,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR), G__defined_typename("vector<TString>"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
10087 G__memfunc_setup("CalcNormalizationParams",2366,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - events", (char*)NULL, (void*) NULL, 0);
10088 G__memfunc_setup("Class",502,G__G__TMVA4_527_0_15, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::VariableNormalizeTransform::Class) ), 0);
10089 G__memfunc_setup("Class_Name",982,G__G__TMVA4_527_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableNormalizeTransform::Class_Name) ), 0);
10090 G__memfunc_setup("Class_Version",1339,G__G__TMVA4_527_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::VariableNormalizeTransform::Class_Version) ), 0);
10091 G__memfunc_setup("Dictionary",1046,G__G__TMVA4_527_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::VariableNormalizeTransform::Dictionary) ), 0);
10092 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
10093 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
10094 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
10095 G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_527_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
10096 G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_527_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableNormalizeTransform::DeclFileName) ), 0);
10097 G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_527_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableNormalizeTransform::ImplFileLine) ), 0);
10098 G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_527_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableNormalizeTransform::ImplFileName) ), 0);
10099 G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_527_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableNormalizeTransform::DeclFileLine) ), 0);
10100
10101 G__memfunc_setup("VariableNormalizeTransform", 2707, G__G__TMVA4_527_0_27, (int) ('i'),
10102 G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::VariableNormalizeTransform' - 11 - -", (char*) NULL, (void*) NULL, 0);
10103
10104 G__memfunc_setup("~VariableNormalizeTransform", 2833, G__G__TMVA4_527_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
10105 G__tag_memfunc_reset();
10106 }
10107
10108
10109
10110
10111
10112 extern "C" void G__cpp_setup_memfuncG__TMVA4() {
10113 }
10114
10115
10116
10117
10118 static void G__cpp_setup_global0() {
10119
10120
10121 G__resetplocal();
10122
10123 }
10124
10125 static void G__cpp_setup_global1() {
10126 }
10127
10128 static void G__cpp_setup_global2() {
10129 }
10130
10131 static void G__cpp_setup_global3() {
10132 }
10133
10134 static void G__cpp_setup_global4() {
10135
10136 G__resetglobalenv();
10137 }
10138 extern "C" void G__cpp_setup_globalG__TMVA4() {
10139 G__cpp_setup_global0();
10140 G__cpp_setup_global1();
10141 G__cpp_setup_global2();
10142 G__cpp_setup_global3();
10143 G__cpp_setup_global4();
10144 }
10145
10146
10147
10148
10149 static void G__cpp_setup_func0() {
10150 G__lastifuncposition();
10151
10152 }
10153
10154 static void G__cpp_setup_func1() {
10155 }
10156
10157 static void G__cpp_setup_func2() {
10158 }
10159
10160 static void G__cpp_setup_func3() {
10161 }
10162
10163 static void G__cpp_setup_func4() {
10164 }
10165
10166 static void G__cpp_setup_func5() {
10167 }
10168
10169 static void G__cpp_setup_func6() {
10170 }
10171
10172 static void G__cpp_setup_func7() {
10173 }
10174
10175 static void G__cpp_setup_func8() {
10176 }
10177
10178 static void G__cpp_setup_func9() {
10179 }
10180
10181 static void G__cpp_setup_func10() {
10182 }
10183
10184 static void G__cpp_setup_func11() {
10185 }
10186
10187 static void G__cpp_setup_func12() {
10188 }
10189
10190 static void G__cpp_setup_func13() {
10191 }
10192
10193 static void G__cpp_setup_func14() {
10194 }
10195
10196 static void G__cpp_setup_func15() {
10197 }
10198
10199 static void G__cpp_setup_func16() {
10200 }
10201
10202 static void G__cpp_setup_func17() {
10203 }
10204
10205 static void G__cpp_setup_func18() {
10206 }
10207
10208 static void G__cpp_setup_func19() {
10209 }
10210
10211 static void G__cpp_setup_func20() {
10212 }
10213
10214 static void G__cpp_setup_func21() {
10215 }
10216
10217 static void G__cpp_setup_func22() {
10218 }
10219
10220 static void G__cpp_setup_func23() {
10221
10222 G__resetifuncposition();
10223 }
10224
10225 extern "C" void G__cpp_setup_funcG__TMVA4() {
10226 G__cpp_setup_func0();
10227 G__cpp_setup_func1();
10228 G__cpp_setup_func2();
10229 G__cpp_setup_func3();
10230 G__cpp_setup_func4();
10231 G__cpp_setup_func5();
10232 G__cpp_setup_func6();
10233 G__cpp_setup_func7();
10234 G__cpp_setup_func8();
10235 G__cpp_setup_func9();
10236 G__cpp_setup_func10();
10237 G__cpp_setup_func11();
10238 G__cpp_setup_func12();
10239 G__cpp_setup_func13();
10240 G__cpp_setup_func14();
10241 G__cpp_setup_func15();
10242 G__cpp_setup_func16();
10243 G__cpp_setup_func17();
10244 G__cpp_setup_func18();
10245 G__cpp_setup_func19();
10246 G__cpp_setup_func20();
10247 G__cpp_setup_func21();
10248 G__cpp_setup_func22();
10249 G__cpp_setup_func23();
10250 }
10251
10252
10253
10254
10255
10256 G__linked_taginfo G__G__TMVA4LN_TClass = { "TClass" , 99 , -1 };
10257 G__linked_taginfo G__G__TMVA4LN_TBuffer = { "TBuffer" , 99 , -1 };
10258 G__linked_taginfo G__G__TMVA4LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
10259 G__linked_taginfo G__G__TMVA4LN_TObject = { "TObject" , 99 , -1 };
10260 G__linked_taginfo G__G__TMVA4LN_TString = { "TString" , 99 , -1 };
10261 G__linked_taginfo G__G__TMVA4LN_ios_base = { "ios_base" , 99 , -1 };
10262 G__linked_taginfo G__G__TMVA4LN_basic_istreamlEcharcOchar_traitslEchargRsPgR = { "basic_istream<char,char_traits<char> >" , 99 , -1 };
10263 G__linked_taginfo G__G__TMVA4LN_basic_ioslEcharcOchar_traitslEchargRsPgR = { "basic_ios<char,char_traits<char> >" , 99 , -1 };
10264 G__linked_taginfo G__G__TMVA4LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
10265 G__linked_taginfo G__G__TMVA4LN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR = { "basic_ifstream<char,char_traits<char> >" , 99 , -1 };
10266 G__linked_taginfo G__G__TMVA4LN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR = { "basic_ofstream<char,char_traits<char> >" , 99 , -1 };
10267 G__linked_taginfo G__G__TMVA4LN_string = { "string" , 99 , -1 };
10268 G__linked_taginfo G__G__TMVA4LN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR = { "basic_ostringstream<char,char_traits<char>,allocator<char> >" , 99 , -1 };
10269 G__linked_taginfo G__G__TMVA4LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
10270 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
10271 G__linked_taginfo G__G__TMVA4LN_TObjArray = { "TObjArray" , 99 , -1 };
10272 G__linked_taginfo G__G__TMVA4LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
10273 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
10274 G__linked_taginfo G__G__TMVA4LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
10275 G__linked_taginfo G__G__TMVA4LN_TFormula = { "TFormula" , 99 , -1 };
10276 G__linked_taginfo G__G__TMVA4LN_TMVA = { "TMVA" , 110 , -1 };
10277 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTNeuron = { "TMVA::TNeuron" , 99 , -1 };
10278 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLMsgLogger = { "TMVA::MsgLogger" , 99 , -1 };
10279 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTSynapse = { "TMVA::TSynapse" , 99 , -1 };
10280 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTActivation = { "TMVA::TActivation" , 99 , -1 };
10281 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLEMsgType = { "TMVA::EMsgType" , 101 , -1 };
10282 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTypes = { "TMVA::Types" , 99 , -1 };
10283 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA = { "TMVA::Types::EMVA" , 101 , -1 };
10284 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform = { "TMVA::Types::EVariableTransform" , 101 , -1 };
10285 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType = { "TMVA::Types::EAnalysisType" , 101 , -1 };
10286 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTypescLcLESBType = { "TMVA::Types::ESBType" , 101 , -1 };
10287 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType = { "TMVA::Types::ETreeType" , 101 , -1 };
10288 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage = { "TMVA::Types::EBoostStage" , 101 , -1 };
10289 G__linked_taginfo G__G__TMVA4LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR = { "map<TString,TMVA::Types::EMVA,less<TString>,allocator<pair<const TString,TMVA::Types::EMVA> > >" , 99 , -1 };
10290 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTNeuronInput = { "TMVA::TNeuronInput" , 99 , -1 };
10291 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTActivationChooser = { "TMVA::TActivationChooser" , 99 , -1 };
10292 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTActivationChoosercLcLEActivationType = { "TMVA::TActivationChooser::EActivationType" , 101 , -1 };
10293 G__linked_taginfo G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
10294 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
10295 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTActivationSigmoid = { "TMVA::TActivationSigmoid" , 99 , -1 };
10296 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTActivationIdentity = { "TMVA::TActivationIdentity" , 99 , -1 };
10297 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTActivationTanh = { "TMVA::TActivationTanh" , 99 , -1 };
10298 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTActivationRadial = { "TMVA::TActivationRadial" , 99 , -1 };
10299 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTNeuronInputSum = { "TMVA::TNeuronInputSum" , 99 , -1 };
10300 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum = { "TMVA::TNeuronInputSqSum" , 99 , -1 };
10301 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs = { "TMVA::TNeuronInputAbs" , 99 , -1 };
10302 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser = { "TMVA::TNeuronInputChooser" , 99 , -1 };
10303 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTNeuronInputChoosercLcLENeuronInputType = { "TMVA::TNeuronInputChooser::ENeuronInputType" , 101 , -1 };
10304 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRank = { "TMVA::Rank" , 99 , -1 };
10305 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRanking = { "TMVA::Ranking" , 99 , -1 };
10306 G__linked_taginfo G__G__TMVA4LN_vectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgR = { "vector<TMVA::Rank,allocator<TMVA::Rank> >" , 99 , -1 };
10307 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Rank,allocator<TMVA::Rank> >::iterator>" , 99 , -1 };
10308 G__linked_taginfo G__G__TMVA4LN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
10309 G__linked_taginfo G__G__TMVA4LN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
10310 G__linked_taginfo G__G__TMVA4LN_TH1 = { "TH1" , 99 , -1 };
10311 G__linked_taginfo G__G__TMVA4LN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
10312 G__linked_taginfo G__G__TMVA4LN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
10313 G__linked_taginfo G__G__TMVA4LN_TH2F = { "TH2F" , 99 , -1 };
10314 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLNode = { "TMVA::Node" , 99 , -1 };
10315 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLEvent = { "TMVA::Event" , 99 , -1 };
10316 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLBinaryTree = { "TMVA::BinaryTree" , 99 , -1 };
10317 G__linked_taginfo G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR = { "vector<float,allocator<float> >" , 99 , -1 };
10318 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<float,allocator<float> >::iterator>" , 99 , -1 };
10319 G__linked_taginfo G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
10320 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<double,allocator<double> >::iterator>" , 99 , -1 };
10321 G__linked_taginfo G__G__TMVA4LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR = { "vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >" , 99 , -1 };
10322 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >::iterator>" , 99 , -1 };
10323 G__linked_taginfo G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR = { "vector<TMVA::Event*,allocator<TMVA::Event*> >" , 99 , -1 };
10324 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Event*,allocator<TMVA::Event*> >::iterator>" , 99 , -1 };
10325 G__linked_taginfo G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
10326 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
10327 G__linked_taginfo G__G__TMVA4LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR = { "pair<double,const TMVA::Event*>" , 115 , -1 };
10328 G__linked_taginfo G__G__TMVA4LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR = { "vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >" , 99 , -1 };
10329 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >::iterator>" , 99 , -1 };
10330 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLDecisionTree = { "TMVA::DecisionTree" , 99 , -1 };
10331 G__linked_taginfo G__G__TMVA4LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR = { "vector<float*,allocator<float*> >" , 99 , -1 };
10332 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<float*,allocator<float*> >::iterator>" , 99 , -1 };
10333 G__linked_taginfo G__G__TMVA4LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
10334 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
10335 G__linked_taginfo G__G__TMVA4LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR = { "vector<const TMVA::Node*,allocator<const TMVA::Node*> >" , 99 , -1 };
10336 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::Node*,allocator<const TMVA::Node*> >::iterator>" , 99 , -1 };
10337 G__linked_taginfo G__G__TMVA4LN_vectorlEcharcOallocatorlEchargRsPgR = { "vector<char,allocator<char> >" , 99 , -1 };
10338 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR = { "reverse_iterator<vector<char,allocator<char> >::iterator>" , 99 , -1 };
10339 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleEnsemble = { "TMVA::RuleEnsemble" , 99 , -1 };
10340 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRule = { "TMVA::Rule" , 99 , -1 };
10341 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLMethodBase = { "TMVA::MethodBase" , 99 , -1 };
10342 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleFit = { "TMVA::RuleFit" , 99 , -1 };
10343 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLMethodRuleFit = { "TMVA::MethodRuleFit" , 99 , -1 };
10344 G__linked_taginfo G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR = { "vector<const TMVA::DecisionTree*,allocator<const TMVA::DecisionTree*> >" , 99 , -1 };
10345 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::DecisionTree*,allocator<const TMVA::DecisionTree*> >::iterator>" , 99 , -1 };
10346 G__linked_taginfo G__G__TMVA4LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR = { "vector<TMVA::Rule*,allocator<TMVA::Rule*> >" , 99 , -1 };
10347 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Rule*,allocator<TMVA::Rule*> >::iterator>" , 99 , -1 };
10348 G__linked_taginfo G__G__TMVA4LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR = { "vector<TH1F*,allocator<TH1F*> >" , 99 , -1 };
10349 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TH1F*,allocator<TH1F*> >::iterator>" , 99 , -1 };
10350 G__linked_taginfo G__G__TMVA4LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR = { "vector<vector<unsigned int,allocator<unsigned int> >,allocator<vector<unsigned int,allocator<unsigned int> > > >" , 99 , -1 };
10351 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<unsigned int,allocator<unsigned int> >,allocator<vector<unsigned int,allocator<unsigned int> > > >::iterator>" , 99 , -1 };
10352 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleFitParams = { "TMVA::RuleFitParams" , 99 , -1 };
10353 G__linked_taginfo G__G__TMVA4LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR = { "vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >" , 99 , -1 };
10354 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >::iterator>" , 99 , -1 };
10355 G__linked_taginfo G__G__TMVA4LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR = { "vector<TH2F*,allocator<TH2F*> >" , 99 , -1 };
10356 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETH2FmUcOallocatorlETH2FmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TH2F*,allocator<TH2F*> >::iterator>" , 99 , -1 };
10357 G__linked_taginfo G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR = { "vector<const TMVA::Event*,allocator<const TMVA::Event*> >" , 99 , -1 };
10358 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::Event*,allocator<const TMVA::Event*> >::iterator>" , 99 , -1 };
10359 G__linked_taginfo G__G__TMVA4LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR = { "map<TMVA::EMsgType,string,less<TMVA::EMsgType>,allocator<pair<const TMVA::EMsgType,string> > >" , 99 , -1 };
10360 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleFitAPI = { "TMVA::RuleFitAPI" , 99 , -1 };
10361 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFMode = { "TMVA::RuleFitAPI::ERFMode" , 101 , -1 };
10362 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLEModel = { "TMVA::RuleFitAPI::EModel" , 101 , -1 };
10363 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFProgram = { "TMVA::RuleFitAPI::ERFProgram" , 101 , -1 };
10364 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLIntParms = { "TMVA::RuleFitAPI::IntParms" , 115 , -1 };
10365 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLRealParms = { "TMVA::RuleFitAPI::RealParms" , 115 , -1 };
10366 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLMethodBoost = { "TMVA::MethodBoost" , 99 , -1 };
10367 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLIMethod = { "TMVA::IMethod" , 99 , -1 };
10368 G__linked_taginfo G__G__TMVA4LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
10369 G__linked_taginfo G__G__TMVA4LN_TMatrixTlEdoublegR = { "TMatrixT<double>" , 99 , -1 };
10370 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLVariableTransformBase = { "TMVA::VariableTransformBase" , 99 , -1 };
10371 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLDataSetInfo = { "TMVA::DataSetInfo" , 99 , -1 };
10372 G__linked_taginfo G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR = { "vector<TMVA::VariableInfo,allocator<TMVA::VariableInfo> >" , 99 , -1 };
10373 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::VariableInfo,allocator<TMVA::VariableInfo> >::iterator>" , 99 , -1 };
10374 G__linked_taginfo G__G__TMVA4LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR = { "vector<TMVA::ClassInfo*,allocator<TMVA::ClassInfo*> >" , 99 , -1 };
10375 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::ClassInfo*,allocator<TMVA::ClassInfo*> >::iterator>" , 99 , -1 };
10376 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform = { "TMVA::VariableIdentityTransform" , 99 , -1 };
10377 G__linked_taginfo G__G__TMVA4LN_TMatrixTSymlEdoublegR = { "TMatrixTSym<double>" , 99 , -1 };
10378 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform = { "TMVA::VariableDecorrTransform" , 99 , -1 };
10379 G__linked_taginfo G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR = { "vector<TMatrixT<double>*,allocator<TMatrixT<double>*> >" , 99 , -1 };
10380 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMatrixT<double>*,allocator<TMatrixT<double>*> >::iterator>" , 99 , -1 };
10381 G__linked_taginfo G__G__TMVA4LN_TElementActionTlEdoublegR = { "TElementActionT<double>" , 99 , -1 };
10382 G__linked_taginfo G__G__TMVA4LN_TElementPosActionTlEdoublegR = { "TElementPosActionT<double>" , 99 , -1 };
10383 G__linked_taginfo G__G__TMVA4LN_TMatrixTSparselEdoublegR = { "TMatrixTSparse<double>" , 99 , -1 };
10384 G__linked_taginfo G__G__TMVA4LN_TMatrixTRow_constlEdoublegR = { "TMatrixTRow_const<double>" , 99 , -1 };
10385 G__linked_taginfo G__G__TMVA4LN_TMatrixTRowlEdoublegR = { "TMatrixTRow<double>" , 99 , -1 };
10386 G__linked_taginfo G__G__TMVA4LN_TMatrixTDiag_constlEdoublegR = { "TMatrixTDiag_const<double>" , 99 , -1 };
10387 G__linked_taginfo G__G__TMVA4LN_TMatrixTColumn_constlEdoublegR = { "TMatrixTColumn_const<double>" , 99 , -1 };
10388 G__linked_taginfo G__G__TMVA4LN_TMatrixTSparseRow_constlEdoublegR = { "TMatrixTSparseRow_const<double>" , 99 , -1 };
10389 G__linked_taginfo G__G__TMVA4LN_TMatrixTSparseRowlEdoublegR = { "TMatrixTSparseRow<double>" , 99 , -1 };
10390 G__linked_taginfo G__G__TMVA4LN_TMatrixTSparseDiag_constlEdoublegR = { "TMatrixTSparseDiag_const<double>" , 99 , -1 };
10391 G__linked_taginfo G__G__TMVA4LN_TMatrixTFlat_constlEdoublegR = { "TMatrixTFlat_const<double>" , 99 , -1 };
10392 G__linked_taginfo G__G__TMVA4LN_TMatrixTSub_constlEdoublegR = { "TMatrixTSub_const<double>" , 99 , -1 };
10393 G__linked_taginfo G__G__TMVA4LN_TMatrixTColumnlEdoublegR = { "TMatrixTColumn<double>" , 99 , -1 };
10394 G__linked_taginfo G__G__TMVA4LN_TMatrixTDiaglEdoublegR = { "TMatrixTDiag<double>" , 99 , -1 };
10395 G__linked_taginfo G__G__TMVA4LN_TMatrixTFlatlEdoublegR = { "TMatrixTFlat<double>" , 99 , -1 };
10396 G__linked_taginfo G__G__TMVA4LN_TMatrixTSublEdoublegR = { "TMatrixTSub<double>" , 99 , -1 };
10397 G__linked_taginfo G__G__TMVA4LN_TMatrixTSparseDiaglEdoublegR = { "TMatrixTSparseDiag<double>" , 99 , -1 };
10398 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLVariablePCATransform = { "TMVA::VariablePCATransform" , 99 , -1 };
10399 G__linked_taginfo G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR = { "vector<TVectorT<double>*,allocator<TVectorT<double>*> >" , 99 , -1 };
10400 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVectorT<double>*,allocator<TVectorT<double>*> >::iterator>" , 99 , -1 };
10401 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLOptionlEboolgR = { "TMVA::Option<bool>" , 99 , -1 };
10402 G__linked_taginfo G__G__TMVA4LN_vectorlEboolcOallocatorlEboolgRsPgR = { "vector<bool,allocator<bool> >" , 99 , -1 };
10403 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<bool,allocator<bool> >::iterator>" , 99 , -1 };
10404 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLOptionlEboolmUgR = { "TMVA::Option<bool*>" , 99 , -1 };
10405 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLOptionlEfloatgR = { "TMVA::Option<float>" , 99 , -1 };
10406 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLPDF = { "TMVA::PDF" , 99 , -1 };
10407 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLVariableGaussTransform = { "TMVA::VariableGaussTransform" , 99 , -1 };
10408 G__linked_taginfo G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR = { "vector<vector<TH1F*,allocator<TH1F*> >,allocator<vector<TH1F*,allocator<TH1F*> > > >" , 99 , -1 };
10409 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<TH1F*,allocator<TH1F*> >,allocator<vector<TH1F*,allocator<TH1F*> > > >::iterator>" , 99 , -1 };
10410 G__linked_taginfo G__G__TMVA4LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR = { "vector<TMVA::PDF*,allocator<TMVA::PDF*> >" , 99 , -1 };
10411 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::PDF*,allocator<TMVA::PDF*> >::iterator>" , 99 , -1 };
10412 G__linked_taginfo G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR = { "vector<vector<TMVA::PDF*,allocator<TMVA::PDF*> >,allocator<vector<TMVA::PDF*,allocator<TMVA::PDF*> > > >" , 99 , -1 };
10413 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<TMVA::PDF*,allocator<TMVA::PDF*> >,allocator<vector<TMVA::PDF*,allocator<TMVA::PDF*> > > >::iterator>" , 99 , -1 };
10414 G__linked_taginfo G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform = { "TMVA::VariableNormalizeTransform" , 99 , -1 };
10415 G__linked_taginfo G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR = { "vector<vector<float,allocator<float> >,allocator<vector<float,allocator<float> > > >" , 99 , -1 };
10416 G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<float,allocator<float> >,allocator<vector<float,allocator<float> > > >::iterator>" , 99 , -1 };
10417
10418
10419 extern "C" void G__cpp_reset_tagtableG__TMVA4() {
10420 G__G__TMVA4LN_TClass.tagnum = -1 ;
10421 G__G__TMVA4LN_TBuffer.tagnum = -1 ;
10422 G__G__TMVA4LN_TMemberInspector.tagnum = -1 ;
10423 G__G__TMVA4LN_TObject.tagnum = -1 ;
10424 G__G__TMVA4LN_TString.tagnum = -1 ;
10425 G__G__TMVA4LN_ios_base.tagnum = -1 ;
10426 G__G__TMVA4LN_basic_istreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
10427 G__G__TMVA4LN_basic_ioslEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
10428 G__G__TMVA4LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
10429 G__G__TMVA4LN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
10430 G__G__TMVA4LN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
10431 G__G__TMVA4LN_string.tagnum = -1 ;
10432 G__G__TMVA4LN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR.tagnum = -1 ;
10433 G__G__TMVA4LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
10434 G__G__TMVA4LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
10435 G__G__TMVA4LN_TObjArray.tagnum = -1 ;
10436 G__G__TMVA4LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
10437 G__G__TMVA4LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
10438 G__G__TMVA4LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
10439 G__G__TMVA4LN_TFormula.tagnum = -1 ;
10440 G__G__TMVA4LN_TMVA.tagnum = -1 ;
10441 G__G__TMVA4LN_TMVAcLcLTNeuron.tagnum = -1 ;
10442 G__G__TMVA4LN_TMVAcLcLMsgLogger.tagnum = -1 ;
10443 G__G__TMVA4LN_TMVAcLcLTSynapse.tagnum = -1 ;
10444 G__G__TMVA4LN_TMVAcLcLTActivation.tagnum = -1 ;
10445 G__G__TMVA4LN_TMVAcLcLEMsgType.tagnum = -1 ;
10446 G__G__TMVA4LN_TMVAcLcLTypes.tagnum = -1 ;
10447 G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA.tagnum = -1 ;
10448 G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform.tagnum = -1 ;
10449 G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType.tagnum = -1 ;
10450 G__G__TMVA4LN_TMVAcLcLTypescLcLESBType.tagnum = -1 ;
10451 G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType.tagnum = -1 ;
10452 G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage.tagnum = -1 ;
10453 G__G__TMVA4LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR.tagnum = -1 ;
10454 G__G__TMVA4LN_TMVAcLcLTNeuronInput.tagnum = -1 ;
10455 G__G__TMVA4LN_TMVAcLcLTActivationChooser.tagnum = -1 ;
10456 G__G__TMVA4LN_TMVAcLcLTActivationChoosercLcLEActivationType.tagnum = -1 ;
10457 G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
10458 G__G__TMVA4LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
10459 G__G__TMVA4LN_TMVAcLcLTActivationSigmoid.tagnum = -1 ;
10460 G__G__TMVA4LN_TMVAcLcLTActivationIdentity.tagnum = -1 ;
10461 G__G__TMVA4LN_TMVAcLcLTActivationTanh.tagnum = -1 ;
10462 G__G__TMVA4LN_TMVAcLcLTActivationRadial.tagnum = -1 ;
10463 G__G__TMVA4LN_TMVAcLcLTNeuronInputSum.tagnum = -1 ;
10464 G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum.tagnum = -1 ;
10465 G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs.tagnum = -1 ;
10466 G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser.tagnum = -1 ;
10467 G__G__TMVA4LN_TMVAcLcLTNeuronInputChoosercLcLENeuronInputType.tagnum = -1 ;
10468 G__G__TMVA4LN_TMVAcLcLRank.tagnum = -1 ;
10469 G__G__TMVA4LN_TMVAcLcLRanking.tagnum = -1 ;
10470 G__G__TMVA4LN_vectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgR.tagnum = -1 ;
10471 G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgRcLcLiteratorgR.tagnum = -1 ;
10472 G__G__TMVA4LN_TVectorTlEfloatgR.tagnum = -1 ;
10473 G__G__TMVA4LN_TVectorTlEdoublegR.tagnum = -1 ;
10474 G__G__TMVA4LN_TH1.tagnum = -1 ;
10475 G__G__TMVA4LN_TMatrixTBaselEfloatgR.tagnum = -1 ;
10476 G__G__TMVA4LN_TMatrixTBaselEdoublegR.tagnum = -1 ;
10477 G__G__TMVA4LN_TH2F.tagnum = -1 ;
10478 G__G__TMVA4LN_TMVAcLcLNode.tagnum = -1 ;
10479 G__G__TMVA4LN_TMVAcLcLEvent.tagnum = -1 ;
10480 G__G__TMVA4LN_TMVAcLcLBinaryTree.tagnum = -1 ;
10481 G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR.tagnum = -1 ;
10482 G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR.tagnum = -1 ;
10483 G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
10484 G__G__TMVA4LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR.tagnum = -1 ;
10485 G__G__TMVA4LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR.tagnum = -1 ;
10486 G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
10487 G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR.tagnum = -1 ;
10488 G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
10489 G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
10490 G__G__TMVA4LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
10491 G__G__TMVA4LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR.tagnum = -1 ;
10492 G__G__TMVA4LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR.tagnum = -1 ;
10493 G__G__TMVA4LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
10494 G__G__TMVA4LN_TMVAcLcLDecisionTree.tagnum = -1 ;
10495 G__G__TMVA4LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR.tagnum = -1 ;
10496 G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
10497 G__G__TMVA4LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
10498 G__G__TMVA4LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
10499 G__G__TMVA4LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR.tagnum = -1 ;
10500 G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
10501 G__G__TMVA4LN_vectorlEcharcOallocatorlEchargRsPgR.tagnum = -1 ;
10502 G__G__TMVA4LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR.tagnum = -1 ;
10503 G__G__TMVA4LN_TMVAcLcLRuleEnsemble.tagnum = -1 ;
10504 G__G__TMVA4LN_TMVAcLcLRule.tagnum = -1 ;
10505 G__G__TMVA4LN_TMVAcLcLMethodBase.tagnum = -1 ;
10506 G__G__TMVA4LN_TMVAcLcLRuleFit.tagnum = -1 ;
10507 G__G__TMVA4LN_TMVAcLcLMethodRuleFit.tagnum = -1 ;
10508 G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR.tagnum = -1 ;
10509 G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
10510 G__G__TMVA4LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR.tagnum = -1 ;
10511 G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
10512 G__G__TMVA4LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR.tagnum = -1 ;
10513 G__G__TMVA4LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
10514 G__G__TMVA4LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR.tagnum = -1 ;
10515 G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
10516 G__G__TMVA4LN_TMVAcLcLRuleFitParams.tagnum = -1 ;
10517 G__G__TMVA4LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR.tagnum = -1 ;
10518 G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
10519 G__G__TMVA4LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR.tagnum = -1 ;
10520 G__G__TMVA4LN_reverse_iteratorlEvectorlETH2FmUcOallocatorlETH2FmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
10521 G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR.tagnum = -1 ;
10522 G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
10523 G__G__TMVA4LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR.tagnum = -1 ;
10524 G__G__TMVA4LN_TMVAcLcLRuleFitAPI.tagnum = -1 ;
10525 G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFMode.tagnum = -1 ;
10526 G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLEModel.tagnum = -1 ;
10527 G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFProgram.tagnum = -1 ;
10528 G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLIntParms.tagnum = -1 ;
10529 G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLRealParms.tagnum = -1 ;
10530 G__G__TMVA4LN_TMVAcLcLMethodBoost.tagnum = -1 ;
10531 G__G__TMVA4LN_TMVAcLcLIMethod.tagnum = -1 ;
10532 G__G__TMVA4LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
10533 G__G__TMVA4LN_TMatrixTlEdoublegR.tagnum = -1 ;
10534 G__G__TMVA4LN_TMVAcLcLVariableTransformBase.tagnum = -1 ;
10535 G__G__TMVA4LN_TMVAcLcLDataSetInfo.tagnum = -1 ;
10536 G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR.tagnum = -1 ;
10537 G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR.tagnum = -1 ;
10538 G__G__TMVA4LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR.tagnum = -1 ;
10539 G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR.tagnum = -1 ;
10540 G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform.tagnum = -1 ;
10541 G__G__TMVA4LN_TMatrixTSymlEdoublegR.tagnum = -1 ;
10542 G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform.tagnum = -1 ;
10543 G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR.tagnum = -1 ;
10544 G__G__TMVA4LN_reverse_iteratorlEvectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
10545 G__G__TMVA4LN_TElementActionTlEdoublegR.tagnum = -1 ;
10546 G__G__TMVA4LN_TElementPosActionTlEdoublegR.tagnum = -1 ;
10547 G__G__TMVA4LN_TMatrixTSparselEdoublegR.tagnum = -1 ;
10548 G__G__TMVA4LN_TMatrixTRow_constlEdoublegR.tagnum = -1 ;
10549 G__G__TMVA4LN_TMatrixTRowlEdoublegR.tagnum = -1 ;
10550 G__G__TMVA4LN_TMatrixTDiag_constlEdoublegR.tagnum = -1 ;
10551 G__G__TMVA4LN_TMatrixTColumn_constlEdoublegR.tagnum = -1 ;
10552 G__G__TMVA4LN_TMatrixTSparseRow_constlEdoublegR.tagnum = -1 ;
10553 G__G__TMVA4LN_TMatrixTSparseRowlEdoublegR.tagnum = -1 ;
10554 G__G__TMVA4LN_TMatrixTSparseDiag_constlEdoublegR.tagnum = -1 ;
10555 G__G__TMVA4LN_TMatrixTFlat_constlEdoublegR.tagnum = -1 ;
10556 G__G__TMVA4LN_TMatrixTSub_constlEdoublegR.tagnum = -1 ;
10557 G__G__TMVA4LN_TMatrixTColumnlEdoublegR.tagnum = -1 ;
10558 G__G__TMVA4LN_TMatrixTDiaglEdoublegR.tagnum = -1 ;
10559 G__G__TMVA4LN_TMatrixTFlatlEdoublegR.tagnum = -1 ;
10560 G__G__TMVA4LN_TMatrixTSublEdoublegR.tagnum = -1 ;
10561 G__G__TMVA4LN_TMatrixTSparseDiaglEdoublegR.tagnum = -1 ;
10562 G__G__TMVA4LN_TMVAcLcLVariablePCATransform.tagnum = -1 ;
10563 G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR.tagnum = -1 ;
10564 G__G__TMVA4LN_reverse_iteratorlEvectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
10565 G__G__TMVA4LN_TMVAcLcLOptionlEboolgR.tagnum = -1 ;
10566 G__G__TMVA4LN_vectorlEboolcOallocatorlEboolgRsPgR.tagnum = -1 ;
10567 G__G__TMVA4LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR.tagnum = -1 ;
10568 G__G__TMVA4LN_TMVAcLcLOptionlEboolmUgR.tagnum = -1 ;
10569 G__G__TMVA4LN_TMVAcLcLOptionlEfloatgR.tagnum = -1 ;
10570 G__G__TMVA4LN_TMVAcLcLPDF.tagnum = -1 ;
10571 G__G__TMVA4LN_TMVAcLcLVariableGaussTransform.tagnum = -1 ;
10572 G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR.tagnum = -1 ;
10573 G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
10574 G__G__TMVA4LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR.tagnum = -1 ;
10575 G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
10576 G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR.tagnum = -1 ;
10577 G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
10578 G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform.tagnum = -1 ;
10579 G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR.tagnum = -1 ;
10580 G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
10581 }
10582
10583
10584 extern "C" void G__cpp_setup_tagtableG__TMVA4() {
10585
10586
10587 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TClass);
10588 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TBuffer);
10589 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMemberInspector);
10590 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TObject);
10591 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TString);
10592 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_ios_base);
10593 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_basic_istreamlEcharcOchar_traitslEchargRsPgR);
10594 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_basic_ioslEcharcOchar_traitslEchargRsPgR);
10595 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
10596 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR);
10597 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR);
10598 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_string);
10599 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR);
10600 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
10601 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
10602 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TObjArray);
10603 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
10604 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
10605 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
10606 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TFormula);
10607 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVA),0,-1,0,(char*)NULL,G__setup_memvarTMVA,G__setup_memfuncTMVA);
10608 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTNeuron),sizeof(TMVA::TNeuron),-1,292096,"Neuron class used by MethodANNBase derivative ANNs",G__setup_memvarTMVAcLcLTNeuron,G__setup_memfuncTMVAcLcLTNeuron);
10609 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLMsgLogger),sizeof(TMVA::MsgLogger),-1,327424,"Ostringstream derivative to redirect and format logging output",G__setup_memvarTMVAcLcLMsgLogger,G__setup_memfuncTMVAcLcLMsgLogger);
10610 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTSynapse),sizeof(TMVA::TSynapse),-1,292096,"Synapse class used by MethodANNBase and derivatives",G__setup_memvarTMVAcLcLTSynapse,G__setup_memfuncTMVAcLcLTSynapse);
10611 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTActivation),sizeof(TMVA::TActivation),-1,263430,"Interface for TNeuron activation function classes",G__setup_memvarTMVAcLcLTActivation,G__setup_memfuncTMVAcLcLTActivation);
10612 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLEMsgType);
10613 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTypes),sizeof(TMVA::Types),-1,263424,(char*)NULL,G__setup_memvarTMVAcLcLTypes,G__setup_memfuncTMVAcLcLTypes);
10614 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA);
10615 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform);
10616 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType);
10617 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTypescLcLESBType);
10618 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType);
10619 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage);
10620 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR);
10621 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTNeuronInput),sizeof(TMVA::TNeuronInput),-1,263426,"Interface for TNeuron input calculation classes",G__setup_memvarTMVAcLcLTNeuronInput,G__setup_memfuncTMVAcLcLTNeuronInput);
10622 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTActivationChooser),sizeof(TMVA::TActivationChooser),-1,263424,"Class for choosing activation functions",G__setup_memvarTMVAcLcLTActivationChooser,G__setup_memfuncTMVAcLcLTActivationChooser);
10623 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTActivationChoosercLcLEActivationType);
10624 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR);
10625 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
10626 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid),sizeof(TMVA::TActivationSigmoid),-1,263424,"Sigmoid activation function for TNeuron",G__setup_memvarTMVAcLcLTActivationSigmoid,G__setup_memfuncTMVAcLcLTActivationSigmoid);
10627 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity),sizeof(TMVA::TActivationIdentity),-1,263424,"Identity activation function for TNeuron",G__setup_memvarTMVAcLcLTActivationIdentity,G__setup_memfuncTMVAcLcLTActivationIdentity);
10628 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTActivationTanh),sizeof(TMVA::TActivationTanh),-1,263424,"Tanh sigmoid activation function for TNeuron",G__setup_memvarTMVAcLcLTActivationTanh,G__setup_memfuncTMVAcLcLTActivationTanh);
10629 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTActivationRadial),sizeof(TMVA::TActivationRadial),-1,263424,"Radial basis activation function for TNeuron",G__setup_memvarTMVAcLcLTActivationRadial,G__setup_memfuncTMVAcLcLTActivationRadial);
10630 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum),sizeof(TMVA::TNeuronInputSum),-1,263424,"Calculates weighted sum of neuron inputs",G__setup_memvarTMVAcLcLTNeuronInputSum,G__setup_memfuncTMVAcLcLTNeuronInputSum);
10631 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum),sizeof(TMVA::TNeuronInputSqSum),-1,263424,"Calculates square of weighted sum of neuron inputs",G__setup_memvarTMVAcLcLTNeuronInputSqSum,G__setup_memfuncTMVAcLcLTNeuronInputSqSum);
10632 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs),sizeof(TMVA::TNeuronInputAbs),-1,263424,"Calculates the sum of the absolute values of the weighted inputs",G__setup_memvarTMVAcLcLTNeuronInputAbs,G__setup_memfuncTMVAcLcLTNeuronInputAbs);
10633 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser),sizeof(TMVA::TNeuronInputChooser),-1,263424,"Class for choosing neuron input functions ",G__setup_memvarTMVAcLcLTNeuronInputChooser,G__setup_memfuncTMVAcLcLTNeuronInputChooser);
10634 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChoosercLcLENeuronInputType);
10635 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRank);
10636 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRanking),sizeof(TMVA::Ranking),-1,296192,"Method-specific ranking for input variables ",G__setup_memvarTMVAcLcLRanking,G__setup_memfuncTMVAcLcLRanking);
10637 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgR);
10638 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgRcLcLiteratorgR);
10639 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TVectorTlEfloatgR);
10640 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TVectorTlEdoublegR);
10641 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TH1);
10642 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTBaselEfloatgR);
10643 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTBaselEdoublegR);
10644 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TH2F);
10645 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLNode);
10646 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLEvent);
10647 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLBinaryTree);
10648 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR);
10649 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR);
10650 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR);
10651 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR);
10652 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR);
10653 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR);
10654 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR);
10655 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR);
10656 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR);
10657 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
10658 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR);
10659 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR);
10660 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR);
10661 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLDecisionTree);
10662 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR);
10663 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR);
10664 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
10665 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
10666 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR);
10667 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgRcLcLiteratorgR);
10668 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEcharcOallocatorlEchargRsPgR);
10669 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR);
10670 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleEnsemble);
10671 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRule);
10672 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLMethodBase);
10673 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFit),sizeof(TMVA::RuleFit),-1,296704,"Calculations for Friedman's RuleFit method",G__setup_memvarTMVAcLcLRuleFit,G__setup_memfuncTMVAcLcLRuleFit);
10674 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLMethodRuleFit);
10675 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR);
10676 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR);
10677 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR);
10678 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgRcLcLiteratorgR);
10679 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR);
10680 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR);
10681 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR);
10682 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgRcLcLiteratorgR);
10683 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFitParams);
10684 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR);
10685 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR);
10686 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR);
10687 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETH2FmUcOallocatorlETH2FmUgRsPgRcLcLiteratorgR);
10688 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR);
10689 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR);
10690 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR);
10691 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFitAPI),sizeof(TMVA::RuleFitAPI),-1,296192,"Friedman's RuleFit method",G__setup_memvarTMVAcLcLRuleFitAPI,G__setup_memfuncTMVAcLcLRuleFitAPI);
10692 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFMode);
10693 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLEModel);
10694 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFProgram);
10695 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLIntParms);
10696 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLRealParms);
10697 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLMethodBoost);
10698 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLIMethod),sizeof(TMVA::IMethod),-1,263439,"Method Interface",G__setup_memvarTMVAcLcLIMethod,G__setup_memfuncTMVAcLcLIMethod);
10699 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
10700 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTlEdoublegR);
10701 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase),sizeof(TMVA::VariableTransformBase),-1,324617,"Base class for variable transformations",G__setup_memvarTMVAcLcLVariableTransformBase,G__setup_memfuncTMVAcLcLVariableTransformBase);
10702 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLDataSetInfo);
10703 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR);
10704 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR);
10705 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR);
10706 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR);
10707 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform),sizeof(TMVA::VariableIdentityTransform),-1,324608,"Variable transformation: identity",G__setup_memvarTMVAcLcLVariableIdentityTransform,G__setup_memfuncTMVAcLcLVariableIdentityTransform);
10708 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSymlEdoublegR);
10709 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform),sizeof(TMVA::VariableDecorrTransform),-1,324608,"Variable transformation: decorrelation",G__setup_memvarTMVAcLcLVariableDecorrTransform,G__setup_memfuncTMVAcLcLVariableDecorrTransform);
10710 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR);
10711 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgRcLcLiteratorgR);
10712 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TElementActionTlEdoublegR);
10713 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TElementPosActionTlEdoublegR);
10714 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSparselEdoublegR);
10715 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTRow_constlEdoublegR);
10716 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTRowlEdoublegR);
10717 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTDiag_constlEdoublegR);
10718 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTColumn_constlEdoublegR);
10719 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSparseRow_constlEdoublegR);
10720 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSparseRowlEdoublegR);
10721 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSparseDiag_constlEdoublegR);
10722 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTFlat_constlEdoublegR);
10723 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSub_constlEdoublegR);
10724 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTColumnlEdoublegR);
10725 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTDiaglEdoublegR);
10726 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTFlatlEdoublegR);
10727 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSublEdoublegR);
10728 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSparseDiaglEdoublegR);
10729 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform),sizeof(TMVA::VariablePCATransform),-1,324608,"Variable transformation: Principal Value Composition",G__setup_memvarTMVAcLcLVariablePCATransform,G__setup_memfuncTMVAcLcLVariablePCATransform);
10730 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR);
10731 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgRcLcLiteratorgR);
10732 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLOptionlEboolgR);
10733 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEboolcOallocatorlEboolgRsPgR);
10734 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR);
10735 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLOptionlEboolmUgR);
10736 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLOptionlEfloatgR);
10737 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLPDF);
10738 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform),sizeof(TMVA::VariableGaussTransform),-1,324608,"Variable transformation: Gauss transformation",G__setup_memvarTMVAcLcLVariableGaussTransform,G__setup_memfuncTMVAcLcLVariableGaussTransform);
10739 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR);
10740 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgRcLcLiteratorgR);
10741 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR);
10742 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcLcLiteratorgR);
10743 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR);
10744 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgRcLcLiteratorgR);
10745 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform),sizeof(TMVA::VariableNormalizeTransform),-1,324608,"Variable transformation: normalization",G__setup_memvarTMVAcLcLVariableNormalizeTransform,G__setup_memfuncTMVAcLcLVariableNormalizeTransform);
10746 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR);
10747 G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR);
10748 }
10749 extern "C" void G__cpp_setupG__TMVA4(void) {
10750 G__check_setup_version(30051515,"G__cpp_setupG__TMVA4()");
10751 G__set_cpp_environmentG__TMVA4();
10752 G__cpp_setup_tagtableG__TMVA4();
10753
10754 G__cpp_setup_inheritanceG__TMVA4();
10755
10756 G__cpp_setup_typetableG__TMVA4();
10757
10758 G__cpp_setup_memvarG__TMVA4();
10759
10760 G__cpp_setup_memfuncG__TMVA4();
10761 G__cpp_setup_globalG__TMVA4();
10762 G__cpp_setup_funcG__TMVA4();
10763
10764 if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__TMVA4();
10765 return;
10766 }
10767 class G__cpp_setup_initG__TMVA4 {
10768 public:
10769 G__cpp_setup_initG__TMVA4() { G__add_setup_func("G__TMVA4",(G__incsetup)(&G__cpp_setupG__TMVA4)); G__call_setup_funcs(); }
10770 ~G__cpp_setup_initG__TMVA4() { G__remove_setup_func("G__TMVA4"); }
10771 };
10772 G__cpp_setup_initG__TMVA4 G__cpp_setup_initializerG__TMVA4;
10773
