~ubuntu-branches/ubuntu/maverick/openturns/maverick
» Revision
7
: python/src/uncertainty_stattests_wrap.cpp
« back to all changes in this revision
Viewing changes to python/src/uncertainty_stattests_wrap.cpp
- browse files at revision 7
- compare with another revision
- download diff
- download tarball
- view history from revision 7
- Committer: Bazaar Package Importer
- Author(s): Fabrice Coutadeur
- Date: 2010-05-10 17:27:55 UTC
- mfrom: (1.1.4 upstream) (5.1.5 sid)
- Revision ID: james.westby@ubuntu.com-20100510172755-cb5ynskknqqi5rhp
Tags: 0.13.2-2ubuntu1
* Merge with Debian testing. No changes left.
* ubuntu_fix-python-2.6.patch: fix detection of python 2.6 libs, to not use
LOCALMODLIBS. This pulls a dependency on SSL and makes the package FTBFS.
* ubuntu_fix-python-2.6.patch: fix detection of python 2.6 libs, to not use
LOCALMODLIBS. This pulls a dependency on SSL and makes the package FTBFS.
- files added:
- debian/patches/fix_ftbfs_on_arm_and_mips.patch
- files removed:
- debian/openturns-examples.lintian-overrides
- lib/src/Uncertainty/Algorithm/Analytical/FORM
- lib/src/Uncertainty/Algorithm/Analytical/SORM
- lib/src/Uncertainty/Algorithm/Simulation/DirectionalSampling
- lib/src/Uncertainty/Algorithm/Simulation/ImportanceSampling
- lib/src/Uncertainty/Algorithm/Simulation/LHS
- lib/src/Uncertainty/Algorithm/Simulation/MonteCarlo
- lib/src/Uncertainty/Algorithm/Simulation/PostAnalyticalControlledImportanceSampling
- lib/src/Uncertainty/Algorithm/Simulation/PostAnalyticalImportanceSampling
- lib/src/Uncertainty/Algorithm/Simulation/QuasiMonteCarlo
- files modified:
- Makefile.am
- lib/src/Uncertainty/Algorithm/IsoProbabilisticTransformation/NatafEllipticalDistribution/Makefile.am
- lib/src/Uncertainty/Algorithm/IsoProbabilisticTransformation/NatafEllipticalDistribution/Makefile.in
- python/test/t_BetaFactory_std.py *
- python/test/t_ChiSquareFactory_std.py *
- python/test/t_ClaytonCopulaFactory_std.py *
- python/test/t_ConfidenceInterval_std.py *
- python/test/t_Distributions_draw.py *
- python/test/t_EnumerateFunction_std.py *
- python/test/t_ExponentialFactory_std.py *
- python/test/t_FrankCopulaFactory_std.py *
- python/test/t_GammaFactory_std.py *
- python/test/t_GeometricFactory_std.py *
- python/test/t_GumbelCopulaFactory_std.py *
- python/test/t_GumbelFactory_std.py *
- python/test/t_HypothesisTest_correlation.py *
- python/test/t_HypothesisTest_std.py *
- python/test/t_Indices_std.py *
- python/test/t_Interval_std.py *
- python/test/t_LaplaceFactory_std.py *
- python/test/t_LinearModelFactory_std.py *
- python/test/t_LinearModelTest_std.py *
- python/test/t_LogNormalFactory_std.py *
- python/test/t_LogisticFactory_std.py *
added
removed
python/src/uncertainty_stattests_wrap.cpp
1
/* ----------------------------------------------------------------------------
2
* This file was automatically generated by SWIG (http://www.swig.org).
3
* Version 1.3.36
4
*
5
* This file is not intended to be easily readable and contains a number of
6
* coding conventions designed to improve portability and efficiency. Do not make
7
* changes to this file unless you know what you are doing--modify the SWIG
8
* interface file instead.
9
* ----------------------------------------------------------------------------- */
10
11
#define SWIGPYTHON
12
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14
#ifdef __cplusplus
15
template<typename T> class SwigValueWrapper {
16
T *tt;
17
public:
18
SwigValueWrapper() : tt(0) { }
19
SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20
SwigValueWrapper(const T& t) : tt(new T(t)) { }
21
~SwigValueWrapper() { delete tt; }
22
SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23
operator T&() const { return *tt; }
24
T *operator&() { return tt; }
25
private:
26
SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27
};
28
29
template <typename T> T SwigValueInit() {
30
return T();
31
}
32
#endif
33
34
/* -----------------------------------------------------------------------------
35
* This section contains generic SWIG labels for method/variable
36
* declarations/attributes, and other compiler dependent labels.
37
* ----------------------------------------------------------------------------- */
38
39
/* template workaround for compilers that cannot correctly implement the C++ standard */
40
#ifndef SWIGTEMPLATEDISAMBIGUATOR
41
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
42
# define SWIGTEMPLATEDISAMBIGUATOR template
43
# elif defined(__HP_aCC)
44
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
45
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
46
# define SWIGTEMPLATEDISAMBIGUATOR template
47
# else
48
# define SWIGTEMPLATEDISAMBIGUATOR
49
# endif
50
#endif
51
52
/* inline attribute */
53
#ifndef SWIGINLINE
54
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
55
# define SWIGINLINE inline
56
# else
57
# define SWIGINLINE
58
# endif
59
#endif
60
61
/* attribute recognised by some compilers to avoid 'unused' warnings */
62
#ifndef SWIGUNUSED
63
# if defined(__GNUC__)
64
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
65
# define SWIGUNUSED __attribute__ ((__unused__))
66
# else
67
# define SWIGUNUSED
68
# endif
69
# elif defined(__ICC)
70
# define SWIGUNUSED __attribute__ ((__unused__))
71
# else
72
# define SWIGUNUSED
73
# endif
74
#endif
75
76
#ifndef SWIG_MSC_UNSUPPRESS_4505
77
# if defined(_MSC_VER)
78
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
79
# endif
80
#endif
81
82
#ifndef SWIGUNUSEDPARM
83
# ifdef __cplusplus
84
# define SWIGUNUSEDPARM(p)
85
# else
86
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
87
# endif
88
#endif
89
90
/* internal SWIG method */
91
#ifndef SWIGINTERN
92
# define SWIGINTERN static SWIGUNUSED
93
#endif
94
95
/* internal inline SWIG method */
96
#ifndef SWIGINTERNINLINE
97
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
98
#endif
99
100
/* exporting methods */
101
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
102
# ifndef GCC_HASCLASSVISIBILITY
103
# define GCC_HASCLASSVISIBILITY
104
# endif
105
#endif
106
107
#ifndef SWIGEXPORT
108
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
109
# if defined(STATIC_LINKED)
110
# define SWIGEXPORT
111
# else
112
# define SWIGEXPORT __declspec(dllexport)
113
# endif
114
# else
115
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
116
# define SWIGEXPORT __attribute__ ((visibility("default")))
117
# else
118
# define SWIGEXPORT
119
# endif
120
# endif
121
#endif
122
123
/* calling conventions for Windows */
124
#ifndef SWIGSTDCALL
125
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
126
# define SWIGSTDCALL __stdcall
127
# else
128
# define SWIGSTDCALL
129
# endif
130
#endif
131
132
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
133
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
134
# define _CRT_SECURE_NO_DEPRECATE
135
#endif
136
137
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
138
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
139
# define _SCL_SECURE_NO_DEPRECATE
140
#endif
141
142
143
144
/* Python.h has to appear first */
145
#include <Python.h>
146
147
/* -----------------------------------------------------------------------------
148
* swigrun.swg
149
*
150
* This file contains generic CAPI SWIG runtime support for pointer
151
* type checking.
152
* ----------------------------------------------------------------------------- */
153
154
/* This should only be incremented when either the layout of swig_type_info changes,
155
or for whatever reason, the runtime changes incompatibly */
156
#define SWIG_RUNTIME_VERSION "4"
157
158
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
159
#ifdef SWIG_TYPE_TABLE
160
# define SWIG_QUOTE_STRING(x) #x
161
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
162
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
163
#else
164
# define SWIG_TYPE_TABLE_NAME
165
#endif
166
167
/*
168
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
169
creating a static or dynamic library from the swig runtime code.
170
In 99.9% of the cases, swig just needs to declare them as 'static'.
171
172
But only do this if is strictly necessary, ie, if you have problems
173
with your compiler or so.
174
*/
175
176
#ifndef SWIGRUNTIME
177
# define SWIGRUNTIME SWIGINTERN
178
#endif
179
180
#ifndef SWIGRUNTIMEINLINE
181
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
182
#endif
183
184
/* Generic buffer size */
185
#ifndef SWIG_BUFFER_SIZE
186
# define SWIG_BUFFER_SIZE 1024
187
#endif
188
189
/* Flags for pointer conversions */
190
#define SWIG_POINTER_DISOWN 0x1
191
#define SWIG_CAST_NEW_MEMORY 0x2
192
193
/* Flags for new pointer objects */
194
#define SWIG_POINTER_OWN 0x1
195
196
197
/*
198
Flags/methods for returning states.
199
200
The swig conversion methods, as ConvertPtr, return and integer
201
that tells if the conversion was successful or not. And if not,
202
an error code can be returned (see swigerrors.swg for the codes).
203
204
Use the following macros/flags to set or process the returning
205
states.
206
207
In old swig versions, you usually write code as:
208
209
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
210
// success code
211
} else {
212
//fail code
213
}
214
215
Now you can be more explicit as:
216
217
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
218
if (SWIG_IsOK(res)) {
219
// success code
220
} else {
221
// fail code
222
}
223
224
that seems to be the same, but now you can also do
225
226
Type *ptr;
227
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
228
if (SWIG_IsOK(res)) {
229
// success code
230
if (SWIG_IsNewObj(res) {
231
...
232
delete *ptr;
233
} else {
234
...
235
}
236
} else {
237
// fail code
238
}
239
240
I.e., now SWIG_ConvertPtr can return new objects and you can
241
identify the case and take care of the deallocation. Of course that
242
requires also to SWIG_ConvertPtr to return new result values, as
243
244
int SWIG_ConvertPtr(obj, ptr,...) {
245
if (<obj is ok>) {
246
if (<need new object>) {
247
*ptr = <ptr to new allocated object>;
248
return SWIG_NEWOBJ;
249
} else {
250
*ptr = <ptr to old object>;
251
return SWIG_OLDOBJ;
252
}
253
} else {
254
return SWIG_BADOBJ;
255
}
256
}
257
258
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
259
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
260
swig errors code.
261
262
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
263
allows to return the 'cast rank', for example, if you have this
264
265
int food(double)
266
int fooi(int);
267
268
and you call
269
270
food(1) // cast rank '1' (1 -> 1.0)
271
fooi(1) // cast rank '0'
272
273
just use the SWIG_AddCast()/SWIG_CheckState()
274
275
276
*/
277
#define SWIG_OK (0)
278
#define SWIG_ERROR (-1)
279
#define SWIG_IsOK(r) (r >= 0)
280
#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
281
282
/* The CastRankLimit says how many bits are used for the cast rank */
283
#define SWIG_CASTRANKLIMIT (1 << 8)
284
/* The NewMask denotes the object was created (using new/malloc) */
285
#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
286
/* The TmpMask is for in/out typemaps that use temporal objects */
287
#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
288
/* Simple returning values */
289
#define SWIG_BADOBJ (SWIG_ERROR)
290
#define SWIG_OLDOBJ (SWIG_OK)
291
#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
292
#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
293
/* Check, add and del mask methods */
294
#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
295
#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
296
#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
297
#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
298
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
299
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
300
301
302
/* Cast-Rank Mode */
303
#if defined(SWIG_CASTRANK_MODE)
304
# ifndef SWIG_TypeRank
305
# define SWIG_TypeRank unsigned long
306
# endif
307
# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
308
# define SWIG_MAXCASTRANK (2)
309
# endif
310
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
311
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
312
SWIGINTERNINLINE int SWIG_AddCast(int r) {
313
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
314
}
315
SWIGINTERNINLINE int SWIG_CheckState(int r) {
316
return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
317
}
318
#else /* no cast-rank mode */
319
# define SWIG_AddCast
320
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
321
#endif
322
323
324
325
326
#include <string.h>
327
328
#ifdef __cplusplus
329
extern "C" {
330
#endif
331
332
typedef void *(*swig_converter_func)(void *, int *);
333
typedef struct swig_type_info *(*swig_dycast_func)(void **);
334
335
/* Structure to store information on one type */
336
typedef struct swig_type_info {
337
const char *name; /* mangled name of this type */
338
const char *str; /* human readable name of this type */
339
swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
340
struct swig_cast_info *cast; /* linked list of types that can cast into this type */
341
void *clientdata; /* language specific type data */
342
int owndata; /* flag if the structure owns the clientdata */
343
} swig_type_info;
344
345
/* Structure to store a type and conversion function used for casting */
346
typedef struct swig_cast_info {
347
swig_type_info *type; /* pointer to type that is equivalent to this type */
348
swig_converter_func converter; /* function to cast the void pointers */
349
struct swig_cast_info *next; /* pointer to next cast in linked list */
350
struct swig_cast_info *prev; /* pointer to the previous cast */
351
} swig_cast_info;
352
353
/* Structure used to store module information
354
* Each module generates one structure like this, and the runtime collects
355
* all of these structures and stores them in a circularly linked list.*/
356
typedef struct swig_module_info {
357
swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
358
size_t size; /* Number of types in this module */
359
struct swig_module_info *next; /* Pointer to next element in circularly linked list */
360
swig_type_info **type_initial; /* Array of initially generated type structures */
361
swig_cast_info **cast_initial; /* Array of initially generated casting structures */
362
void *clientdata; /* Language specific module data */
363
} swig_module_info;
364
365
/*
366
Compare two type names skipping the space characters, therefore
367
"char*" == "char *" and "Class<int>" == "Class<int >", etc.
368
369
Return 0 when the two name types are equivalent, as in
370
strncmp, but skipping ' '.
371
*/
372
SWIGRUNTIME int
373
SWIG_TypeNameComp(const char *f1, const char *l1,
374
const char *f2, const char *l2) {
375
for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
376
while ((*f1 == ' ') && (f1 != l1)) ++f1;
377
while ((*f2 == ' ') && (f2 != l2)) ++f2;
378
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
379
}
380
return (int)((l1 - f1) - (l2 - f2));
381
}
382
383
/*
384
Check type equivalence in a name list like <name1>|<name2>|...
385
Return 0 if not equal, 1 if equal
386
*/
387
SWIGRUNTIME int
388
SWIG_TypeEquiv(const char *nb, const char *tb) {
389
int equiv = 0;
390
const char* te = tb + strlen(tb);
391
const char* ne = nb;
392
while (!equiv && *ne) {
393
for (nb = ne; *ne; ++ne) {
394
if (*ne == '|') break;
395
}
396
equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
397
if (*ne) ++ne;
398
}
399
return equiv;
400
}
401
402
/*
403
Check type equivalence in a name list like <name1>|<name2>|...
404
Return 0 if equal, -1 if nb < tb, 1 if nb > tb
405
*/
406
SWIGRUNTIME int
407
SWIG_TypeCompare(const char *nb, const char *tb) {
408
int equiv = 0;
409
const char* te = tb + strlen(tb);
410
const char* ne = nb;
411
while (!equiv && *ne) {
412
for (nb = ne; *ne; ++ne) {
413
if (*ne == '|') break;
414
}
415
equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
416
if (*ne) ++ne;
417
}
418
return equiv;
419
}
420
421
422
/* think of this as a c++ template<> or a scheme macro */
423
#define SWIG_TypeCheck_Template(comparison, ty) \
424
if (ty) { \
425
swig_cast_info *iter = ty->cast; \
426
while (iter) { \
427
if (comparison) { \
428
if (iter == ty->cast) return iter; \
429
/* Move iter to the top of the linked list */ \
430
iter->prev->next = iter->next; \
431
if (iter->next) \
432
iter->next->prev = iter->prev; \
433
iter->next = ty->cast; \
434
iter->prev = 0; \
435
if (ty->cast) ty->cast->prev = iter; \
436
ty->cast = iter; \
437
return iter; \
438
} \
439
iter = iter->next; \
440
} \
441
} \
442
return 0
443
444
/*
445
Check the typename
446
*/
447
SWIGRUNTIME swig_cast_info *
448
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
449
SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
450
}
451
452
/* Same as previous function, except strcmp is replaced with a pointer comparison */
453
SWIGRUNTIME swig_cast_info *
454
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
455
SWIG_TypeCheck_Template(iter->type == from, into);
456
}
457
458
/*
459
Cast a pointer up an inheritance hierarchy
460
*/
461
SWIGRUNTIMEINLINE void *
462
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
463
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
464
}
465
466
/*
467
Dynamic pointer casting. Down an inheritance hierarchy
468
*/
469
SWIGRUNTIME swig_type_info *
470
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
471
swig_type_info *lastty = ty;
472
if (!ty || !ty->dcast) return ty;
473
while (ty && (ty->dcast)) {
474
ty = (*ty->dcast)(ptr);
475
if (ty) lastty = ty;
476
}
477
return lastty;
478
}
479
480
/*
481
Return the name associated with this type
482
*/
483
SWIGRUNTIMEINLINE const char *
484
SWIG_TypeName(const swig_type_info *ty) {
485
return ty->name;
486
}
487
488
/*
489
Return the pretty name associated with this type,
490
that is an unmangled type name in a form presentable to the user.
491
*/
492
SWIGRUNTIME const char *
493
SWIG_TypePrettyName(const swig_type_info *type) {
494
/* The "str" field contains the equivalent pretty names of the
495
type, separated by vertical-bar characters. We choose
496
to print the last name, as it is often (?) the most
497
specific. */
498
if (!type) return NULL;
499
if (type->str != NULL) {
500
const char *last_name = type->str;
501
const char *s;
502
for (s = type->str; *s; s++)
503
if (*s == '|') last_name = s+1;
504
return last_name;
505
}
506
else
507
return type->name;
508
}
509
510
/*
511
Set the clientdata field for a type
512
*/
513
SWIGRUNTIME void
514
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
515
swig_cast_info *cast = ti->cast;
516
/* if (ti->clientdata == clientdata) return; */
517
ti->clientdata = clientdata;
518
519
while (cast) {
520
if (!cast->converter) {
521
swig_type_info *tc = cast->type;
522
if (!tc->clientdata) {
523
SWIG_TypeClientData(tc, clientdata);
524
}
525
}
526
cast = cast->next;
527
}
528
}
529
SWIGRUNTIME void
530
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
531
SWIG_TypeClientData(ti, clientdata);
532
ti->owndata = 1;
533
}
534
535
/*
536
Search for a swig_type_info structure only by mangled name
537
Search is a O(log #types)
538
539
We start searching at module start, and finish searching when start == end.
540
Note: if start == end at the beginning of the function, we go all the way around
541
the circular list.
542
*/
543
SWIGRUNTIME swig_type_info *
544
SWIG_MangledTypeQueryModule(swig_module_info *start,
545
swig_module_info *end,
546
const char *name) {
547
swig_module_info *iter = start;
548
do {
549
if (iter->size) {
550
register size_t l = 0;
551
register size_t r = iter->size - 1;
552
do {
553
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
554
register size_t i = (l + r) >> 1;
555
const char *iname = iter->types[i]->name;
556
if (iname) {
557
register int compare = strcmp(name, iname);
558
if (compare == 0) {
559
return iter->types[i];
560
} else if (compare < 0) {
561
if (i) {
562
r = i - 1;
563
} else {
564
break;
565
}
566
} else if (compare > 0) {
567
l = i + 1;
568
}
569
} else {
570
break; /* should never happen */
571
}
572
} while (l <= r);
573
}
574
iter = iter->next;
575
} while (iter != end);
576
return 0;
577
}
578
579
/*
580
Search for a swig_type_info structure for either a mangled name or a human readable name.
581
It first searches the mangled names of the types, which is a O(log #types)
582
If a type is not found it then searches the human readable names, which is O(#types).
583
584
We start searching at module start, and finish searching when start == end.
585
Note: if start == end at the beginning of the function, we go all the way around
586
the circular list.
587
*/
588
SWIGRUNTIME swig_type_info *
589
SWIG_TypeQueryModule(swig_module_info *start,
590
swig_module_info *end,
591
const char *name) {
592
/* STEP 1: Search the name field using binary search */
593
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
594
if (ret) {
595
return ret;
596
} else {
597
/* STEP 2: If the type hasn't been found, do a complete search
598
of the str field (the human readable name) */
599
swig_module_info *iter = start;
600
do {
601
register size_t i = 0;
602
for (; i < iter->size; ++i) {
603
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
604
return iter->types[i];
605
}
606
iter = iter->next;
607
} while (iter != end);
608
}
609
610
/* neither found a match */
611
return 0;
612
}
613
614
/*
615
Pack binary data into a string
616
*/
617
SWIGRUNTIME char *
618
SWIG_PackData(char *c, void *ptr, size_t sz) {
619
static const char hex[17] = "0123456789abcdef";
620
register const unsigned char *u = (unsigned char *) ptr;
621
register const unsigned char *eu = u + sz;
622
for (; u != eu; ++u) {
623
register unsigned char uu = *u;
624
*(c++) = hex[(uu & 0xf0) >> 4];
625
*(c++) = hex[uu & 0xf];
626
}
627
return c;
628
}
629
630
/*
631
Unpack binary data from a string
632
*/
633
SWIGRUNTIME const char *
634
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
635
register unsigned char *u = (unsigned char *) ptr;
636
register const unsigned char *eu = u + sz;
637
for (; u != eu; ++u) {
638
register char d = *(c++);
639
register unsigned char uu;
640
if ((d >= '0') && (d <= '9'))
641
uu = ((d - '0') << 4);
642
else if ((d >= 'a') && (d <= 'f'))
643
uu = ((d - ('a'-10)) << 4);
644
else
645
return (char *) 0;
646
d = *(c++);
647
if ((d >= '0') && (d <= '9'))
648
uu |= (d - '0');
649
else if ((d >= 'a') && (d <= 'f'))
650
uu |= (d - ('a'-10));
651
else
652
return (char *) 0;
653
*u = uu;
654
}
655
return c;
656
}
657
658
/*
659
Pack 'void *' into a string buffer.
660
*/
661
SWIGRUNTIME char *
662
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
663
char *r = buff;
664
if ((2*sizeof(void *) + 2) > bsz) return 0;
665
*(r++) = '_';
666
r = SWIG_PackData(r,&ptr,sizeof(void *));
667
if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
668
strcpy(r,name);
669
return buff;
670
}
671
672
SWIGRUNTIME const char *
673
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
674
if (*c != '_') {
675
if (strcmp(c,"NULL") == 0) {
676
*ptr = (void *) 0;
677
return name;
678
} else {
679
return 0;
680
}
681
}
682
return SWIG_UnpackData(++c,ptr,sizeof(void *));
683
}
684
685
SWIGRUNTIME char *
686
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
687
char *r = buff;
688
size_t lname = (name ? strlen(name) : 0);
689
if ((2*sz + 2 + lname) > bsz) return 0;
690
*(r++) = '_';
691
r = SWIG_PackData(r,ptr,sz);
692
if (lname) {
693
strncpy(r,name,lname+1);
694
} else {
695
*r = 0;
696
}
697
return buff;
698
}
699
700
SWIGRUNTIME const char *
701
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
702
if (*c != '_') {
703
if (strcmp(c,"NULL") == 0) {
704
memset(ptr,0,sz);
705
return name;
706
} else {
707
return 0;
708
}
709
}
710
return SWIG_UnpackData(++c,ptr,sz);
711
}
712
713
#ifdef __cplusplus
714
}
715
#endif
716
717
/* Errors in SWIG */
718
#define SWIG_UnknownError -1
719
#define SWIG_IOError -2
720
#define SWIG_RuntimeError -3
721
#define SWIG_IndexError -4
722
#define SWIG_TypeError -5
723
#define SWIG_DivisionByZero -6
724
#define SWIG_OverflowError -7
725
#define SWIG_SyntaxError -8
726
#define SWIG_ValueError -9
727
#define SWIG_SystemError -10
728
#define SWIG_AttributeError -11
729
#define SWIG_MemoryError -12
730
#define SWIG_NullReferenceError -13
731
732
733
734
735
/* Add PyOS_snprintf for old Pythons */
736
#if PY_VERSION_HEX < 0x02020000
737
# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
738
# define PyOS_snprintf _snprintf
739
# else
740
# define PyOS_snprintf snprintf
741
# endif
742
#endif
743
744
/* A crude PyString_FromFormat implementation for old Pythons */
745
#if PY_VERSION_HEX < 0x02020000
746
747
#ifndef SWIG_PYBUFFER_SIZE
748
# define SWIG_PYBUFFER_SIZE 1024
749
#endif
750
751
static PyObject *
752
PyString_FromFormat(const char *fmt, ...) {
753
va_list ap;
754
char buf[SWIG_PYBUFFER_SIZE * 2];
755
int res;
756
va_start(ap, fmt);
757
res = vsnprintf(buf, sizeof(buf), fmt, ap);
758
va_end(ap);
759
return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
760
}
761
#endif
762
763
/* Add PyObject_Del for old Pythons */
764
#if PY_VERSION_HEX < 0x01060000
765
# define PyObject_Del(op) PyMem_DEL((op))
766
#endif
767
#ifndef PyObject_DEL
768
# define PyObject_DEL PyObject_Del
769
#endif
770
771
/* A crude PyExc_StopIteration exception for old Pythons */
772
#if PY_VERSION_HEX < 0x02020000
773
# ifndef PyExc_StopIteration
774
# define PyExc_StopIteration PyExc_RuntimeError
775
# endif
776
# ifndef PyObject_GenericGetAttr
777
# define PyObject_GenericGetAttr 0
778
# endif
779
#endif
780
/* Py_NotImplemented is defined in 2.1 and up. */
781
#if PY_VERSION_HEX < 0x02010000
782
# ifndef Py_NotImplemented
783
# define Py_NotImplemented PyExc_RuntimeError
784
# endif
785
#endif
786
787
788
/* A crude PyString_AsStringAndSize implementation for old Pythons */
789
#if PY_VERSION_HEX < 0x02010000
790
# ifndef PyString_AsStringAndSize
791
# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
792
# endif
793
#endif
794
795
/* PySequence_Size for old Pythons */
796
#if PY_VERSION_HEX < 0x02000000
797
# ifndef PySequence_Size
798
# define PySequence_Size PySequence_Length
799
# endif
800
#endif
801
802
803
/* PyBool_FromLong for old Pythons */
804
#if PY_VERSION_HEX < 0x02030000
805
static
806
PyObject *PyBool_FromLong(long ok)
807
{
808
PyObject *result = ok ? Py_True : Py_False;
809
Py_INCREF(result);
810
return result;
811
}
812
#endif
813
814
/* Py_ssize_t for old Pythons */
815
/* This code is as recommended by: */
816
/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
817
#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
818
typedef int Py_ssize_t;
819
# define PY_SSIZE_T_MAX INT_MAX
820
# define PY_SSIZE_T_MIN INT_MIN
821
#endif
822
823
/* -----------------------------------------------------------------------------
824
* error manipulation
825
* ----------------------------------------------------------------------------- */
826
827
SWIGRUNTIME PyObject*
828
SWIG_Python_ErrorType(int code) {
829
PyObject* type = 0;
830
switch(code) {
831
case SWIG_MemoryError:
832
type = PyExc_MemoryError;
833
break;
834
case SWIG_IOError:
835
type = PyExc_IOError;
836
break;
837
case SWIG_RuntimeError:
838
type = PyExc_RuntimeError;
839
break;
840
case SWIG_IndexError:
841
type = PyExc_IndexError;
842
break;
843
case SWIG_TypeError:
844
type = PyExc_TypeError;
845
break;
846
case SWIG_DivisionByZero:
847
type = PyExc_ZeroDivisionError;
848
break;
849
case SWIG_OverflowError:
850
type = PyExc_OverflowError;
851
break;
852
case SWIG_SyntaxError:
853
type = PyExc_SyntaxError;
854
break;
855
case SWIG_ValueError:
856
type = PyExc_ValueError;
857
break;
858
case SWIG_SystemError:
859
type = PyExc_SystemError;
860
break;
861
case SWIG_AttributeError:
862
type = PyExc_AttributeError;
863
break;
864
default:
865
type = PyExc_RuntimeError;
866
}
867
return type;
868
}
869
870
871
SWIGRUNTIME void
872
SWIG_Python_AddErrorMsg(const char* mesg)
873
{
874
PyObject *type = 0;
875
PyObject *value = 0;
876
PyObject *traceback = 0;
877
878
if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
879
if (value) {
880
PyObject *old_str = PyObject_Str(value);
881
PyErr_Clear();
882
Py_XINCREF(type);
883
PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
884
Py_DECREF(old_str);
885
Py_DECREF(value);
886
} else {
887
PyErr_SetString(PyExc_RuntimeError, mesg);
888
}
889
}
890
891
892
893
#if defined(SWIG_PYTHON_NO_THREADS)
894
# if defined(SWIG_PYTHON_THREADS)
895
# undef SWIG_PYTHON_THREADS
896
# endif
897
#endif
898
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
899
# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
900
# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
901
# define SWIG_PYTHON_USE_GIL
902
# endif
903
# endif
904
# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
905
# ifndef SWIG_PYTHON_INITIALIZE_THREADS
906
# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
907
# endif
908
# ifdef __cplusplus /* C++ code */
909
class SWIG_Python_Thread_Block {
910
bool status;
911
PyGILState_STATE state;
912
public:
913
void end() { if (status) { PyGILState_Release(state); status = false;} }
914
SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
915
~SWIG_Python_Thread_Block() { end(); }
916
};
917
class SWIG_Python_Thread_Allow {
918
bool status;
919
PyThreadState *save;
920
public:
921
void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
922
SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
923
~SWIG_Python_Thread_Allow() { end(); }
924
};
925
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
926
# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
927
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
928
# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
929
# else /* C code */
930
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
931
# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
932
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
933
# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
934
# endif
935
# else /* Old thread way, not implemented, user must provide it */
936
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
937
# define SWIG_PYTHON_INITIALIZE_THREADS
938
# endif
939
# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
940
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
941
# endif
942
# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
943
# define SWIG_PYTHON_THREAD_END_BLOCK
944
# endif
945
# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
946
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
947
# endif
948
# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
949
# define SWIG_PYTHON_THREAD_END_ALLOW
950
# endif
951
# endif
952
#else /* No thread support */
953
# define SWIG_PYTHON_INITIALIZE_THREADS
954
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
955
# define SWIG_PYTHON_THREAD_END_BLOCK
956
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
957
# define SWIG_PYTHON_THREAD_END_ALLOW
958
#endif
959
960
/* -----------------------------------------------------------------------------
961
* Python API portion that goes into the runtime
962
* ----------------------------------------------------------------------------- */
963
964
#ifdef __cplusplus
965
extern "C" {
966
#if 0
967
} /* cc-mode */
968
#endif
969
#endif
970
971
/* -----------------------------------------------------------------------------
972
* Constant declarations
973
* ----------------------------------------------------------------------------- */
974
975
/* Constant Types */
976
#define SWIG_PY_POINTER 4
977
#define SWIG_PY_BINARY 5
978
979
/* Constant information structure */
980
typedef struct swig_const_info {
981
int type;
982
char *name;
983
long lvalue;
984
double dvalue;
985
void *pvalue;
986
swig_type_info **ptype;
987
} swig_const_info;
988
989
#ifdef __cplusplus
990
#if 0
991
{ /* cc-mode */
992
#endif
993
}
994
#endif
995
996
997
/* -----------------------------------------------------------------------------
998
* See the LICENSE file for information on copyright, usage and redistribution
999
* of SWIG, and the README file for authors - http://www.swig.org/release.html.
1000
*
1001
* pyrun.swg
1002
*
1003
* This file contains the runtime support for Python modules
1004
* and includes code for managing global variables and pointer
1005
* type checking.
1006
*
1007
* ----------------------------------------------------------------------------- */
1008
1009
/* Common SWIG API */
1010
1011
/* for raw pointers */
1012
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1013
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1014
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1015
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
1016
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1017
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1018
#define swig_owntype int
1019
1020
/* for raw packed data */
1021
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1022
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1023
1024
/* for class or struct pointers */
1025
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1026
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1027
1028
/* for C or C++ function pointers */
1029
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1030
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1031
1032
/* for C++ member pointers, ie, member methods */
1033
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1034
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1035
1036
1037
/* Runtime API */
1038
1039
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1040
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1041
#define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1042
1043
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1044
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1045
#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1046
#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1047
#define SWIG_fail goto fail
1048
1049
1050
/* Runtime API implementation */
1051
1052
/* Error manipulation */
1053
1054
SWIGINTERN void
1055
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1056
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1057
PyErr_SetObject(errtype, obj);
1058
Py_DECREF(obj);
1059
SWIG_PYTHON_THREAD_END_BLOCK;
1060
}
1061
1062
SWIGINTERN void
1063
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1064
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1065
PyErr_SetString(errtype, (char *) msg);
1066
SWIG_PYTHON_THREAD_END_BLOCK;
1067
}
1068
1069
#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1070
1071
/* Set a constant value */
1072
1073
SWIGINTERN void
1074
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1075
PyDict_SetItemString(d, (char*) name, obj);
1076
Py_DECREF(obj);
1077
}
1078
1079
/* Append a value to the result obj */
1080
1081
SWIGINTERN PyObject*
1082
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1083
#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1084
if (!result) {
1085
result = obj;
1086
} else if (result == Py_None) {
1087
Py_DECREF(result);
1088
result = obj;
1089
} else {
1090
if (!PyList_Check(result)) {
1091
PyObject *o2 = result;
1092
result = PyList_New(1);
1093
PyList_SetItem(result, 0, o2);
1094
}
1095
PyList_Append(result,obj);
1096
Py_DECREF(obj);
1097
}
1098
return result;
1099
#else
1100
PyObject* o2;
1101
PyObject* o3;
1102
if (!result) {
1103
result = obj;
1104
} else if (result == Py_None) {
1105
Py_DECREF(result);
1106
result = obj;
1107
} else {
1108
if (!PyTuple_Check(result)) {
1109
o2 = result;
1110
result = PyTuple_New(1);
1111
PyTuple_SET_ITEM(result, 0, o2);
1112
}
1113
o3 = PyTuple_New(1);
1114
PyTuple_SET_ITEM(o3, 0, obj);
1115
o2 = result;
1116
result = PySequence_Concat(o2, o3);
1117
Py_DECREF(o2);
1118
Py_DECREF(o3);
1119
}
1120
return result;
1121
#endif
1122
}
1123
1124
/* Unpack the argument tuple */
1125
1126
SWIGINTERN int
1127
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1128
{
1129
if (!args) {
1130
if (!min && !max) {
1131
return 1;
1132
} else {
1133
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1134
name, (min == max ? "" : "at least "), (int)min);
1135
return 0;
1136
}
1137
}
1138
if (!PyTuple_Check(args)) {
1139
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1140
return 0;
1141
} else {
1142
register Py_ssize_t l = PyTuple_GET_SIZE(args);
1143
if (l < min) {
1144
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1145
name, (min == max ? "" : "at least "), (int)min, (int)l);
1146
return 0;
1147
} else if (l > max) {
1148
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1149
name, (min == max ? "" : "at most "), (int)max, (int)l);
1150
return 0;
1151
} else {
1152
register int i;
1153
for (i = 0; i < l; ++i) {
1154
objs[i] = PyTuple_GET_ITEM(args, i);
1155
}
1156
for (; l < max; ++l) {
1157
objs[l] = 0;
1158
}
1159
return i + 1;
1160
}
1161
}
1162
}
1163
1164
/* A functor is a function object with one single object argument */
1165
#if PY_VERSION_HEX >= 0x02020000
1166
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1167
#else
1168
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1169
#endif
1170
1171
/*
1172
Helper for static pointer initialization for both C and C++ code, for example
1173
static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1174
*/
1175
#ifdef __cplusplus
1176
#define SWIG_STATIC_POINTER(var) var
1177
#else
1178
#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1179
#endif
1180
1181
/* -----------------------------------------------------------------------------
1182
* Pointer declarations
1183
* ----------------------------------------------------------------------------- */
1184
1185
/* Flags for new pointer objects */
1186
#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1187
#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1188
1189
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1190
1191
#ifdef __cplusplus
1192
extern "C" {
1193
#if 0
1194
} /* cc-mode */
1195
#endif
1196
#endif
1197
1198
/* How to access Py_None */
1199
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1200
# ifndef SWIG_PYTHON_NO_BUILD_NONE
1201
# ifndef SWIG_PYTHON_BUILD_NONE
1202
# define SWIG_PYTHON_BUILD_NONE
1203
# endif
1204
# endif
1205
#endif
1206
1207
#ifdef SWIG_PYTHON_BUILD_NONE
1208
# ifdef Py_None
1209
# undef Py_None
1210
# define Py_None SWIG_Py_None()
1211
# endif
1212
SWIGRUNTIMEINLINE PyObject *
1213
_SWIG_Py_None(void)
1214
{
1215
PyObject *none = Py_BuildValue((char*)"");
1216
Py_DECREF(none);
1217
return none;
1218
}
1219
SWIGRUNTIME PyObject *
1220
SWIG_Py_None(void)
1221
{
1222
static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1223
return none;
1224
}
1225
#endif
1226
1227
/* The python void return value */
1228
1229
SWIGRUNTIMEINLINE PyObject *
1230
SWIG_Py_Void(void)
1231
{
1232
PyObject *none = Py_None;
1233
Py_INCREF(none);
1234
return none;
1235
}
1236
1237
/* PySwigClientData */
1238
1239
typedef struct {
1240
PyObject *klass;
1241
PyObject *newraw;
1242
PyObject *newargs;
1243
PyObject *destroy;
1244
int delargs;
1245
int implicitconv;
1246
} PySwigClientData;
1247
1248
SWIGRUNTIMEINLINE int
1249
SWIG_Python_CheckImplicit(swig_type_info *ty)
1250
{
1251
PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1252
return data ? data->implicitconv : 0;
1253
}
1254
1255
SWIGRUNTIMEINLINE PyObject *
1256
SWIG_Python_ExceptionType(swig_type_info *desc) {
1257
PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1258
PyObject *klass = data ? data->klass : 0;
1259
return (klass ? klass : PyExc_RuntimeError);
1260
}
1261
1262
1263
SWIGRUNTIME PySwigClientData *
1264
PySwigClientData_New(PyObject* obj)
1265
{
1266
if (!obj) {
1267
return 0;
1268
} else {
1269
PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1270
/* the klass element */
1271
data->klass = obj;
1272
Py_INCREF(data->klass);
1273
/* the newraw method and newargs arguments used to create a new raw instance */
1274
if (PyClass_Check(obj)) {
1275
data->newraw = 0;
1276
data->newargs = obj;
1277
Py_INCREF(obj);
1278
} else {
1279
#if (PY_VERSION_HEX < 0x02020000)
1280
data->newraw = 0;
1281
#else
1282
data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1283
#endif
1284
if (data->newraw) {
1285
Py_INCREF(data->newraw);
1286
data->newargs = PyTuple_New(1);
1287
PyTuple_SetItem(data->newargs, 0, obj);
1288
} else {
1289
data->newargs = obj;
1290
}
1291
Py_INCREF(data->newargs);
1292
}
1293
/* the destroy method, aka as the C++ delete method */
1294
data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1295
if (PyErr_Occurred()) {
1296
PyErr_Clear();
1297
data->destroy = 0;
1298
}
1299
if (data->destroy) {
1300
int flags;
1301
Py_INCREF(data->destroy);
1302
flags = PyCFunction_GET_FLAGS(data->destroy);
1303
#ifdef METH_O
1304
data->delargs = !(flags & (METH_O));
1305
#else
1306
data->delargs = 0;
1307
#endif
1308
} else {
1309
data->delargs = 0;
1310
}
1311
data->implicitconv = 0;
1312
return data;
1313
}
1314
}
1315
1316
SWIGRUNTIME void
1317
PySwigClientData_Del(PySwigClientData* data)
1318
{
1319
Py_XDECREF(data->newraw);
1320
Py_XDECREF(data->newargs);
1321
Py_XDECREF(data->destroy);
1322
}
1323
1324
/* =============== PySwigObject =====================*/
1325
1326
typedef struct {
1327
PyObject_HEAD
1328
void *ptr;
1329
swig_type_info *ty;
1330
int own;
1331
PyObject *next;
1332
} PySwigObject;
1333
1334
SWIGRUNTIME PyObject *
1335
PySwigObject_long(PySwigObject *v)
1336
{
1337
return PyLong_FromVoidPtr(v->ptr);
1338
}
1339
1340
SWIGRUNTIME PyObject *
1341
PySwigObject_format(const char* fmt, PySwigObject *v)
1342
{
1343
PyObject *res = NULL;
1344
PyObject *args = PyTuple_New(1);
1345
if (args) {
1346
if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1347
PyObject *ofmt = PyString_FromString(fmt);
1348
if (ofmt) {
1349
res = PyString_Format(ofmt,args);
1350
Py_DECREF(ofmt);
1351
}
1352
Py_DECREF(args);
1353
}
1354
}
1355
return res;
1356
}
1357
1358
SWIGRUNTIME PyObject *
1359
PySwigObject_oct(PySwigObject *v)
1360
{
1361
return PySwigObject_format("%o",v);
1362
}
1363
1364
SWIGRUNTIME PyObject *
1365
PySwigObject_hex(PySwigObject *v)
1366
{
1367
return PySwigObject_format("%x",v);
1368
}
1369
1370
SWIGRUNTIME PyObject *
1371
#ifdef METH_NOARGS
1372
PySwigObject_repr(PySwigObject *v)
1373
#else
1374
PySwigObject_repr(PySwigObject *v, PyObject *args)
1375
#endif
1376
{
1377
const char *name = SWIG_TypePrettyName(v->ty);
1378
PyObject *hex = PySwigObject_hex(v);
1379
PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1380
Py_DECREF(hex);
1381
if (v->next) {
1382
#ifdef METH_NOARGS
1383
PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1384
#else
1385
PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1386
#endif
1387
PyString_ConcatAndDel(&repr,nrep);
1388
}
1389
return repr;
1390
}
1391
1392
SWIGRUNTIME int
1393
PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1394
{
1395
#ifdef METH_NOARGS
1396
PyObject *repr = PySwigObject_repr(v);
1397
#else
1398
PyObject *repr = PySwigObject_repr(v, NULL);
1399
#endif
1400
if (repr) {
1401
fputs(PyString_AsString(repr), fp);
1402
Py_DECREF(repr);
1403
return 0;
1404
} else {
1405
return 1;
1406
}
1407
}
1408
1409
SWIGRUNTIME PyObject *
1410
PySwigObject_str(PySwigObject *v)
1411
{
1412
char result[SWIG_BUFFER_SIZE];
1413
return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1414
PyString_FromString(result) : 0;
1415
}
1416
1417
SWIGRUNTIME int
1418
PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1419
{
1420
void *i = v->ptr;
1421
void *j = w->ptr;
1422
return (i < j) ? -1 : ((i > j) ? 1 : 0);
1423
}
1424
1425
SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1426
1427
SWIGRUNTIME PyTypeObject*
1428
PySwigObject_type(void) {
1429
static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1430
return type;
1431
}
1432
1433
SWIGRUNTIMEINLINE int
1434
PySwigObject_Check(PyObject *op) {
1435
return ((op)->ob_type == PySwigObject_type())
1436
|| (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1437
}
1438
1439
SWIGRUNTIME PyObject *
1440
PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1441
1442
SWIGRUNTIME void
1443
PySwigObject_dealloc(PyObject *v)
1444
{
1445
PySwigObject *sobj = (PySwigObject *) v;
1446
PyObject *next = sobj->next;
1447
if (sobj->own == SWIG_POINTER_OWN) {
1448
swig_type_info *ty = sobj->ty;
1449
PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1450
PyObject *destroy = data ? data->destroy : 0;
1451
if (destroy) {
1452
/* destroy is always a VARARGS method */
1453
PyObject *res;
1454
if (data->delargs) {
1455
/* we need to create a temporal object to carry the destroy operation */
1456
PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1457
res = SWIG_Python_CallFunctor(destroy, tmp);
1458
Py_DECREF(tmp);
1459
} else {
1460
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1461
PyObject *mself = PyCFunction_GET_SELF(destroy);
1462
res = ((*meth)(mself, v));
1463
}
1464
Py_XDECREF(res);
1465
}
1466
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1467
else {
1468
const char *name = SWIG_TypePrettyName(ty);
1469
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1470
}
1471
#endif
1472
}
1473
Py_XDECREF(next);
1474
PyObject_DEL(v);
1475
}
1476
1477
SWIGRUNTIME PyObject*
1478
PySwigObject_append(PyObject* v, PyObject* next)
1479
{
1480
PySwigObject *sobj = (PySwigObject *) v;
1481
#ifndef METH_O
1482
PyObject *tmp = 0;
1483
if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1484
next = tmp;
1485
#endif
1486
if (!PySwigObject_Check(next)) {
1487
return NULL;
1488
}
1489
sobj->next = next;
1490
Py_INCREF(next);
1491
return SWIG_Py_Void();
1492
}
1493
1494
SWIGRUNTIME PyObject*
1495
#ifdef METH_NOARGS
1496
PySwigObject_next(PyObject* v)
1497
#else
1498
PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1499
#endif
1500
{
1501
PySwigObject *sobj = (PySwigObject *) v;
1502
if (sobj->next) {
1503
Py_INCREF(sobj->next);
1504
return sobj->next;
1505
} else {
1506
return SWIG_Py_Void();
1507
}
1508
}
1509
1510
SWIGINTERN PyObject*
1511
#ifdef METH_NOARGS
1512
PySwigObject_disown(PyObject *v)
1513
#else
1514
PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1515
#endif
1516
{
1517
PySwigObject *sobj = (PySwigObject *)v;
1518
sobj->own = 0;
1519
return SWIG_Py_Void();
1520
}
1521
1522
SWIGINTERN PyObject*
1523
#ifdef METH_NOARGS
1524
PySwigObject_acquire(PyObject *v)
1525
#else
1526
PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1527
#endif
1528
{
1529
PySwigObject *sobj = (PySwigObject *)v;
1530
sobj->own = SWIG_POINTER_OWN;
1531
return SWIG_Py_Void();
1532
}
1533
1534
SWIGINTERN PyObject*
1535
PySwigObject_own(PyObject *v, PyObject *args)
1536
{
1537
PyObject *val = 0;
1538
#if (PY_VERSION_HEX < 0x02020000)
1539
if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1540
#else
1541
if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1542
#endif
1543
{
1544
return NULL;
1545
}
1546
else
1547
{
1548
PySwigObject *sobj = (PySwigObject *)v;
1549
PyObject *obj = PyBool_FromLong(sobj->own);
1550
if (val) {
1551
#ifdef METH_NOARGS
1552
if (PyObject_IsTrue(val)) {
1553
PySwigObject_acquire(v);
1554
} else {
1555
PySwigObject_disown(v);
1556
}
1557
#else
1558
if (PyObject_IsTrue(val)) {
1559
PySwigObject_acquire(v,args);
1560
} else {
1561
PySwigObject_disown(v,args);
1562
}
1563
#endif
1564
}
1565
return obj;
1566
}
1567
}
1568
1569
#ifdef METH_O
1570
static PyMethodDef
1571
swigobject_methods[] = {
1572
{(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1573
{(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1574
{(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1575
{(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1576
{(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1577
{(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1578
{0, 0, 0, 0}
1579
};
1580
#else
1581
static PyMethodDef
1582
swigobject_methods[] = {
1583
{(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1584
{(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1585
{(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1586
{(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1587
{(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1588
{(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1589
{0, 0, 0, 0}
1590
};
1591
#endif
1592
1593
#if PY_VERSION_HEX < 0x02020000
1594
SWIGINTERN PyObject *
1595
PySwigObject_getattr(PySwigObject *sobj,char *name)
1596
{
1597
return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1598
}
1599
#endif
1600
1601
SWIGRUNTIME PyTypeObject*
1602
_PySwigObject_type(void) {
1603
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1604
1605
static PyNumberMethods PySwigObject_as_number = {
1606
(binaryfunc)0, /*nb_add*/
1607
(binaryfunc)0, /*nb_subtract*/
1608
(binaryfunc)0, /*nb_multiply*/
1609
(binaryfunc)0, /*nb_divide*/
1610
(binaryfunc)0, /*nb_remainder*/
1611
(binaryfunc)0, /*nb_divmod*/
1612
(ternaryfunc)0,/*nb_power*/
1613
(unaryfunc)0, /*nb_negative*/
1614
(unaryfunc)0, /*nb_positive*/
1615
(unaryfunc)0, /*nb_absolute*/
1616
(inquiry)0, /*nb_nonzero*/
1617
0, /*nb_invert*/
1618
0, /*nb_lshift*/
1619
0, /*nb_rshift*/
1620
0, /*nb_and*/
1621
0, /*nb_xor*/
1622
0, /*nb_or*/
1623
(coercion)0, /*nb_coerce*/
1624
(unaryfunc)PySwigObject_long, /*nb_int*/
1625
(unaryfunc)PySwigObject_long, /*nb_long*/
1626
(unaryfunc)0, /*nb_float*/
1627
(unaryfunc)PySwigObject_oct, /*nb_oct*/
1628
(unaryfunc)PySwigObject_hex, /*nb_hex*/
1629
#if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1630
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1631
#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1632
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1633
#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1634
0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1635
#endif
1636
};
1637
1638
static PyTypeObject pyswigobject_type;
1639
static int type_init = 0;
1640
if (!type_init) {
1641
const PyTypeObject tmp
1642
= {
1643
PyObject_HEAD_INIT(NULL)
1644
0, /* ob_size */
1645
(char *)"PySwigObject", /* tp_name */
1646
sizeof(PySwigObject), /* tp_basicsize */
1647
0, /* tp_itemsize */
1648
(destructor)PySwigObject_dealloc, /* tp_dealloc */
1649
(printfunc)PySwigObject_print, /* tp_print */
1650
#if PY_VERSION_HEX < 0x02020000
1651
(getattrfunc)PySwigObject_getattr, /* tp_getattr */
1652
#else
1653
(getattrfunc)0, /* tp_getattr */
1654
#endif
1655
(setattrfunc)0, /* tp_setattr */
1656
(cmpfunc)PySwigObject_compare, /* tp_compare */
1657
(reprfunc)PySwigObject_repr, /* tp_repr */
1658
&PySwigObject_as_number, /* tp_as_number */
1659
0, /* tp_as_sequence */
1660
0, /* tp_as_mapping */
1661
(hashfunc)0, /* tp_hash */
1662
(ternaryfunc)0, /* tp_call */
1663
(reprfunc)PySwigObject_str, /* tp_str */
1664
PyObject_GenericGetAttr, /* tp_getattro */
1665
0, /* tp_setattro */
1666
0, /* tp_as_buffer */
1667
Py_TPFLAGS_DEFAULT, /* tp_flags */
1668
swigobject_doc, /* tp_doc */
1669
0, /* tp_traverse */
1670
0, /* tp_clear */
1671
0, /* tp_richcompare */
1672
0, /* tp_weaklistoffset */
1673
#if PY_VERSION_HEX >= 0x02020000
1674
0, /* tp_iter */
1675
0, /* tp_iternext */
1676
swigobject_methods, /* tp_methods */
1677
0, /* tp_members */
1678
0, /* tp_getset */
1679
0, /* tp_base */
1680
0, /* tp_dict */
1681
0, /* tp_descr_get */
1682
0, /* tp_descr_set */
1683
0, /* tp_dictoffset */
1684
0, /* tp_init */
1685
0, /* tp_alloc */
1686
0, /* tp_new */
1687
0, /* tp_free */
1688
0, /* tp_is_gc */
1689
0, /* tp_bases */
1690
0, /* tp_mro */
1691
0, /* tp_cache */
1692
0, /* tp_subclasses */
1693
0, /* tp_weaklist */
1694
#endif
1695
#if PY_VERSION_HEX >= 0x02030000
1696
0, /* tp_del */
1697
#endif
1698
#ifdef COUNT_ALLOCS
1699
0,0,0,0 /* tp_alloc -> tp_next */
1700
#endif
1701
};
1702
pyswigobject_type = tmp;
1703
pyswigobject_type.ob_type = &PyType_Type;
1704
type_init = 1;
1705
}
1706
return &pyswigobject_type;
1707
}
1708
1709
SWIGRUNTIME PyObject *
1710
PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1711
{
1712
PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1713
if (sobj) {
1714
sobj->ptr = ptr;
1715
sobj->ty = ty;
1716
sobj->own = own;
1717
sobj->next = 0;
1718
}
1719
return (PyObject *)sobj;
1720
}
1721
1722
/* -----------------------------------------------------------------------------
1723
* Implements a simple Swig Packed type, and use it instead of string
1724
* ----------------------------------------------------------------------------- */
1725
1726
typedef struct {
1727
PyObject_HEAD
1728
void *pack;
1729
swig_type_info *ty;
1730
size_t size;
1731
} PySwigPacked;
1732
1733
SWIGRUNTIME int
1734
PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1735
{
1736
char result[SWIG_BUFFER_SIZE];
1737
fputs("<Swig Packed ", fp);
1738
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1739
fputs("at ", fp);
1740
fputs(result, fp);
1741
}
1742
fputs(v->ty->name,fp);
1743
fputs(">", fp);
1744
return 0;
1745
}
1746
1747
SWIGRUNTIME PyObject *
1748
PySwigPacked_repr(PySwigPacked *v)
1749
{
1750
char result[SWIG_BUFFER_SIZE];
1751
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1752
return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1753
} else {
1754
return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1755
}
1756
}
1757
1758
SWIGRUNTIME PyObject *
1759
PySwigPacked_str(PySwigPacked *v)
1760
{
1761
char result[SWIG_BUFFER_SIZE];
1762
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1763
return PyString_FromFormat("%s%s", result, v->ty->name);
1764
} else {
1765
return PyString_FromString(v->ty->name);
1766
}
1767
}
1768
1769
SWIGRUNTIME int
1770
PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1771
{
1772
size_t i = v->size;
1773
size_t j = w->size;
1774
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1775
return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1776
}
1777
1778
SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1779
1780
SWIGRUNTIME PyTypeObject*
1781
PySwigPacked_type(void) {
1782
static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1783
return type;
1784
}
1785
1786
SWIGRUNTIMEINLINE int
1787
PySwigPacked_Check(PyObject *op) {
1788
return ((op)->ob_type == _PySwigPacked_type())
1789
|| (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1790
}
1791
1792
SWIGRUNTIME void
1793
PySwigPacked_dealloc(PyObject *v)
1794
{
1795
if (PySwigPacked_Check(v)) {
1796
PySwigPacked *sobj = (PySwigPacked *) v;
1797
free(sobj->pack);
1798
}
1799
PyObject_DEL(v);
1800
}
1801
1802
SWIGRUNTIME PyTypeObject*
1803
_PySwigPacked_type(void) {
1804
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1805
static PyTypeObject pyswigpacked_type;
1806
static int type_init = 0;
1807
if (!type_init) {
1808
const PyTypeObject tmp
1809
= {
1810
PyObject_HEAD_INIT(NULL)
1811
0, /* ob_size */
1812
(char *)"PySwigPacked", /* tp_name */
1813
sizeof(PySwigPacked), /* tp_basicsize */
1814
0, /* tp_itemsize */
1815
(destructor)PySwigPacked_dealloc, /* tp_dealloc */
1816
(printfunc)PySwigPacked_print, /* tp_print */
1817
(getattrfunc)0, /* tp_getattr */
1818
(setattrfunc)0, /* tp_setattr */
1819
(cmpfunc)PySwigPacked_compare, /* tp_compare */
1820
(reprfunc)PySwigPacked_repr, /* tp_repr */
1821
0, /* tp_as_number */
1822
0, /* tp_as_sequence */
1823
0, /* tp_as_mapping */
1824
(hashfunc)0, /* tp_hash */
1825
(ternaryfunc)0, /* tp_call */
1826
(reprfunc)PySwigPacked_str, /* tp_str */
1827
PyObject_GenericGetAttr, /* tp_getattro */
1828
0, /* tp_setattro */
1829
0, /* tp_as_buffer */
1830
Py_TPFLAGS_DEFAULT, /* tp_flags */
1831
swigpacked_doc, /* tp_doc */
1832
0, /* tp_traverse */
1833
0, /* tp_clear */
1834
0, /* tp_richcompare */
1835
0, /* tp_weaklistoffset */
1836
#if PY_VERSION_HEX >= 0x02020000
1837
0, /* tp_iter */
1838
0, /* tp_iternext */
1839
0, /* tp_methods */
1840
0, /* tp_members */
1841
0, /* tp_getset */
1842
0, /* tp_base */
1843
0, /* tp_dict */
1844
0, /* tp_descr_get */
1845
0, /* tp_descr_set */
1846
0, /* tp_dictoffset */
1847
0, /* tp_init */
1848
0, /* tp_alloc */
1849
0, /* tp_new */
1850
0, /* tp_free */
1851
0, /* tp_is_gc */
1852
0, /* tp_bases */
1853
0, /* tp_mro */
1854
0, /* tp_cache */
1855
0, /* tp_subclasses */
1856
0, /* tp_weaklist */
1857
#endif
1858
#if PY_VERSION_HEX >= 0x02030000
1859
0, /* tp_del */
1860
#endif
1861
#ifdef COUNT_ALLOCS
1862
0,0,0,0 /* tp_alloc -> tp_next */
1863
#endif
1864
};
1865
pyswigpacked_type = tmp;
1866
pyswigpacked_type.ob_type = &PyType_Type;
1867
type_init = 1;
1868
}
1869
return &pyswigpacked_type;
1870
}
1871
1872
SWIGRUNTIME PyObject *
1873
PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1874
{
1875
PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1876
if (sobj) {
1877
void *pack = malloc(size);
1878
if (pack) {
1879
memcpy(pack, ptr, size);
1880
sobj->pack = pack;
1881
sobj->ty = ty;
1882
sobj->size = size;
1883
} else {
1884
PyObject_DEL((PyObject *) sobj);
1885
sobj = 0;
1886
}
1887
}
1888
return (PyObject *) sobj;
1889
}
1890
1891
SWIGRUNTIME swig_type_info *
1892
PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1893
{
1894
if (PySwigPacked_Check(obj)) {
1895
PySwigPacked *sobj = (PySwigPacked *)obj;
1896
if (sobj->size != size) return 0;
1897
memcpy(ptr, sobj->pack, size);
1898
return sobj->ty;
1899
} else {
1900
return 0;
1901
}
1902
}
1903
1904
/* -----------------------------------------------------------------------------
1905
* pointers/data manipulation
1906
* ----------------------------------------------------------------------------- */
1907
1908
SWIGRUNTIMEINLINE PyObject *
1909
_SWIG_This(void)
1910
{
1911
return PyString_FromString("this");
1912
}
1913
1914
SWIGRUNTIME PyObject *
1915
SWIG_This(void)
1916
{
1917
static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1918
return swig_this;
1919
}
1920
1921
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1922
1923
SWIGRUNTIME PySwigObject *
1924
SWIG_Python_GetSwigThis(PyObject *pyobj)
1925
{
1926
if (PySwigObject_Check(pyobj)) {
1927
return (PySwigObject *) pyobj;
1928
} else {
1929
PyObject *obj = 0;
1930
#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1931
if (PyInstance_Check(pyobj)) {
1932
obj = _PyInstance_Lookup(pyobj, SWIG_This());
1933
} else {
1934
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1935
if (dictptr != NULL) {
1936
PyObject *dict = *dictptr;
1937
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1938
} else {
1939
#ifdef PyWeakref_CheckProxy
1940
if (PyWeakref_CheckProxy(pyobj)) {
1941
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1942
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1943
}
1944
#endif
1945
obj = PyObject_GetAttr(pyobj,SWIG_This());
1946
if (obj) {
1947
Py_DECREF(obj);
1948
} else {
1949
if (PyErr_Occurred()) PyErr_Clear();
1950
return 0;
1951
}
1952
}
1953
}
1954
#else
1955
obj = PyObject_GetAttr(pyobj,SWIG_This());
1956
if (obj) {
1957
Py_DECREF(obj);
1958
} else {
1959
if (PyErr_Occurred()) PyErr_Clear();
1960
return 0;
1961
}
1962
#endif
1963
if (obj && !PySwigObject_Check(obj)) {
1964
/* a PyObject is called 'this', try to get the 'real this'
1965
PySwigObject from it */
1966
return SWIG_Python_GetSwigThis(obj);
1967
}
1968
return (PySwigObject *)obj;
1969
}
1970
}
1971
1972
/* Acquire a pointer value */
1973
1974
SWIGRUNTIME int
1975
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1976
if (own == SWIG_POINTER_OWN) {
1977
PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1978
if (sobj) {
1979
int oldown = sobj->own;
1980
sobj->own = own;
1981
return oldown;
1982
}
1983
}
1984
return 0;
1985
}
1986
1987
/* Convert a pointer value */
1988
1989
SWIGRUNTIME int
1990
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1991
if (!obj) return SWIG_ERROR;
1992
if (obj == Py_None) {
1993
if (ptr) *ptr = 0;
1994
return SWIG_OK;
1995
} else {
1996
PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1997
if (own)
1998
*own = 0;
1999
while (sobj) {
2000
void *vptr = sobj->ptr;
2001
if (ty) {
2002
swig_type_info *to = sobj->ty;
2003
if (to == ty) {
2004
/* no type cast needed */
2005
if (ptr) *ptr = vptr;
2006
break;
2007
} else {
2008
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2009
if (!tc) {
2010
sobj = (PySwigObject *)sobj->next;
2011
} else {
2012
if (ptr) {
2013
int newmemory = 0;
2014
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2015
if (newmemory == SWIG_CAST_NEW_MEMORY) {
2016
assert(own);
2017
if (own)
2018
*own = *own | SWIG_CAST_NEW_MEMORY;
2019
}
2020
}
2021
break;
2022
}
2023
}
2024
} else {
2025
if (ptr) *ptr = vptr;
2026
break;
2027
}
2028
}
2029
if (sobj) {
2030
if (own)
2031
*own = *own | sobj->own;
2032
if (flags & SWIG_POINTER_DISOWN) {
2033
sobj->own = 0;
2034
}
2035
return SWIG_OK;
2036
} else {
2037
int res = SWIG_ERROR;
2038
if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2039
PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2040
if (data && !data->implicitconv) {
2041
PyObject *klass = data->klass;
2042
if (klass) {
2043
PyObject *impconv;
2044
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2045
impconv = SWIG_Python_CallFunctor(klass, obj);
2046
data->implicitconv = 0;
2047
if (PyErr_Occurred()) {
2048
PyErr_Clear();
2049
impconv = 0;
2050
}
2051
if (impconv) {
2052
PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2053
if (iobj) {
2054
void *vptr;
2055
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2056
if (SWIG_IsOK(res)) {
2057
if (ptr) {
2058
*ptr = vptr;
2059
/* transfer the ownership to 'ptr' */
2060
iobj->own = 0;
2061
res = SWIG_AddCast(res);
2062
res = SWIG_AddNewMask(res);
2063
} else {
2064
res = SWIG_AddCast(res);
2065
}
2066
}
2067
}
2068
Py_DECREF(impconv);
2069
}
2070
}
2071
}
2072
}
2073
return res;
2074
}
2075
}
2076
}
2077
2078
/* Convert a function ptr value */
2079
2080
SWIGRUNTIME int
2081
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2082
if (!PyCFunction_Check(obj)) {
2083
return SWIG_ConvertPtr(obj, ptr, ty, 0);
2084
} else {
2085
void *vptr = 0;
2086
2087
/* here we get the method pointer for callbacks */
2088
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2089
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2090
if (desc) {
2091
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2092
if (!desc) return SWIG_ERROR;
2093
}
2094
if (ty) {
2095
swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2096
if (tc) {
2097
int newmemory = 0;
2098
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2099
assert(!newmemory); /* newmemory handling not yet implemented */
2100
} else {
2101
return SWIG_ERROR;
2102
}
2103
} else {
2104
*ptr = vptr;
2105
}
2106
return SWIG_OK;
2107
}
2108
}
2109
2110
/* Convert a packed value value */
2111
2112
SWIGRUNTIME int
2113
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2114
swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2115
if (!to) return SWIG_ERROR;
2116
if (ty) {
2117
if (to != ty) {
2118
/* check type cast? */
2119
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2120
if (!tc) return SWIG_ERROR;
2121
}
2122
}
2123
return SWIG_OK;
2124
}
2125
2126
/* -----------------------------------------------------------------------------
2127
* Create a new pointer object
2128
* ----------------------------------------------------------------------------- */
2129
2130
/*
2131
Create a new instance object, whitout calling __init__, and set the
2132
'this' attribute.
2133
*/
2134
2135
SWIGRUNTIME PyObject*
2136
SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2137
{
2138
#if (PY_VERSION_HEX >= 0x02020000)
2139
PyObject *inst = 0;
2140
PyObject *newraw = data->newraw;
2141
if (newraw) {
2142
inst = PyObject_Call(newraw, data->newargs, NULL);
2143
if (inst) {
2144
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2145
PyObject **dictptr = _PyObject_GetDictPtr(inst);
2146
if (dictptr != NULL) {
2147
PyObject *dict = *dictptr;
2148
if (dict == NULL) {
2149
dict = PyDict_New();
2150
*dictptr = dict;
2151
PyDict_SetItem(dict, SWIG_This(), swig_this);
2152
}
2153
}
2154
#else
2155
PyObject *key = SWIG_This();
2156
PyObject_SetAttr(inst, key, swig_this);
2157
#endif
2158
}
2159
} else {
2160
PyObject *dict = PyDict_New();
2161
PyDict_SetItem(dict, SWIG_This(), swig_this);
2162
inst = PyInstance_NewRaw(data->newargs, dict);
2163
Py_DECREF(dict);
2164
}
2165
return inst;
2166
#else
2167
#if (PY_VERSION_HEX >= 0x02010000)
2168
PyObject *inst;
2169
PyObject *dict = PyDict_New();
2170
PyDict_SetItem(dict, SWIG_This(), swig_this);
2171
inst = PyInstance_NewRaw(data->newargs, dict);
2172
Py_DECREF(dict);
2173
return (PyObject *) inst;
2174
#else
2175
PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2176
if (inst == NULL) {
2177
return NULL;
2178
}
2179
inst->in_class = (PyClassObject *)data->newargs;
2180
Py_INCREF(inst->in_class);
2181
inst->in_dict = PyDict_New();
2182
if (inst->in_dict == NULL) {
2183
Py_DECREF(inst);
2184
return NULL;
2185
}
2186
#ifdef Py_TPFLAGS_HAVE_WEAKREFS
2187
inst->in_weakreflist = NULL;
2188
#endif
2189
#ifdef Py_TPFLAGS_GC
2190
PyObject_GC_Init(inst);
2191
#endif
2192
PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2193
return (PyObject *) inst;
2194
#endif
2195
#endif
2196
}
2197
2198
SWIGRUNTIME void
2199
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2200
{
2201
PyObject *dict;
2202
#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2203
PyObject **dictptr = _PyObject_GetDictPtr(inst);
2204
if (dictptr != NULL) {
2205
dict = *dictptr;
2206
if (dict == NULL) {
2207
dict = PyDict_New();
2208
*dictptr = dict;
2209
}
2210
PyDict_SetItem(dict, SWIG_This(), swig_this);
2211
return;
2212
}
2213
#endif
2214
dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2215
PyDict_SetItem(dict, SWIG_This(), swig_this);
2216
Py_DECREF(dict);
2217
}
2218
2219
2220
SWIGINTERN PyObject *
2221
SWIG_Python_InitShadowInstance(PyObject *args) {
2222
PyObject *obj[2];
2223
if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2224
return NULL;
2225
} else {
2226
PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2227
if (sthis) {
2228
PySwigObject_append((PyObject*) sthis, obj[1]);
2229
} else {
2230
SWIG_Python_SetSwigThis(obj[0], obj[1]);
2231
}
2232
return SWIG_Py_Void();
2233
}
2234
}
2235
2236
/* Create a new pointer object */
2237
2238
SWIGRUNTIME PyObject *
2239
SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2240
if (!ptr) {
2241
return SWIG_Py_Void();
2242
} else {
2243
int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2244
PyObject *robj = PySwigObject_New(ptr, type, own);
2245
PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2246
if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2247
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2248
if (inst) {
2249
Py_DECREF(robj);
2250
robj = inst;
2251
}
2252
}
2253
return robj;
2254
}
2255
}
2256
2257
/* Create a new packed object */
2258
2259
SWIGRUNTIMEINLINE PyObject *
2260
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2261
return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2262
}
2263
2264
/* -----------------------------------------------------------------------------*
2265
* Get type list
2266
* -----------------------------------------------------------------------------*/
2267
2268
#ifdef SWIG_LINK_RUNTIME
2269
void *SWIG_ReturnGlobalTypeList(void *);
2270
#endif
2271
2272
SWIGRUNTIME swig_module_info *
2273
SWIG_Python_GetModule(void) {
2274
static void *type_pointer = (void *)0;
2275
/* first check if module already created */
2276
if (!type_pointer) {
2277
#ifdef SWIG_LINK_RUNTIME
2278
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2279
#else
2280
type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2281
(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2282
if (PyErr_Occurred()) {
2283
PyErr_Clear();
2284
type_pointer = (void *)0;
2285
}
2286
#endif
2287
}
2288
return (swig_module_info *) type_pointer;
2289
}
2290
2291
#if PY_MAJOR_VERSION < 2
2292
/* PyModule_AddObject function was introduced in Python 2.0. The following function
2293
is copied out of Python/modsupport.c in python version 2.3.4 */
2294
SWIGINTERN int
2295
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2296
{
2297
PyObject *dict;
2298
if (!PyModule_Check(m)) {
2299
PyErr_SetString(PyExc_TypeError,
2300
"PyModule_AddObject() needs module as first arg");
2301
return SWIG_ERROR;
2302
}
2303
if (!o) {
2304
PyErr_SetString(PyExc_TypeError,
2305
"PyModule_AddObject() needs non-NULL value");
2306
return SWIG_ERROR;
2307
}
2308
2309
dict = PyModule_GetDict(m);
2310
if (dict == NULL) {
2311
/* Internal error -- modules must have a dict! */
2312
PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2313
PyModule_GetName(m));
2314
return SWIG_ERROR;
2315
}
2316
if (PyDict_SetItemString(dict, name, o))
2317
return SWIG_ERROR;
2318
Py_DECREF(o);
2319
return SWIG_OK;
2320
}
2321
#endif
2322
2323
SWIGRUNTIME void
2324
SWIG_Python_DestroyModule(void *vptr)
2325
{
2326
swig_module_info *swig_module = (swig_module_info *) vptr;
2327
swig_type_info **types = swig_module->types;
2328
size_t i;
2329
for (i =0; i < swig_module->size; ++i) {
2330
swig_type_info *ty = types[i];
2331
if (ty->owndata) {
2332
PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2333
if (data) PySwigClientData_Del(data);
2334
}
2335
}
2336
Py_DECREF(SWIG_This());
2337
}
2338
2339
SWIGRUNTIME void
2340
SWIG_Python_SetModule(swig_module_info *swig_module) {
2341
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2342
2343
PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2344
swig_empty_runtime_method_table);
2345
PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2346
if (pointer && module) {
2347
PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2348
} else {
2349
Py_XDECREF(pointer);
2350
}
2351
}
2352
2353
/* The python cached type query */
2354
SWIGRUNTIME PyObject *
2355
SWIG_Python_TypeCache(void) {
2356
static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2357
return cache;
2358
}
2359
2360
SWIGRUNTIME swig_type_info *
2361
SWIG_Python_TypeQuery(const char *type)
2362
{
2363
PyObject *cache = SWIG_Python_TypeCache();
2364
PyObject *key = PyString_FromString(type);
2365
PyObject *obj = PyDict_GetItem(cache, key);
2366
swig_type_info *descriptor;
2367
if (obj) {
2368
descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2369
} else {
2370
swig_module_info *swig_module = SWIG_Python_GetModule();
2371
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2372
if (descriptor) {
2373
obj = PyCObject_FromVoidPtr(descriptor, NULL);
2374
PyDict_SetItem(cache, key, obj);
2375
Py_DECREF(obj);
2376
}
2377
}
2378
Py_DECREF(key);
2379
return descriptor;
2380
}
2381
2382
/*
2383
For backward compatibility only
2384
*/
2385
#define SWIG_POINTER_EXCEPTION 0
2386
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2387
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2388
2389
SWIGRUNTIME int
2390
SWIG_Python_AddErrMesg(const char* mesg, int infront)
2391
{
2392
if (PyErr_Occurred()) {
2393
PyObject *type = 0;
2394
PyObject *value = 0;
2395
PyObject *traceback = 0;
2396
PyErr_Fetch(&type, &value, &traceback);
2397
if (value) {
2398
PyObject *old_str = PyObject_Str(value);
2399
Py_XINCREF(type);
2400
PyErr_Clear();
2401
if (infront) {
2402
PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2403
} else {
2404
PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2405
}
2406
Py_DECREF(old_str);
2407
}
2408
return 1;
2409
} else {
2410
return 0;
2411
}
2412
}
2413
2414
SWIGRUNTIME int
2415
SWIG_Python_ArgFail(int argnum)
2416
{
2417
if (PyErr_Occurred()) {
2418
/* add information about failing argument */
2419
char mesg[256];
2420
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2421
return SWIG_Python_AddErrMesg(mesg, 1);
2422
} else {
2423
return 0;
2424
}
2425
}
2426
2427
SWIGRUNTIMEINLINE const char *
2428
PySwigObject_GetDesc(PyObject *self)
2429
{
2430
PySwigObject *v = (PySwigObject *)self;
2431
swig_type_info *ty = v ? v->ty : 0;
2432
return ty ? ty->str : (char*)"";
2433
}
2434
2435
SWIGRUNTIME void
2436
SWIG_Python_TypeError(const char *type, PyObject *obj)
2437
{
2438
if (type) {
2439
#if defined(SWIG_COBJECT_TYPES)
2440
if (obj && PySwigObject_Check(obj)) {
2441
const char *otype = (const char *) PySwigObject_GetDesc(obj);
2442
if (otype) {
2443
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2444
type, otype);
2445
return;
2446
}
2447
} else
2448
#endif
2449
{
2450
const char *otype = (obj ? obj->ob_type->tp_name : 0);
2451
if (otype) {
2452
PyObject *str = PyObject_Str(obj);
2453
const char *cstr = str ? PyString_AsString(str) : 0;
2454
if (cstr) {
2455
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2456
type, otype, cstr);
2457
} else {
2458
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2459
type, otype);
2460
}
2461
Py_XDECREF(str);
2462
return;
2463
}
2464
}
2465
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2466
} else {
2467
PyErr_Format(PyExc_TypeError, "unexpected type is received");
2468
}
2469
}
2470
2471
2472
/* Convert a pointer value, signal an exception on a type mismatch */
2473
SWIGRUNTIME void *
2474
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2475
void *result;
2476
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2477
PyErr_Clear();
2478
if (flags & SWIG_POINTER_EXCEPTION) {
2479
SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2480
SWIG_Python_ArgFail(argnum);
2481
}
2482
}
2483
return result;
2484
}
2485
2486
2487
#ifdef __cplusplus
2488
#if 0
2489
{ /* cc-mode */
2490
#endif
2491
}
2492
#endif
2493
2494
2495
2496
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2497
2498
#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2499
2500
2501
2502
#define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
2503
2504
2505
/* -------- TYPES TABLE (BEGIN) -------- */
2506
2507
#define SWIGTYPE_p_Antecedent swig_types[0]
2508
#define SWIGTYPE_p_ArchimedeanCopula swig_types[1]
2509
#define SWIGTYPE_p_BoolCollection swig_types[2]
2510
#define SWIGTYPE_p_BoolPersistentCollection swig_types[3]
2511
#define SWIGTYPE_p_BoundingBox swig_types[4]
2512
#define SWIGTYPE_p_CacheImplementation swig_types[5]
2513
#define SWIGTYPE_p_CacheKeyType swig_types[6]
2514
#define SWIGTYPE_p_CacheType swig_types[7]
2515
#define SWIGTYPE_p_CacheValueType swig_types[8]
2516
#define SWIGTYPE_p_Coefficients swig_types[9]
2517
#define SWIGTYPE_p_ComparisonOperator swig_types[10]
2518
#define SWIGTYPE_p_ConfidenceIntervalCollection swig_types[11]
2519
#define SWIGTYPE_p_ConfidenceIntervalPersistentCollection swig_types[12]
2520
#define SWIGTYPE_p_Copula swig_types[13]
2521
#define SWIGTYPE_p_CopulaCollection swig_types[14]
2522
#define SWIGTYPE_p_CopulaImplementation swig_types[15]
2523
#define SWIGTYPE_p_CopulaPersistentCollection swig_types[16]
2524
#define SWIGTYPE_p_CorrelationMatrix swig_types[17]
2525
#define SWIGTYPE_p_CovarianceMatrix swig_types[18]
2526
#define SWIGTYPE_p_Description swig_types[19]
2527
#define SWIGTYPE_p_DirectoryList swig_types[20]
2528
#define SWIGTYPE_p_DiscreteDistribution swig_types[21]
2529
#define SWIGTYPE_p_Distribution swig_types[22]
2530
#define SWIGTYPE_p_DistributionCollection swig_types[23]
2531
#define SWIGTYPE_p_DistributionFactory swig_types[24]
2532
#define SWIGTYPE_p_DistributionFactoryCollection swig_types[25]
2533
#define SWIGTYPE_p_DistributionImplementation swig_types[26]
2534
#define SWIGTYPE_p_DistributionImplementationFactory swig_types[27]
2535
#define SWIGTYPE_p_DistributionPersistentCollection swig_types[28]
2536
#define SWIGTYPE_p_DrawableCollection swig_types[29]
2537
#define SWIGTYPE_p_DrawablePersistentCollection swig_types[30]
2538
#define SWIGTYPE_p_ElementType swig_types[31]
2539
#define SWIGTYPE_p_EllipticalDistribution swig_types[32]
2540
#define SWIGTYPE_p_EvaluationImplementation swig_types[33]
2541
#define SWIGTYPE_p_Factory swig_types[34]
2542
#define SWIGTYPE_p_FileListType swig_types[35]
2543
#define SWIGTYPE_p_FileNotFoundException swig_types[36]
2544
#define SWIGTYPE_p_Format swig_types[37]
2545
#define SWIGTYPE_p_FunctionalChaosResult swig_types[38]
2546
#define SWIGTYPE_p_GradientImplementation swig_types[39]
2547
#define SWIGTYPE_p_Graph swig_types[40]
2548
#define SWIGTYPE_p_GraphCollection swig_types[41]
2549
#define SWIGTYPE_p_HessianImplementation swig_types[42]
2550
#define SWIGTYPE_p_IdentityMatrix swig_types[43]
2551
#define SWIGTYPE_p_Implementation swig_types[44]
2552
#define SWIGTYPE_p_ImplementationAsPersistentObject swig_types[45]
2553
#define SWIGTYPE_p_ImplementationElementType swig_types[46]
2554
#define SWIGTYPE_p_ImplementationType swig_types[47]
2555
#define SWIGTYPE_p_Indices swig_types[48]
2556
#define SWIGTYPE_p_InternalException swig_types[49]
2557
#define SWIGTYPE_p_InternalFunction swig_types[50]
2558
#define SWIGTYPE_p_InternalGradient swig_types[51]
2559
#define SWIGTYPE_p_InternalHessian swig_types[52]
2560
#define SWIGTYPE_p_InternalType swig_types[53]
2561
#define SWIGTYPE_p_Interval swig_types[54]
2562
#define SWIGTYPE_p_InvalidArgumentException swig_types[55]
2563
#define SWIGTYPE_p_InvalidDimensionException swig_types[56]
2564
#define SWIGTYPE_p_InverseIsoProbabilisticTransformation swig_types[57]
2565
#define SWIGTYPE_p_IsoProbabilisticTransformation swig_types[58]
2566
#define SWIGTYPE_p_KeyType swig_types[59]
2567
#define SWIGTYPE_p_LabelMap swig_types[60]
2568
#define SWIGTYPE_p_LinearModel swig_types[61]
2569
#define SWIGTYPE_p_Map swig_types[62]
2570
#define SWIGTYPE_p_MapElement swig_types[63]
2571
#define SWIGTYPE_p_MappedType swig_types[64]
2572
#define SWIGTYPE_p_Matrix swig_types[65]
2573
#define SWIGTYPE_p_MersenneTwister swig_types[66]
2574
#define SWIGTYPE_p_NoWrapperFileFoundException swig_types[67]
2575
#define SWIGTYPE_p_NonEllipticalDistribution swig_types[68]
2576
#define SWIGTYPE_p_Normal swig_types[69]
2577
#define SWIGTYPE_p_NotDefinedException swig_types[70]
2578
#define SWIGTYPE_p_NotSymmetricDefinitePositiveException swig_types[71]
2579
#define SWIGTYPE_p_NumericalComplexCollection swig_types[72]
2580
#define SWIGTYPE_p_NumericalComplexPersistentCollection swig_types[73]
2581
#define SWIGTYPE_p_NumericalMathFunction swig_types[74]
2582
#define SWIGTYPE_p_NumericalMathFunctionCollection swig_types[75]
2583
#define SWIGTYPE_p_NumericalMathFunctionPersistentCollection swig_types[76]
2584
#define SWIGTYPE_p_NumericalPoint swig_types[77]
2585
#define SWIGTYPE_p_NumericalPointCollection swig_types[78]
2586
#define SWIGTYPE_p_NumericalPointWithDescription swig_types[79]
2587
#define SWIGTYPE_p_NumericalPointWithDescriptionCollection swig_types[80]
2588
#define SWIGTYPE_p_NumericalSample swig_types[81]
2589
#define SWIGTYPE_p_NumericalScalarCollection swig_types[82]
2590
#define SWIGTYPE_p_NumericalScalarPersistentCollection swig_types[83]
2591
#define SWIGTYPE_p_OT__Base__Optim__AbdoRackwitzSpecificParameters swig_types[84]
2592
#define SWIGTYPE_p_OT__Base__Optim__CobylaSpecificParameters swig_types[85]
2593
#define SWIGTYPE_p_OT__Base__Optim__NearestPointAlgorithmImplementation__Result swig_types[86]
2594
#define SWIGTYPE_p_OT__Base__Optim__NearestPointChecker__Result swig_types[87]
2595
#define SWIGTYPE_p_OT__Base__Optim__SQPSpecificParameters swig_types[88]
2596
#define SWIGTYPE_p_OT__Base__Optim__TNCSpecificParameters swig_types[89]
2597
#define SWIGTYPE_p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters swig_types[90]
2598
#define SWIGTYPE_p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult swig_types[91]
2599
#define SWIGTYPE_p_OT__Base__Stat__RandomGeneratorState swig_types[92]
2600
#define SWIGTYPE_p_OT__Uncertainty__Distribution__HistogramPair swig_types[93]
2601
#define SWIGTYPE_p_OT__Uncertainty__Distribution__UserDefinedPair swig_types[94]
2602
#define SWIGTYPE_p_OpenTURNS__Base__Common__ComparisonOperator swig_types[95]
2603
#define SWIGTYPE_p_OpenTURNS__Base__Common__ComparisonOperatorImplementation swig_types[96]
2604
#define SWIGTYPE_p_OpenTURNS__Base__Common__Equal swig_types[97]
2605
#define SWIGTYPE_p_OpenTURNS__Base__Common__Greater swig_types[98]
2606
#define SWIGTYPE_p_OpenTURNS__Base__Common__GreaterOrEqual swig_types[99]
2607
#define SWIGTYPE_p_OpenTURNS__Base__Common__InterfaceObject swig_types[100]
2608
#define SWIGTYPE_p_OpenTURNS__Base__Common__Less swig_types[101]
2609
#define SWIGTYPE_p_OpenTURNS__Base__Common__LessOrEqual swig_types[102]
2610
#define SWIGTYPE_p_OpenTURNS__Base__Common__Object swig_types[103]
2611
#define SWIGTYPE_p_OpenTURNS__Base__Common__PersistentObject swig_types[104]
2612
#define SWIGTYPE_p_OpenTURNS__Base__Common__StorageManager swig_types[105]
2613
#define SWIGTYPE_p_OpenTURNS__Base__Common__Study swig_types[106]
2614
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t swig_types[107]
2615
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t swig_types[108]
2616
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Common__ComparisonOperatorImplementation_t swig_types[109]
2617
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__NumericalMathFunctionImplementation_t swig_types[110]
2618
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__UniVariatePolynomialImplementation_t swig_types[111]
2619
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__DrawableImplementation_t swig_types[112]
2620
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__GraphImplementation_t swig_types[113]
2621
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation_t swig_types[114]
2622
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation_t swig_types[115]
2623
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Solver__SolverImplementation_t swig_types[116]
2624
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__HistoryStrategyImplementation_t swig_types[117]
2625
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation_t swig_types[118]
2626
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t swig_types[119]
2627
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t swig_types[120]
2628
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__MatrixImplementation_t swig_types[121]
2629
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__TensorImplementation_t swig_types[122]
2630
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory_t swig_types[123]
2631
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementation_t swig_types[124]
2632
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__RandomVectorImplementation_t swig_types[125]
2633
#define SWIGTYPE_p_OpenTURNS__Base__Common__XMLStorageManager swig_types[126]
2634
#define SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient swig_types[127]
2635
#define SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian swig_types[128]
2636
#define SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient swig_types[129]
2637
#define SWIGTYPE_p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation swig_types[130]
2638
#define SWIGTYPE_p_OpenTURNS__Base__Func__ComposedNumericalMathFunction swig_types[131]
2639
#define SWIGTYPE_p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation swig_types[132]
2640
#define SWIGTYPE_p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation swig_types[133]
2641
#define SWIGTYPE_p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation swig_types[134]
2642
#define SWIGTYPE_p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation swig_types[135]
2643
#define SWIGTYPE_p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation swig_types[136]
2644
#define SWIGTYPE_p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation swig_types[137]
2645
#define SWIGTYPE_p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation swig_types[138]
2646
#define SWIGTYPE_p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation swig_types[139]
2647
#define SWIGTYPE_p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation swig_types[140]
2648
#define SWIGTYPE_p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation swig_types[141]
2649
#define SWIGTYPE_p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation swig_types[142]
2650
#define SWIGTYPE_p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation swig_types[143]
2651
#define SWIGTYPE_p_OpenTURNS__Base__Func__LinearNumericalMathFunction swig_types[144]
2652
#define SWIGTYPE_p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation swig_types[145]
2653
#define SWIGTYPE_p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation swig_types[146]
2654
#define SWIGTYPE_p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation swig_types[147]
2655
#define SWIGTYPE_p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation swig_types[148]
2656
#define SWIGTYPE_p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation swig_types[149]
2657
#define SWIGTYPE_p_OpenTURNS__Base__Func__NumericalMathFunction swig_types[150]
2658
#define SWIGTYPE_p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation swig_types[151]
2659
#define SWIGTYPE_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation swig_types[152]
2660
#define SWIGTYPE_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation swig_types[153]
2661
#define SWIGTYPE_p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation swig_types[154]
2662
#define SWIGTYPE_p_OpenTURNS__Base__Func__ProductNumericalMathFunction swig_types[155]
2663
#define SWIGTYPE_p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation swig_types[156]
2664
#define SWIGTYPE_p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation swig_types[157]
2665
#define SWIGTYPE_p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation swig_types[158]
2666
#define SWIGTYPE_p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation swig_types[159]
2667
#define SWIGTYPE_p_OpenTURNS__Base__Func__UniVariatePolynomial swig_types[160]
2668
#define SWIGTYPE_p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation swig_types[161]
2669
#define SWIGTYPE_p_OpenTURNS__Base__Func__WrapperData swig_types[162]
2670
#define SWIGTYPE_p_OpenTURNS__Base__Func__WrapperDataFile swig_types[163]
2671
#define SWIGTYPE_p_OpenTURNS__Base__Func__WrapperDataVariable swig_types[164]
2672
#define SWIGTYPE_p_OpenTURNS__Base__Func__WrapperFile swig_types[165]
2673
#define SWIGTYPE_p_OpenTURNS__Base__Func__WrapperFrameworkData swig_types[166]
2674
#define SWIGTYPE_p_OpenTURNS__Base__Func__WrapperFunctionDescription swig_types[167]
2675
#define SWIGTYPE_p_OpenTURNS__Base__Func__WrapperParameter swig_types[168]
2676
#define SWIGTYPE_p_OpenTURNS__Base__Graph__BarPlot swig_types[169]
2677
#define SWIGTYPE_p_OpenTURNS__Base__Graph__Cloud swig_types[170]
2678
#define SWIGTYPE_p_OpenTURNS__Base__Graph__Contour swig_types[171]
2679
#define SWIGTYPE_p_OpenTURNS__Base__Graph__Curve swig_types[172]
2680
#define SWIGTYPE_p_OpenTURNS__Base__Graph__Drawable swig_types[173]
2681
#define SWIGTYPE_p_OpenTURNS__Base__Graph__DrawableImplementation swig_types[174]
2682
#define SWIGTYPE_p_OpenTURNS__Base__Graph__Graph swig_types[175]
2683
#define SWIGTYPE_p_OpenTURNS__Base__Graph__GraphImplementation swig_types[176]
2684
#define SWIGTYPE_p_OpenTURNS__Base__Graph__Pie swig_types[177]
2685
#define SWIGTYPE_p_OpenTURNS__Base__Graph__Staircase swig_types[178]
2686
#define SWIGTYPE_p_OpenTURNS__Base__Optim__AbdoRackwitz swig_types[179]
2687
#define SWIGTYPE_p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithm swig_types[180]
2688
#define SWIGTYPE_p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation swig_types[181]
2689
#define SWIGTYPE_p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationResult swig_types[182]
2690
#define SWIGTYPE_p_OpenTURNS__Base__Optim__Cobyla swig_types[183]
2691
#define SWIGTYPE_p_OpenTURNS__Base__Optim__NearestPointAlgorithm swig_types[184]
2692
#define SWIGTYPE_p_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation swig_types[185]
2693
#define SWIGTYPE_p_OpenTURNS__Base__Optim__NearestPointChecker swig_types[186]
2694
#define SWIGTYPE_p_OpenTURNS__Base__Optim__PenalizedLeastSquaresAlgorithm swig_types[187]
2695
#define SWIGTYPE_p_OpenTURNS__Base__Optim__SQP swig_types[188]
2696
#define SWIGTYPE_p_OpenTURNS__Base__Optim__TNC swig_types[189]
2697
#define SWIGTYPE_p_OpenTURNS__Base__Solver__Bisection swig_types[190]
2698
#define SWIGTYPE_p_OpenTURNS__Base__Solver__Brent swig_types[191]
2699
#define SWIGTYPE_p_OpenTURNS__Base__Solver__Secant swig_types[192]
2700
#define SWIGTYPE_p_OpenTURNS__Base__Solver__Solver swig_types[193]
2701
#define SWIGTYPE_p_OpenTURNS__Base__Solver__SolverImplementation swig_types[194]
2702
#define SWIGTYPE_p_OpenTURNS__Base__Stat__Compact swig_types[195]
2703
#define SWIGTYPE_p_OpenTURNS__Base__Stat__ConfidenceInterval swig_types[196]
2704
#define SWIGTYPE_p_OpenTURNS__Base__Stat__CorrelationMatrix swig_types[197]
2705
#define SWIGTYPE_p_OpenTURNS__Base__Stat__CovarianceMatrix swig_types[198]
2706
#define SWIGTYPE_p_OpenTURNS__Base__Stat__Full swig_types[199]
2707
#define SWIGTYPE_p_OpenTURNS__Base__Stat__HaltonSequence swig_types[200]
2708
#define SWIGTYPE_p_OpenTURNS__Base__Stat__HistoryStrategy swig_types[201]
2709
#define SWIGTYPE_p_OpenTURNS__Base__Stat__HistoryStrategyImplementation swig_types[202]
2710
#define SWIGTYPE_p_OpenTURNS__Base__Stat__Last swig_types[203]
2711
#define SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel swig_types[204]
2712
#define SWIGTYPE_p_OpenTURNS__Base__Stat__LowDiscrepancySequence swig_types[205]
2713
#define SWIGTYPE_p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation swig_types[206]
2714
#define SWIGTYPE_p_OpenTURNS__Base__Stat__Null swig_types[207]
2715
#define SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample swig_types[208]
2716
#define SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSampleImplementation swig_types[209]
2717
#define SWIGTYPE_p_OpenTURNS__Base__Stat__SobolSequence swig_types[210]
2718
#define SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult swig_types[211]
2719
#define SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OT__Uncertainty__Distribution__HistogramPair_t swig_types[212]
2720
#define SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t swig_types[213]
2721
#define SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__DistributionFactory_t swig_types[214]
2722
#define SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__Distribution_t swig_types[215]
2723
#define SWIGTYPE_p_OpenTURNS__Base__Type__Description swig_types[216]
2724
#define SWIGTYPE_p_OpenTURNS__Base__Type__DescriptionImplementation swig_types[217]
2725
#define SWIGTYPE_p_OpenTURNS__Base__Type__IdentityMatrix swig_types[218]
2726
#define SWIGTYPE_p_OpenTURNS__Base__Type__Indices swig_types[219]
2727
#define SWIGTYPE_p_OpenTURNS__Base__Type__Interval swig_types[220]
2728
#define SWIGTYPE_p_OpenTURNS__Base__Type__Matrix swig_types[221]
2729
#define SWIGTYPE_p_OpenTURNS__Base__Type__MatrixImplementation swig_types[222]
2730
#define SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPoint swig_types[223]
2731
#define SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPointWithDescription swig_types[224]
2732
#define SWIGTYPE_p_OpenTURNS__Base__Type__PersistentCollectionT_OT__Uncertainty__Distribution__UserDefinedPair_t swig_types[225]
2733
#define SWIGTYPE_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_t swig_types[226]
2734
#define SWIGTYPE_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_t swig_types[227]
2735
#define SWIGTYPE_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_t swig_types[228]
2736
#define SWIGTYPE_p_OpenTURNS__Base__Type__PersistentCollectionT_double_t swig_types[229]
2737
#define SWIGTYPE_p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_t swig_types[230]
2738
#define SWIGTYPE_p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_t swig_types[231]
2739
#define SWIGTYPE_p_OpenTURNS__Base__Type__SquareMatrix swig_types[232]
2740
#define SWIGTYPE_p_OpenTURNS__Base__Type__SymmetricMatrix swig_types[233]
2741
#define SWIGTYPE_p_OpenTURNS__Base__Type__SymmetricTensor swig_types[234]
2742
#define SWIGTYPE_p_OpenTURNS__Base__Type__Tensor swig_types[235]
2743
#define SWIGTYPE_p_OpenTURNS__Base__Type__TensorImplementation swig_types[236]
2744
#define SWIGTYPE_p_OpenTURNS__PointInSourceFile swig_types[237]
2745
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Beta swig_types[238]
2746
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__BetaFactory swig_types[239]
2747
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__ChiSquare swig_types[240]
2748
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__ChiSquareFactory swig_types[241]
2749
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__ClaytonCopula swig_types[242]
2750
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaFactory swig_types[243]
2751
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__ComposedCopula swig_types[244]
2752
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__ComposedDistribution swig_types[245]
2753
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Epanechnikov swig_types[246]
2754
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Exponential swig_types[247]
2755
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__ExponentialFactory swig_types[248]
2756
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__FrankCopula swig_types[249]
2757
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__FrankCopulaFactory swig_types[250]
2758
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Gamma swig_types[251]
2759
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__GammaFactory swig_types[252]
2760
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Geometric swig_types[253]
2761
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__GeometricFactory swig_types[254]
2762
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Gumbel swig_types[255]
2763
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__GumbelCopula swig_types[256]
2764
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaFactory swig_types[257]
2765
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__GumbelFactory swig_types[258]
2766
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Histogram swig_types[259]
2767
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__HistogramFactory swig_types[260]
2768
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__IndependentCopula swig_types[261]
2769
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__KernelMixture swig_types[262]
2770
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__KernelSmoothing swig_types[263]
2771
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Laplace swig_types[264]
2772
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__LaplaceFactory swig_types[265]
2773
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__LogNormal swig_types[266]
2774
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__LogNormalFactory swig_types[267]
2775
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Logistic swig_types[268]
2776
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__LogisticFactory swig_types[269]
2777
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Mixture swig_types[270]
2778
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__MultiNomial swig_types[271]
2779
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__MultiNomialFactory swig_types[272]
2780
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__NonCentralStudent swig_types[273]
2781
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Normal swig_types[274]
2782
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__NormalCopula swig_types[275]
2783
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__NormalCopulaFactory swig_types[276]
2784
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__NormalFactory swig_types[277]
2785
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Poisson swig_types[278]
2786
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__PoissonFactory swig_types[279]
2787
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__RandomMixture swig_types[280]
2788
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Rayleigh swig_types[281]
2789
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__RayleighFactory swig_types[282]
2790
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Student swig_types[283]
2791
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__StudentFactory swig_types[284]
2792
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Triangular swig_types[285]
2793
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__TriangularFactory swig_types[286]
2794
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__TruncatedDistribution swig_types[287]
2795
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__TruncatedNormal swig_types[288]
2796
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalFactory swig_types[289]
2797
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Uniform swig_types[290]
2798
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__UniformFactory swig_types[291]
2799
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__UserDefined swig_types[292]
2800
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__UserDefinedFactory swig_types[293]
2801
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__Weibull swig_types[294]
2802
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Distribution__WeibullFactory swig_types[295]
2803
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__ArchimedeanCopula swig_types[296]
2804
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__CompositeRandomVector swig_types[297]
2805
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__ConditionalRandomVector swig_types[298]
2806
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__ConstantRandomVector swig_types[299]
2807
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__ContinuousDistribution swig_types[300]
2808
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Copula swig_types[301]
2809
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__CopulaImplementation swig_types[302]
2810
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__DiscreteDistribution swig_types[303]
2811
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution swig_types[304]
2812
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__DistributionFactory swig_types[305]
2813
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__DistributionImplementation swig_types[306]
2814
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory swig_types[307]
2815
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__EllipticalDistribution swig_types[308]
2816
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Event swig_types[309]
2817
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__EventRandomVectorImplementation swig_types[310]
2818
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__NonEllipticalDistribution swig_types[311]
2819
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__RandomVector swig_types[312]
2820
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__RandomVectorImplementation swig_types[313]
2821
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__SklarCopula swig_types[314]
2822
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__StandardEvent swig_types[315]
2823
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__UsualDistribution swig_types[316]
2824
#define SWIGTYPE_p_OpenTURNS__Uncertainty__Model__UsualRandomVector swig_types[317]
2825
#define SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__FittingTest swig_types[318]
2826
#define SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__HypothesisTest swig_types[319]
2827
#define SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__LinearModelTest swig_types[320]
2828
#define SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__NormalityTest swig_types[321]
2829
#define SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__VisualTest swig_types[322]
2830
#define SWIGTYPE_p_OptimizationProblem swig_types[323]
2831
#define SWIGTYPE_p_OutOfBoundException swig_types[324]
2832
#define SWIGTYPE_p_Pair swig_types[325]
2833
#define SWIGTYPE_p_PairCollection swig_types[326]
2834
#define SWIGTYPE_p_PersistentObject swig_types[327]
2835
#define SWIGTYPE_p_PolynomialCollection swig_types[328]
2836
#define SWIGTYPE_p_PolynomialPersistentCollection swig_types[329]
2837
#define SWIGTYPE_p_Result swig_types[330]
2838
#define SWIGTYPE_p_Severity swig_types[331]
2839
#define SWIGTYPE_p_SobolIndiceParameters swig_types[332]
2840
#define SWIGTYPE_p_SobolIndiceResult swig_types[333]
2841
#define SWIGTYPE_p_SpecificParameters swig_types[334]
2842
#define SWIGTYPE_p_SquareMatrix swig_types[335]
2843
#define SWIGTYPE_p_State swig_types[336]
2844
#define SWIGTYPE_p_StorageManager swig_types[337]
2845
#define SWIGTYPE_p_StorageManagerImplementation swig_types[338]
2846
#define SWIGTYPE_p_SymmetricMatrix swig_types[339]
2847
#define SWIGTYPE_p_SymmetricTensor swig_types[340]
2848
#define SWIGTYPE_p_Tensor swig_types[341]
2849
#define SWIGTYPE_p_TestResult swig_types[342]
2850
#define SWIGTYPE_p_TestResultCollection swig_types[343]
2851
#define SWIGTYPE_p_UnsignedLongCollection swig_types[344]
2852
#define SWIGTYPE_p_Value swig_types[345]
2853
#define SWIGTYPE_p_ValueType swig_types[346]
2854
#define SWIGTYPE_p_VariableListType swig_types[347]
2855
#define SWIGTYPE_p_WrapperFileParsingException swig_types[348]
2856
#define SWIGTYPE_p_WrapperInternalException swig_types[349]
2857
#define SWIGTYPE_p_allocator_type swig_types[350]
2858
#define SWIGTYPE_p_bool swig_types[351]
2859
#define SWIGTYPE_p_char swig_types[352]
2860
#define SWIGTYPE_p_const_iterator swig_types[353]
2861
#define SWIGTYPE_p_const_reverse_iterator swig_types[354]
2862
#define SWIGTYPE_p_difference_type swig_types[355]
2863
#define SWIGTYPE_p_double swig_types[356]
2864
#define SWIGTYPE_p_iterator swig_types[357]
2865
#define SWIGTYPE_p_key_type swig_types[358]
2866
#define SWIGTYPE_p_long swig_types[359]
2867
#define SWIGTYPE_p_mapped_type swig_types[360]
2868
#define SWIGTYPE_p_pointer_type swig_types[361]
2869
#define SWIGTYPE_p_reverse_iterator swig_types[362]
2870
#define SWIGTYPE_p_size_type swig_types[363]
2871
#define SWIGTYPE_p_std__complexT_double_t swig_types[364]
2872
#define SWIGTYPE_p_std__invalid_argument swig_types[365]
2873
#define SWIGTYPE_p_std__string swig_types[366]
2874
#define SWIGTYPE_p_swig__PySwigIterator swig_types[367]
2875
#define SWIGTYPE_p_unsigned_long swig_types[368]
2876
#define SWIGTYPE_p_value_type swig_types[369]
2877
#define SWIGTYPE_p_xNumericalSample swig_types[370]
2878
static swig_type_info *swig_types[372];
2879
static swig_module_info swig_module = {swig_types, 371, 0, 0, 0, 0};
2880
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2881
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2882
2883
/* -------- TYPES TABLE (END) -------- */
2884
2885
#if (PY_VERSION_HEX <= 0x02000000)
2886
# if !defined(SWIG_PYTHON_CLASSIC)
2887
# error "This python version requires swig to be run with the '-classic' option"
2888
# endif
2889
#endif
2890
2891
/*-----------------------------------------------
2892
@(target):= _stattests.so
2893
------------------------------------------------*/
2894
#define SWIG_init init_stattests
2895
2896
#define SWIG_name "_stattests"
2897
2898
#define SWIGVERSION 0x010336
2899
#define SWIG_VERSION SWIGVERSION
2900
2901
2902
#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2903
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2904
2905
2906
#include <stdexcept>
2907
2908
2909
namespace swig {
2910
class PyObject_ptr {
2911
protected:
2912
PyObject *_obj;
2913
2914
public:
2915
PyObject_ptr() :_obj(0)
2916
{
2917
}
2918
2919
PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2920
{
2921
Py_XINCREF(_obj);
2922
}
2923
2924
PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2925
{
2926
if (initial_ref) {
2927
Py_XINCREF(_obj);
2928
}
2929
}
2930
2931
PyObject_ptr & operator=(const PyObject_ptr& item)
2932
{
2933
Py_XINCREF(item._obj);
2934
Py_XDECREF(_obj);
2935
_obj = item._obj;
2936
return *this;
2937
}
2938
2939
~PyObject_ptr()
2940
{
2941
Py_XDECREF(_obj);
2942
}
2943
2944
operator PyObject *() const
2945
{
2946
return _obj;
2947
}
2948
2949
PyObject *operator->() const
2950
{
2951
return _obj;
2952
}
2953
};
2954
}
2955
2956
2957
namespace swig {
2958
struct PyObject_var : PyObject_ptr {
2959
PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2960
2961
PyObject_var & operator = (PyObject* obj)
2962
{
2963
Py_XDECREF(_obj);
2964
_obj = obj;
2965
return *this;
2966
}
2967
};
2968
}
2969
2970
2971
#include "OTBase.hxx"
2972
#include "OTModel.hxx"
2973
#include "OTDistribution.hxx"
2974
#include "OTStatTests.hxx"
2975
2976
2977
#include <string>
2978
2979
2980
#include <stdexcept>
2981
2982
2983
#if defined(__GNUC__)
2984
# if __GNUC__ == 2 && __GNUC_MINOR <= 96
2985
# define SWIG_STD_NOMODERN_STL
2986
# endif
2987
#endif
2988
2989
2990
#include <string>
2991
#include <stdexcept>
2992
2993
2994
#include <utility>
2995
2996
2997
#include <iostream>
2998
2999
3000
namespace swig {
3001
struct stop_iteration {
3002
};
3003
3004
struct PySwigIterator {
3005
private:
3006
PyObject_ptr _seq;
3007
3008
protected:
3009
PySwigIterator(PyObject *seq) : _seq(seq)
3010
{
3011
}
3012
3013
public:
3014
virtual ~PySwigIterator() {}
3015
3016
// Access iterator method, required by Python
3017
virtual PyObject *value() const = 0;
3018
3019
// Forward iterator method, required by Python
3020
virtual PySwigIterator *incr(size_t n = 1) = 0;
3021
3022
// Backward iterator method, very common in C++, but not required in Python
3023
virtual PySwigIterator *decr(size_t /*n*/ = 1)
3024
{
3025
throw stop_iteration();
3026
}
3027
3028
// Random access iterator methods, but not required in Python
3029
virtual ptrdiff_t distance(const PySwigIterator &/*x*/) const
3030
{
3031
throw std::invalid_argument("operation not supported");
3032
}
3033
3034
virtual bool equal (const PySwigIterator &/*x*/) const
3035
{
3036
throw std::invalid_argument("operation not supported");
3037
}
3038
3039
// C++ common/needed methods
3040
virtual PySwigIterator *copy() const = 0;
3041
3042
PyObject *next()
3043
{
3044
SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
3045
PyObject *obj = value();
3046
incr();
3047
SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
3048
return obj;
3049
}
3050
3051
PyObject *previous()
3052
{
3053
SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
3054
decr();
3055
PyObject *obj = value();
3056
SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
3057
return obj;
3058
}
3059
3060
PySwigIterator *advance(ptrdiff_t n)
3061
{
3062
return (n > 0) ? incr(n) : decr(-n);
3063
}
3064
3065
bool operator == (const PySwigIterator& x) const
3066
{
3067
return equal(x);
3068
}
3069
3070
bool operator != (const PySwigIterator& x) const
3071
{
3072
return ! operator==(x);
3073
}
3074
3075
PySwigIterator& operator += (ptrdiff_t n)
3076
{
3077
return *advance(n);
3078
}
3079
3080
PySwigIterator& operator -= (ptrdiff_t n)
3081
{
3082
return *advance(-n);
3083
}
3084
3085
PySwigIterator* operator + (ptrdiff_t n) const
3086
{
3087
return copy()->advance(n);
3088
}
3089
3090
PySwigIterator* operator - (ptrdiff_t n) const
3091
{
3092
return copy()->advance(-n);
3093
}
3094
3095
ptrdiff_t operator - (const PySwigIterator& x) const
3096
{
3097
return x.distance(*this);
3098
}
3099
3100
static swig_type_info* descriptor() {
3101
static int init = 0;
3102
static swig_type_info* desc = 0;
3103
if (!init) {
3104
desc = SWIG_TypeQuery("swig::PySwigIterator *");
3105
init = 1;
3106
}
3107
return desc;
3108
}
3109
};
3110
}
3111
3112
3113
SWIGINTERN int
3114
SWIG_AsVal_double (PyObject *obj, double *val)
3115
{
3116
int res = SWIG_TypeError;
3117
if (PyFloat_Check(obj)) {
3118
if (val) *val = PyFloat_AsDouble(obj);
3119
return SWIG_OK;
3120
} else if (PyInt_Check(obj)) {
3121
if (val) *val = PyInt_AsLong(obj);
3122
return SWIG_OK;
3123
} else if (PyLong_Check(obj)) {
3124
double v = PyLong_AsDouble(obj);
3125
if (!PyErr_Occurred()) {
3126
if (val) *val = v;
3127
return SWIG_OK;
3128
} else {
3129
PyErr_Clear();
3130
}
3131
}
3132
#ifdef SWIG_PYTHON_CAST_MODE
3133
{
3134
int dispatch = 0;
3135
double d = PyFloat_AsDouble(obj);
3136
if (!PyErr_Occurred()) {
3137
if (val) *val = d;
3138
return SWIG_AddCast(SWIG_OK);
3139
} else {
3140
PyErr_Clear();
3141
}
3142
if (!dispatch) {
3143
long v = PyLong_AsLong(obj);
3144
if (!PyErr_Occurred()) {
3145
if (val) *val = v;
3146
return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3147
} else {
3148
PyErr_Clear();
3149
}
3150
}
3151
}
3152
#endif
3153
return res;
3154
}
3155
3156
3157
#include <float.h>
3158
3159
3160
#include <math.h>
3161
3162
3163
SWIGINTERNINLINE int
3164
SWIG_CanCastAsInteger(double *d, double min, double max) {
3165
double x = *d;
3166
if ((min <= x && x <= max)) {
3167
double fx = floor(x);
3168
double cx = ceil(x);
3169
double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3170
if ((errno == EDOM) || (errno == ERANGE)) {
3171
errno = 0;
3172
} else {
3173
double summ, reps, diff;
3174
if (rd < x) {
3175
diff = x - rd;
3176
} else if (rd > x) {
3177
diff = rd - x;
3178
} else {
3179
return 1;
3180
}
3181
summ = rd + x;
3182
reps = diff/summ;
3183
if (reps < 8*DBL_EPSILON) {
3184
*d = rd;
3185
return 1;
3186
}
3187
}
3188
}
3189
return 0;
3190
}
3191
3192
3193
SWIGINTERN int
3194
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3195
{
3196
if (PyInt_Check(obj)) {
3197
long v = PyInt_AsLong(obj);
3198
if (v >= 0) {
3199
if (val) *val = v;
3200
return SWIG_OK;
3201
} else {
3202
return SWIG_OverflowError;
3203
}
3204
} else if (PyLong_Check(obj)) {
3205
unsigned long v = PyLong_AsUnsignedLong(obj);
3206
if (!PyErr_Occurred()) {
3207
if (val) *val = v;
3208
return SWIG_OK;
3209
} else {
3210
PyErr_Clear();
3211
}
3212
}
3213
#ifdef SWIG_PYTHON_CAST_MODE
3214
{
3215
int dispatch = 0;
3216
unsigned long v = PyLong_AsUnsignedLong(obj);
3217
if (!PyErr_Occurred()) {
3218
if (val) *val = v;
3219
return SWIG_AddCast(SWIG_OK);
3220
} else {
3221
PyErr_Clear();
3222
}
3223
if (!dispatch) {
3224
double d;
3225
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3226
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3227
if (val) *val = (unsigned long)(d);
3228
return res;
3229
}
3230
}
3231
}
3232
#endif
3233
return SWIG_TypeError;
3234
}
3235
3236
3237
SWIGINTERNINLINE int
3238
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3239
{
3240
unsigned long v;
3241
int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3242
if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3243
return res;
3244
}
3245
3246
3247
#define SWIG_From_long PyInt_FromLong
3248
3249
3250
SWIGINTERNINLINE PyObject *
3251
SWIG_From_ptrdiff_t (ptrdiff_t value)
3252
{
3253
return SWIG_From_long (static_cast< long >(value));
3254
}
3255
3256
3257
SWIGINTERNINLINE PyObject*
3258
SWIG_From_bool (bool value)
3259
{
3260
return PyBool_FromLong(value ? 1 : 0);
3261
}
3262
3263
3264
SWIGINTERN int
3265
SWIG_AsVal_long (PyObject *obj, long* val)
3266
{
3267
if (PyInt_Check(obj)) {
3268
if (val) *val = PyInt_AsLong(obj);
3269
return SWIG_OK;
3270
} else if (PyLong_Check(obj)) {
3271
long v = PyLong_AsLong(obj);
3272
if (!PyErr_Occurred()) {
3273
if (val) *val = v;
3274
return SWIG_OK;
3275
} else {
3276
PyErr_Clear();
3277
}
3278
}
3279
#ifdef SWIG_PYTHON_CAST_MODE
3280
{
3281
int dispatch = 0;
3282
long v = PyInt_AsLong(obj);
3283
if (!PyErr_Occurred()) {
3284
if (val) *val = v;
3285
return SWIG_AddCast(SWIG_OK);
3286
} else {
3287
PyErr_Clear();
3288
}
3289
if (!dispatch) {
3290
double d;
3291
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3292
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3293
if (val) *val = (long)(d);
3294
return res;
3295
}
3296
}
3297
}
3298
#endif
3299
return SWIG_TypeError;
3300
}
3301
3302
3303
SWIGINTERNINLINE int
3304
SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
3305
{
3306
long v;
3307
int res = SWIG_AsVal_long (obj, val ? &v : 0);
3308
if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
3309
return res;
3310
}
3311
3312
3313
#include <stdexcept>
3314
3315
3316
#include <algorithm>
3317
3318
3319
#include <map>
3320
#include <algorithm>
3321
#include <stdexcept>
3322
3323
3324
#include <complex>
3325
3326
3327
#include "OT.hxx"
3328
#include "PythonWrappingFunctions.hxx"
3329
3330
3331
namespace OpenTURNS {
3332
3333
3334
3335
template <>
3336
struct traitsPythonType<OpenTURNS::Base::Type::NumericalPoint>
3337
{
3338
typedef _PySequence_ Type;
3339
};
3340
3341
template <>
3342
inline
3343
OpenTURNS::Base::Type::NumericalPoint
3344
convert<_PySequence_,OpenTURNS::Base::Type::NumericalPoint>(PyObject * pyObj)
3345
{
3346
OpenTURNS::Base::Common::Pointer<OpenTURNS::Base::Type::Collection<OpenTURNS::NumericalScalar> > ptr = buildCollectionFromPySequence<OpenTURNS::NumericalScalar>( pyObj );
3347
return OpenTURNS::Base::Type::NumericalPoint( *ptr );
3348
}
3349
3350
3351
3352
template <>
3353
struct traitsPythonType<OpenTURNS::Base::Type::Indices>
3354
{
3355
typedef _PySequence_ Type;
3356
};
3357
3358
template <>
3359
inline
3360
OpenTURNS::Base::Type::Indices
3361
convert<_PySequence_,OpenTURNS::Base::Type::Indices>(PyObject * pyObj)
3362
{
3363
OpenTURNS::Base::Common::Pointer<OpenTURNS::Base::Type::Collection<OpenTURNS::UnsignedLong> > ptr = buildCollectionFromPySequence<OpenTURNS::UnsignedLong>( pyObj );
3364
return OpenTURNS::Base::Type::Indices( ptr->begin(), ptr->end() );
3365
}
3366
3367
3368
3369
3370
template <>
3371
struct traitsPythonType<OpenTURNS::Base::Func::WrapperDataFile>
3372
{
3373
typedef _PySequence_ Type;
3374
};
3375
3376
template <>
3377
inline
3378
OpenTURNS::Base::Func::WrapperDataFile
3379
convert<_PySequence_,OpenTURNS::Base::Func::WrapperDataFile>(PyObject * pyObj)
3380
{
3381
return OpenTURNS::Base::Func::WrapperDataFile();
3382
}
3383
3384
3385
3386
template <>
3387
struct traitsPythonType<OpenTURNS::Base::Func::WrapperDataVariable>
3388
{
3389
typedef _PySequence_ Type;
3390
};
3391
3392
template <>
3393
inline
3394
OpenTURNS::Base::Func::WrapperDataVariable
3395
convert<_PySequence_,OpenTURNS::Base::Func::WrapperDataVariable>(PyObject * pyObj)
3396
{
3397
return OpenTURNS::Base::Func::WrapperDataVariable();
3398
}
3399
3400
3401
} /* namespace OpenTURNS */
3402
3403
3404
3405
#include "Exception.hxx"
3406
3407
3408
#include <vector>
3409
3410
3411
namespace swig {
3412
template <class Type>
3413
struct noconst_traits {
3414
typedef Type noconst_type;
3415
};
3416
3417
template <class Type>
3418
struct noconst_traits<const Type> {
3419
typedef Type noconst_type;
3420
};
3421
3422
/*
3423
type categories
3424
*/
3425
struct pointer_category { };
3426
struct value_category { };
3427
3428
/*
3429
General traits that provides type_name and type_info
3430
*/
3431
template <class Type> struct traits { };
3432
3433
template <class Type>
3434
inline const char* type_name() {
3435
return traits<typename noconst_traits<Type >::noconst_type >::type_name();
3436
}
3437
3438
template <class Type>
3439
struct traits_info {
3440
static swig_type_info *type_query(std::string name) {
3441
name += " *";
3442
return SWIG_TypeQuery(name.c_str());
3443
}
3444
static swig_type_info *type_info() {
3445
static swig_type_info *info = type_query(type_name<Type>());
3446
return info;
3447
}
3448
};
3449
3450
template <class Type>
3451
inline swig_type_info *type_info() {
3452
return traits_info<Type>::type_info();
3453
}
3454
3455
/*
3456
Partial specialization for pointers
3457
*/
3458
template <class Type> struct traits <Type *> {
3459
typedef pointer_category category;
3460
static std::string make_ptr_name(const char* name) {
3461
std::string ptrname = name;
3462
ptrname += " *";
3463
return ptrname;
3464
}
3465
static const char* type_name() {
3466
static std::string name = make_ptr_name(swig::type_name<Type>());
3467
return name.c_str();
3468
}
3469
};
3470
3471
template <class Type, class Category>
3472
struct traits_as { };
3473
3474
template <class Type, class Category>
3475
struct traits_check { };
3476
3477
}
3478
3479
3480
namespace swig {
3481
/*
3482
Traits that provides the from method
3483
*/
3484
template <class Type> struct traits_from_ptr {
3485
static PyObject *from(Type *val, int owner = 0) {
3486
return SWIG_NewPointerObj(val, type_info<Type>(), owner);
3487
}
3488
};
3489
3490
template <class Type> struct traits_from {
3491
static PyObject *from(const Type& val) {
3492
return traits_from_ptr<Type>::from(new Type(val), 1);
3493
}
3494
};
3495
3496
template <class Type> struct traits_from<Type *> {
3497
static PyObject *from(Type* val) {
3498
return traits_from_ptr<Type>::from(val, 0);
3499
}
3500
};
3501
3502
template <class Type> struct traits_from<const Type *> {
3503
static PyObject *from(const Type* val) {
3504
return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
3505
}
3506
};
3507
3508
3509
template <class Type>
3510
inline PyObject *from(const Type& val) {
3511
return traits_from<Type>::from(val);
3512
}
3513
3514
template <class Type>
3515
inline PyObject *from_ptr(Type* val, int owner) {
3516
return traits_from_ptr<Type>::from(val, owner);
3517
}
3518
3519
/*
3520
Traits that provides the asval/as/check method
3521
*/
3522
template <class Type>
3523
struct traits_asptr {
3524
static int asptr(PyObject *obj, Type **val) {
3525
Type *p;
3526
int res = (SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0) == SWIG_OK) ? SWIG_OLDOBJ : 0;
3527
if (SWIG_IsOK(res)) {
3528
if (val) *val = p;
3529
}
3530
return res;
3531
}
3532
};
3533
3534
template <class Type>
3535
inline int asptr(PyObject *obj, Type **vptr) {
3536
return traits_asptr<Type>::asptr(obj, vptr);
3537
}
3538
3539
template <class Type>
3540
struct traits_asval {
3541
static int asval(PyObject *obj, Type *val) {
3542
if (val) {
3543
Type *p = 0;
3544
int res = traits_asptr<Type>::asptr(obj, &p);
3545
if (!SWIG_IsOK(res)) return res;
3546
if (p) {
3547
typedef typename noconst_traits<Type>::noconst_type noconst_type;
3548
*(const_cast<noconst_type*>(val)) = *p;
3549
if (SWIG_IsNewObj(res)){
3550
delete p;
3551
res = SWIG_DelNewMask(res);
3552
}
3553
return res;
3554
} else {
3555
return SWIG_ERROR;
3556
}
3557
} else {
3558
return traits_asptr<Type>::asptr(obj, (Type **)(0));
3559
}
3560
}
3561
};
3562
3563
template <class Type> struct traits_asval<Type*> {
3564
static int asval(PyObject *obj, Type **val) {
3565
if (val) {
3566
typedef typename noconst_traits<Type>::noconst_type noconst_type;
3567
noconst_type *p = 0;
3568
int res = traits_asptr<noconst_type>::asptr(obj, &p);
3569
if (SWIG_IsOK(res)) {
3570
*(const_cast<noconst_type**>(val)) = p;
3571
}
3572
return res;
3573
} else {
3574
return traits_asptr<Type>::asptr(obj, (Type **)(0));
3575
}
3576
}
3577
};
3578
3579
template <class Type>
3580
inline int asval(PyObject *obj, Type *val) {
3581
return traits_asval<Type>::asval(obj, val);
3582
}
3583
3584
template <class Type>
3585
struct traits_as<Type, value_category> {
3586
static Type as(PyObject *obj, bool throw_error) {
3587
Type v;
3588
int res = asval(obj, &v);
3589
if (!obj || !SWIG_IsOK(res)) {
3590
if (!PyErr_Occurred()) {
3591
::SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
3592
}
3593
if (throw_error) throw std::invalid_argument("bad type");
3594
}
3595
return v;
3596
}
3597
};
3598
3599
template <class Type>
3600
struct traits_as<Type, pointer_category> {
3601
static Type as(PyObject *obj, bool throw_error) {
3602
Type *v = 0;
3603
int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3604
if (SWIG_IsOK(res) && v) {
3605
if (SWIG_IsNewObj(res)) {
3606
Type r(*v);
3607
delete v;
3608
return r;
3609
} else {
3610
return *v;
3611
}
3612
} else {
3613
// Uninitialized return value, no Type() constructor required.
3614
static Type *v_def = (Type*) malloc(sizeof(Type));
3615
if (!PyErr_Occurred()) {
3616
SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
3617
}
3618
if (throw_error) throw std::invalid_argument("bad type");
3619
memset(v_def,0,sizeof(Type));
3620
return *v_def;
3621
}
3622
}
3623
};
3624
3625
template <class Type>
3626
struct traits_as<Type*, pointer_category> {
3627
static Type* as(PyObject *obj, bool throw_error) {
3628
Type *v = 0;
3629
int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3630
if (SWIG_IsOK(res)) {
3631
return v;
3632
} else {
3633
if (!PyErr_Occurred()) {
3634
SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
3635
}
3636
if (throw_error) throw std::invalid_argument("bad type");
3637
return 0;
3638
}
3639
}
3640
};
3641
3642
template <class Type>
3643
inline Type as(PyObject *obj, bool te = false) {
3644
return traits_as<Type, typename traits<Type>::category>::as(obj, te);
3645
}
3646
3647
template <class Type>
3648
struct traits_check<Type, value_category> {
3649
static bool check(PyObject *obj) {
3650
int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
3651
return SWIG_IsOK(res) ? true : false;
3652
}
3653
};
3654
3655
template <class Type>
3656
struct traits_check<Type, pointer_category> {
3657
static bool check(PyObject *obj) {
3658
int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
3659
return SWIG_IsOK(res) ? true : false;
3660
}
3661
};
3662
3663
template <class Type>
3664
inline bool check(PyObject *obj) {
3665
return traits_check<Type, typename traits<Type>::category>::check(obj);
3666
}
3667
}
3668
3669
3670
#include <functional>
3671
3672
namespace std {
3673
template <>
3674
struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
3675
{
3676
bool
3677
operator()(PyObject * v, PyObject *w) const
3678
{
3679
bool res;
3680
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3681
res = PyObject_Compare(v, w) < 0;
3682
SWIG_PYTHON_THREAD_END_BLOCK;
3683
return res;
3684
}
3685
};
3686
3687
template <>
3688
struct less <swig::PyObject_ptr>: public binary_function<swig::PyObject_ptr, swig::PyObject_ptr, bool>
3689
{
3690
bool
3691
operator()(const swig::PyObject_ptr& v, const swig::PyObject_ptr& w) const
3692
{
3693
return std::less<PyObject *>()(v, w);
3694
}
3695
};
3696
3697
template <>
3698
struct less <swig::PyObject_var>: public binary_function<swig::PyObject_var, swig::PyObject_var, bool>
3699
{
3700
bool
3701
operator()(const swig::PyObject_var& v, const swig::PyObject_var& w) const
3702
{
3703
return std::less<PyObject *>()(v, w);
3704
}
3705
};
3706
3707
}
3708
3709
namespace swig {
3710
template <> struct traits<PyObject *> {
3711
typedef value_category category;
3712
static const char* type_name() { return "PyObject *"; }
3713
};
3714
3715
template <> struct traits_asval<PyObject * > {
3716
typedef PyObject * value_type;
3717
static int asval(PyObject *obj, value_type *val) {
3718
if (val) *val = obj;
3719
return SWIG_OK;
3720
}
3721
};
3722
3723
template <>
3724
struct traits_check<PyObject *, value_category> {
3725
static bool check(PyObject *) {
3726
return true;
3727
}
3728
};
3729
3730
template <> struct traits_from<PyObject *> {
3731
typedef PyObject * value_type;
3732
static PyObject *from(const value_type& val) {
3733
Py_XINCREF(val);
3734
return val;
3735
}
3736
};
3737
3738
}
3739
3740
namespace swig {
3741
inline size_t
3742
check_index(ptrdiff_t i, size_t size, bool insert = false) {
3743
if ( i < 0 ) {
3744
if ((size_t) (-i) <= size)
3745
return (size_t) (i + size);
3746
} else if ( (size_t) i < size ) {
3747
return (size_t) i;
3748
} else if (insert && ((size_t) i == size)) {
3749
return size;
3750
}
3751
3752
throw std::out_of_range("index out of range");
3753
}
3754
3755
inline size_t
3756
slice_index(ptrdiff_t i, size_t size) {
3757
if ( i < 0 ) {
3758
if ((size_t) (-i) <= size) {
3759
return (size_t) (i + size);
3760
} else {
3761
throw std::out_of_range("index out of range");
3762
}
3763
} else {
3764
return ( (size_t) i < size ) ? ((size_t) i) : size;
3765
}
3766
}
3767
3768
template <class Sequence, class Difference>
3769
inline typename Sequence::iterator
3770
getpos(Sequence* self, Difference i) {
3771
typename Sequence::iterator pos = self->begin();
3772
std::advance(pos, check_index(i,self->size()));
3773
return pos;
3774
}
3775
3776
template <class Sequence, class Difference>
3777
inline typename Sequence::const_iterator
3778
cgetpos(const Sequence* self, Difference i) {
3779
typename Sequence::const_iterator pos = self->begin();
3780
std::advance(pos, check_index(i,self->size()));
3781
return pos;
3782
}
3783
3784
template <class Sequence, class Difference>
3785
inline Sequence*
3786
getslice(const Sequence* self, Difference i, Difference j) {
3787
typename Sequence::size_type size = self->size();
3788
typename Sequence::size_type ii = swig::check_index(i, size);
3789
typename Sequence::size_type jj = swig::slice_index(j, size);
3790
3791
if (jj > ii) {
3792
typename Sequence::const_iterator vb = self->begin();
3793
typename Sequence::const_iterator ve = self->begin();
3794
std::advance(vb,ii);
3795
std::advance(ve,jj);
3796
return new Sequence(vb, ve);
3797
} else {
3798
return new Sequence();
3799
}
3800
}
3801
3802
template <class Sequence, class Difference, class InputSeq>
3803
inline void
3804
setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
3805
typename Sequence::size_type size = self->size();
3806
typename Sequence::size_type ii = swig::check_index(i, size, true);
3807
typename Sequence::size_type jj = swig::slice_index(j, size);
3808
if (jj < ii) jj = ii;
3809
size_t ssize = jj - ii;
3810
if (ssize <= v.size()) {
3811
typename Sequence::iterator sb = self->begin();
3812
typename InputSeq::const_iterator vmid = v.begin();
3813
std::advance(sb,ii);
3814
std::advance(vmid, jj - ii);
3815
self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
3816
} else {
3817
typename Sequence::iterator sb = self->begin();
3818
typename Sequence::iterator se = self->begin();
3819
std::advance(sb,ii);
3820
std::advance(se,jj);
3821
self->erase(sb,se);
3822
self->insert(sb, v.begin(), v.end());
3823
}
3824
}
3825
3826
template <class Sequence, class Difference>
3827
inline void
3828
delslice(Sequence* self, Difference i, Difference j) {
3829
typename Sequence::size_type size = self->size();
3830
typename Sequence::size_type ii = swig::check_index(i, size, true);
3831
typename Sequence::size_type jj = swig::slice_index(j, size);
3832
if (jj > ii) {
3833
typename Sequence::iterator sb = self->begin();
3834
typename Sequence::iterator se = self->begin();
3835
std::advance(sb,ii);
3836
std::advance(se,jj);
3837
self->erase(sb,se);
3838
}
3839
}
3840
}
3841
3842
3843
#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
3844
# if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
3845
# define SWIG_STD_NOITERATOR_TRAITS_STL
3846
# endif
3847
#endif
3848
3849
#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
3850
#include <iterator>
3851
#else
3852
namespace std {
3853
template <class Iterator>
3854
struct iterator_traits {
3855
typedef ptrdiff_t difference_type;
3856
typedef typename Iterator::value_type value_type;
3857
};
3858
3859
template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
3860
struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
3861
typedef Distance difference_type;
3862
typedef T value_type;
3863
};
3864
3865
template <class T>
3866
struct iterator_traits<T*> {
3867
typedef T value_type;
3868
typedef ptrdiff_t difference_type;
3869
};
3870
3871
template<typename _InputIterator>
3872
inline typename iterator_traits<_InputIterator>::difference_type
3873
distance(_InputIterator __first, _InputIterator __last)
3874
{
3875
typename iterator_traits<_InputIterator>::difference_type __n = 0;
3876
while (__first != __last) {
3877
++__first; ++__n;
3878
}
3879
return __n;
3880
}
3881
}
3882
#endif
3883
3884
3885
namespace swig {
3886
template<typename OutIterator>
3887
class PySwigIterator_T : public PySwigIterator
3888
{
3889
public:
3890
typedef OutIterator out_iterator;
3891
typedef typename std::iterator_traits<out_iterator>::value_type value_type;
3892
typedef PySwigIterator_T<out_iterator> self_type;
3893
3894
PySwigIterator_T(out_iterator curr, PyObject *seq)
3895
: PySwigIterator(seq), current(curr)
3896
{
3897
}
3898
3899
const out_iterator& get_current() const
3900
{
3901
return current;
3902
}
3903
3904
3905
bool equal (const PySwigIterator &iter) const
3906
{
3907
const self_type *iters = dynamic_cast<const self_type *>(&iter);
3908
if (iters) {
3909
return (current == iters->get_current());
3910
} else {
3911
throw std::invalid_argument("bad iterator type");
3912
}
3913
}
3914
3915
ptrdiff_t distance(const PySwigIterator &iter) const
3916
{
3917
const self_type *iters = dynamic_cast<const self_type *>(&iter);
3918
if (iters) {
3919
return std::distance(current, iters->get_current());
3920
} else {
3921
throw std::invalid_argument("bad iterator type");
3922
}
3923
}
3924
3925
protected:
3926
out_iterator current;
3927
};
3928
3929
template <class ValueType>
3930
struct from_oper
3931
{
3932
typedef const ValueType& argument_type;
3933
typedef PyObject *result_type;
3934
result_type operator()(argument_type v) const
3935
{
3936
return swig::from(v);
3937
}
3938
};
3939
3940
template<typename OutIterator,
3941
typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
3942
typename FromOper = from_oper<ValueType> >
3943
class PySwigIteratorOpen_T : public PySwigIterator_T<OutIterator>
3944
{
3945
public:
3946
FromOper from;
3947
typedef OutIterator out_iterator;
3948
typedef ValueType value_type;
3949
typedef PySwigIterator_T<out_iterator> base;
3950
typedef PySwigIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
3951
3952
PySwigIteratorOpen_T(out_iterator curr, PyObject *seq)
3953
: PySwigIterator_T<OutIterator>(curr, seq)
3954
{
3955
}
3956
3957
PyObject *value() const {
3958
return from(static_cast<const value_type&>(*(base::current)));
3959
}
3960
3961
PySwigIterator *copy() const
3962
{
3963
return new self_type(*this);
3964
}
3965
3966
PySwigIterator *incr(size_t n = 1)
3967
{
3968
while (n--) {
3969
++base::current;
3970
}
3971
return this;
3972
}
3973
3974
PySwigIterator *decr(size_t n = 1)
3975
{
3976
while (n--) {
3977
--base::current;
3978
}
3979
return this;
3980
}
3981
};
3982
3983
template<typename OutIterator,
3984
typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
3985
typename FromOper = from_oper<ValueType> >
3986
class PySwigIteratorClosed_T : public PySwigIterator_T<OutIterator>
3987
{
3988
public:
3989
FromOper from;
3990
typedef OutIterator out_iterator;
3991
typedef ValueType value_type;
3992
typedef PySwigIterator_T<out_iterator> base;
3993
typedef PySwigIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
3994
3995
PySwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
3996
: PySwigIterator_T<OutIterator>(curr, seq), begin(first), end(last)
3997
{
3998
}
3999
4000
PyObject *value() const {
4001
if (base::current == end) {
4002
throw stop_iteration();
4003
} else {
4004
return from(static_cast<const value_type&>(*(base::current)));
4005
}
4006
}
4007
4008
PySwigIterator *copy() const
4009
{
4010
return new self_type(*this);
4011
}
4012
4013
PySwigIterator *incr(size_t n = 1)
4014
{
4015
while (n--) {
4016
if (base::current == end) {
4017
throw stop_iteration();
4018
} else {
4019
++base::current;
4020
}
4021
}
4022
return this;
4023
}
4024
4025
PySwigIterator *decr(size_t n = 1)
4026
{
4027
while (n--) {
4028
if (base::current == begin) {
4029
throw stop_iteration();
4030
} else {
4031
--base::current;
4032
}
4033
}
4034
return this;
4035
}
4036
4037
private:
4038
out_iterator begin;
4039
out_iterator end;
4040
};
4041
4042
template<typename OutIter>
4043
inline PySwigIterator*
4044
make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
4045
{
4046
return new PySwigIteratorClosed_T<OutIter>(current, begin, end, seq);
4047
}
4048
4049
template<typename OutIter>
4050
inline PySwigIterator*
4051
make_output_iterator(const OutIter& current, PyObject *seq = 0)
4052
{
4053
return new PySwigIteratorOpen_T<OutIter>(current, seq);
4054
}
4055
}
4056
4057
4058
namespace swig
4059
{
4060
template <class T>
4061
struct PySequence_Ref
4062
{
4063
PySequence_Ref(PyObject* seq, int index)
4064
: _seq(seq), _index(index)
4065
{
4066
}
4067
4068
operator T () const
4069
{
4070
swig::PyObject_var item = PySequence_GetItem(_seq, _index);
4071
try {
4072
return swig::as<T>(item, true);
4073
} catch (std::exception& e) {
4074
char msg[1024];
4075
sprintf(msg, "in sequence element %d ", _index);
4076
if (!PyErr_Occurred()) {
4077
::SWIG_Error(SWIG_TypeError, swig::type_name<T>());
4078
}
4079
SWIG_Python_AddErrorMsg(msg);
4080
SWIG_Python_AddErrorMsg(e.what());
4081
throw;
4082
}
4083
}
4084
4085
PySequence_Ref& operator=(const T& v)
4086
{
4087
PySequence_SetItem(_seq, _index, swig::from<T>(v));
4088
return *this;
4089
}
4090
4091
private:
4092
PyObject* _seq;
4093
int _index;
4094
};
4095
4096
template <class T>
4097
struct PySequence_ArrowProxy
4098
{
4099
PySequence_ArrowProxy(const T& x): m_value(x) {}
4100
const T* operator->() const { return &m_value; }
4101
operator const T*() const { return &m_value; }
4102
T m_value;
4103
};
4104
4105
template <class T, class Reference >
4106
struct PySequence_InputIterator
4107
{
4108
typedef PySequence_InputIterator<T, Reference > self;
4109
4110
typedef std::random_access_iterator_tag iterator_category;
4111
typedef Reference reference;
4112
typedef T value_type;
4113
typedef T* pointer;
4114
typedef int difference_type;
4115
4116
PySequence_InputIterator()
4117
{
4118
}
4119
4120
PySequence_InputIterator(PyObject* seq, int index)
4121
: _seq(seq), _index(index)
4122
{
4123
}
4124
4125
reference operator*() const
4126
{
4127
return reference(_seq, _index);
4128
}
4129
4130
PySequence_ArrowProxy<T>
4131
operator->() const {
4132
return PySequence_ArrowProxy<T>(operator*());
4133
}
4134
4135
bool operator==(const self& ri) const
4136
{
4137
return (_index == ri._index) && (_seq == ri._seq);
4138
}
4139
4140
bool operator!=(const self& ri) const
4141
{
4142
return !(operator==(ri));
4143
}
4144
4145
self& operator ++ ()
4146
{
4147
++_index;
4148
return *this;
4149
}
4150
4151
self& operator -- ()
4152
{
4153
--_index;
4154
return *this;
4155
}
4156
4157
self& operator += (difference_type n)
4158
{
4159
_index += n;
4160
return *this;
4161
}
4162
4163
self operator +(difference_type n) const
4164
{
4165
return self(_seq, _index + n);
4166
}
4167
4168
self& operator -= (difference_type n)
4169
{
4170
_index -= n;
4171
return *this;
4172
}
4173
4174
self operator -(difference_type n) const
4175
{
4176
return self(_seq, _index - n);
4177
}
4178
4179
difference_type operator - (const self& ri) const
4180
{
4181
return _index - ri._index;
4182
}
4183
4184
bool operator < (const self& ri) const
4185
{
4186
return _index < ri._index;
4187
}
4188
4189
reference
4190
operator[](difference_type n) const
4191
{
4192
return reference(_seq, _index + n);
4193
}
4194
4195
private:
4196
PyObject* _seq;
4197
difference_type _index;
4198
};
4199
4200
template <class T>
4201
struct PySequence_Cont
4202
{
4203
typedef PySequence_Ref<T> reference;
4204
typedef const PySequence_Ref<T> const_reference;
4205
typedef T value_type;
4206
typedef T* pointer;
4207
typedef int difference_type;
4208
typedef int size_type;
4209
typedef const pointer const_pointer;
4210
typedef PySequence_InputIterator<T, reference> iterator;
4211
typedef PySequence_InputIterator<T, const_reference> const_iterator;
4212
4213
PySequence_Cont(PyObject* seq) : _seq(0)
4214
{
4215
if (!PySequence_Check(seq)) {
4216
throw std::invalid_argument("a sequence is expected");
4217
}
4218
_seq = seq;
4219
Py_INCREF(_seq);
4220
}
4221
4222
~PySequence_Cont()
4223
{
4224
Py_XDECREF(_seq);
4225
}
4226
4227
size_type size() const
4228
{
4229
return static_cast<size_type>(PySequence_Size(_seq));
4230
}
4231
4232
bool empty() const
4233
{
4234
return size() == 0;
4235
}
4236
4237
iterator begin()
4238
{
4239
return iterator(_seq, 0);
4240
}
4241
4242
const_iterator begin() const
4243
{
4244
return const_iterator(_seq, 0);
4245
}
4246
4247
iterator end()
4248
{
4249
return iterator(_seq, size());
4250
}
4251
4252
const_iterator end() const
4253
{
4254
return const_iterator(_seq, size());
4255
}
4256
4257
reference operator[](difference_type n)
4258
{
4259
return reference(_seq, n);
4260
}
4261
4262
const_reference operator[](difference_type n) const
4263
{
4264
return const_reference(_seq, n);
4265
}
4266
4267
bool check(bool set_err = true) const
4268
{
4269
int s = size();
4270
for (int i = 0; i < s; ++i) {
4271
swig::PyObject_var item = PySequence_GetItem(_seq, i);
4272
if (!swig::check<value_type>(item)) {
4273
if (set_err) {
4274
char msg[1024];
4275
sprintf(msg, "in sequence element %d", i);
4276
SWIG_Error(SWIG_RuntimeError, msg);
4277
}
4278
return false;
4279
}
4280
}
4281
return true;
4282
}
4283
4284
private:
4285
PyObject* _seq;
4286
};
4287
4288
}
4289
4290
4291
#include "TestResult.hxx"
4292
4293
namespace OpenTURNS {
4294
4295
template <>
4296
struct traitsPythonType<OpenTURNS::Base::Stat::TestResult>
4297
{
4298
typedef _PySequence_ Type;
4299
};
4300
4301
template <>
4302
inline
4303
OpenTURNS::Base::Stat::TestResult
4304
convert<_PySequence_,OpenTURNS::Base::Stat::TestResult>(PyObject * pyObj)
4305
{
4306
check<_PySequence_>( pyObj );
4307
if (PySequence_Fast_GET_SIZE( pyObj ) != 4)
4308
throw Base::Common::InvalidArgumentException(HERE) << "Sequence passed as argument is not convertible to a TestResult. Expected sequence (String, Bool, NumericalScalar, NumericalScalar)";
4309
4310
PyObject * item_0 = PySequence_Fast_GET_ITEM( pyObj, 0 ); check<_PyString_>( item_0 );
4311
PyObject * item_1 = PySequence_Fast_GET_ITEM( pyObj, 1 ); check<_PyBool_>( item_1 );
4312
PyObject * item_2 = PySequence_Fast_GET_ITEM( pyObj, 2 ); check<_PyFloat_>( item_2 );
4313
PyObject * item_3 = PySequence_Fast_GET_ITEM( pyObj, 3 ); check<_PyFloat_>( item_3 );
4314
4315
return OpenTURNS::Base::Stat::TestResult( convert<_PyString_,String>( item_0 ),
4316
convert<_PyBool_,Bool>( item_1 ),
4317
convert<_PyFloat_,NumericalScalar>( item_2 ),
4318
convert<_PyFloat_,NumericalScalar>( item_3 ) );
4319
}
4320
4321
4322
} /* namespace OpenTURNS */
4323
4324
4325
4326
SWIGINTERN swig_type_info*
4327
SWIG_pchar_descriptor(void)
4328
{
4329
static int init = 0;
4330
static swig_type_info* info = 0;
4331
if (!init) {
4332
info = SWIG_TypeQuery("_p_char");
4333
init = 1;
4334
}
4335
return info;
4336
}
4337
4338
4339
SWIGINTERNINLINE PyObject *
4340
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
4341
{
4342
if (carray) {
4343
if (size > INT_MAX) {
4344
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
4345
return pchar_descriptor ?
4346
SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
4347
} else {
4348
return PyString_FromStringAndSize(carray, static_cast< int >(size));
4349
}
4350
} else {
4351
return SWIG_Py_Void();
4352
}
4353
}
4354
4355
4356
SWIGINTERNINLINE PyObject *
4357
SWIG_From_std_string (const std::string& s)
4358
{
4359
if (s.size()) {
4360
return SWIG_FromCharPtrAndSize(s.data(), s.size());
4361
} else {
4362
return SWIG_FromCharPtrAndSize(s.c_str(), 0);
4363
}
4364
}
4365
4366
4367
SWIGINTERN int
4368
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
4369
{
4370
if (PyString_Check(obj)) {
4371
char *cstr; Py_ssize_t len;
4372
PyString_AsStringAndSize(obj, &cstr, &len);
4373
if (cptr) {
4374
if (alloc) {
4375
/*
4376
In python the user should not be able to modify the inner
4377
string representation. To warranty that, if you define
4378
SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
4379
buffer is always returned.
4380
4381
The default behavior is just to return the pointer value,
4382
so, be careful.
4383
*/
4384
#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
4385
if (*alloc != SWIG_OLDOBJ)
4386
#else
4387
if (*alloc == SWIG_NEWOBJ)
4388
#endif
4389
{
4390
*cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
4391
*alloc = SWIG_NEWOBJ;
4392
}
4393
else {
4394
*cptr = cstr;
4395
*alloc = SWIG_OLDOBJ;
4396
}
4397
} else {
4398
*cptr = PyString_AsString(obj);
4399
}
4400
}
4401
if (psize) *psize = len + 1;
4402
return SWIG_OK;
4403
} else {
4404
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
4405
if (pchar_descriptor) {
4406
void* vptr = 0;
4407
if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
4408
if (cptr) *cptr = (char *) vptr;
4409
if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
4410
if (alloc) *alloc = SWIG_OLDOBJ;
4411
return SWIG_OK;
4412
}
4413
}
4414
}
4415
return SWIG_TypeError;
4416
}
4417
4418
4419
SWIGINTERN int
4420
SWIG_AsPtr_std_string (PyObject * obj, std::string **val)
4421
{
4422
char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
4423
if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
4424
if (buf) {
4425
if (val) *val = new std::string(buf, size - 1);
4426
if (alloc == SWIG_NEWOBJ) delete[] buf;
4427
return SWIG_NEWOBJ;
4428
} else {
4429
if (val) *val = 0;
4430
return SWIG_OLDOBJ;
4431
}
4432
} else {
4433
static int init = 0;
4434
static swig_type_info* descriptor = 0;
4435
if (!init) {
4436
descriptor = SWIG_TypeQuery("std::string" " *");
4437
init = 1;
4438
}
4439
if (descriptor) {
4440
std::string *vptr;
4441
int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
4442
if (SWIG_IsOK(res) && val) *val = vptr;
4443
return res;
4444
}
4445
}
4446
return SWIG_ERROR;
4447
}
4448
4449
4450
SWIGINTERN int
4451
SWIG_AsVal_bool (PyObject *obj, bool *val)
4452
{
4453
int r = PyObject_IsTrue(obj);
4454
if (r == -1)
4455
return SWIG_ERROR;
4456
if (val) *val = r ? true : false;
4457
return SWIG_OK;
4458
}
4459
4460
4461
#define SWIG_From_double PyFloat_FromDouble
4462
4463
SWIGINTERN OpenTURNS::Base::Stat::TestResult *new_OpenTURNS_Base_Stat_TestResult__SWIG_2(OpenTURNS::Base::Stat::TestResult const &other){ return new OpenTURNS::Base::Stat::TestResult(other); }
4464
SWIGINTERN OpenTURNS::Base::Stat::TestResult *new_OpenTURNS_Base_Stat_TestResult__SWIG_3(PyObject *pyObj){
4465
return new OpenTURNS::Base::Stat::TestResult( OpenTURNS::convert<OpenTURNS::_PySequence_,OpenTURNS::Base::Stat::TestResult>(pyObj) );
4466
}
4467
4468
#include "VisualTest.hxx"
4469
4470
SWIGINTERN OpenTURNS::Uncertainty::StatTest::VisualTest *new_OpenTURNS_Uncertainty_StatTest_VisualTest__SWIG_1(OpenTURNS::Uncertainty::StatTest::VisualTest const &other){ return new OpenTURNS::Uncertainty::StatTest::VisualTest(other); }
4471
4472
#include "FittingTest.hxx"
4473
4474
SWIGINTERN OpenTURNS::Uncertainty::StatTest::FittingTest *new_OpenTURNS_Uncertainty_StatTest_FittingTest__SWIG_1(OpenTURNS::Uncertainty::StatTest::FittingTest const &other){ return new OpenTURNS::Uncertainty::StatTest::FittingTest(other); }
4475
4476
#include "HypothesisTest.hxx"
4477
4478
4479
SWIGINTERNINLINE PyObject*
4480
SWIG_From_unsigned_SS_long (unsigned long value)
4481
{
4482
return (value > LONG_MAX) ?
4483
PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
4484
}
4485
4486
SWIGINTERN OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *new_OpenTURNS_Base_Type_Collection_Sl_OpenTURNS_Base_Stat_TestResult_Sg___SWIG_3(PyObject *pyObj){
4487
return OpenTURNS::buildCollectionFromPySequence< OpenTURNS::Base::Stat::TestResult >( pyObj );
4488
}
4489
SWIGINTERN OpenTURNS::Uncertainty::StatTest::HypothesisTest *new_OpenTURNS_Uncertainty_StatTest_HypothesisTest__SWIG_1(OpenTURNS::Uncertainty::StatTest::HypothesisTest const &other){ return new OpenTURNS::Uncertainty::StatTest::HypothesisTest(other); }
4490
4491
#include "LinearModelTest.hxx"
4492
4493
SWIGINTERN OpenTURNS::Uncertainty::StatTest::LinearModelTest *new_OpenTURNS_Uncertainty_StatTest_LinearModelTest__SWIG_1(OpenTURNS::Uncertainty::StatTest::LinearModelTest const &other){ return new OpenTURNS::Uncertainty::StatTest::LinearModelTest(other); }
4494
4495
#include "NormalityTest.hxx"
4496
4497
SWIGINTERN OpenTURNS::Uncertainty::StatTest::NormalityTest *new_OpenTURNS_Uncertainty_StatTest_NormalityTest__SWIG_1(OpenTURNS::Uncertainty::StatTest::NormalityTest const &other){ return new OpenTURNS::Uncertainty::StatTest::NormalityTest(other); }
4498
#ifdef __cplusplus
4499
extern "C" {
4500
#endif
4501
SWIGINTERN PyObject *_wrap_delete_PySwigIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4502
PyObject *resultobj = 0;
4503
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4504
void *argp1 = 0 ;
4505
int res1 = 0 ;
4506
PyObject * obj0 = 0 ;
4507
4508
if (!PyArg_ParseTuple(args,(char *)"O:delete_PySwigIterator",&obj0)) SWIG_fail;
4509
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
4510
if (!SWIG_IsOK(res1)) {
4511
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySwigIterator" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4512
}
4513
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4514
delete arg1;
4515
resultobj = SWIG_Py_Void();
4516
return resultobj;
4517
fail:
4518
return NULL;
4519
}
4520
4521
4522
SWIGINTERN PyObject *_wrap_PySwigIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4523
PyObject *resultobj = 0;
4524
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4525
void *argp1 = 0 ;
4526
int res1 = 0 ;
4527
PyObject * obj0 = 0 ;
4528
PyObject *result = 0 ;
4529
4530
if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_value",&obj0)) SWIG_fail;
4531
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4532
if (!SWIG_IsOK(res1)) {
4533
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_value" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4534
}
4535
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4536
try {
4537
result = (PyObject *)((swig::PySwigIterator const *)arg1)->value();
4538
}
4539
catch(swig::stop_iteration &_e) {
4540
{
4541
(void)_e;
4542
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4543
SWIG_fail;
4544
}
4545
}
4546
4547
resultobj = result;
4548
return resultobj;
4549
fail:
4550
return NULL;
4551
}
4552
4553
4554
SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4555
PyObject *resultobj = 0;
4556
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4557
size_t arg2 ;
4558
void *argp1 = 0 ;
4559
int res1 = 0 ;
4560
size_t val2 ;
4561
int ecode2 = 0 ;
4562
PyObject * obj0 = 0 ;
4563
PyObject * obj1 = 0 ;
4564
swig::PySwigIterator *result = 0 ;
4565
4566
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_incr",&obj0,&obj1)) SWIG_fail;
4567
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4568
if (!SWIG_IsOK(res1)) {
4569
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4570
}
4571
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4572
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
4573
if (!SWIG_IsOK(ecode2)) {
4574
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
4575
}
4576
arg2 = static_cast< size_t >(val2);
4577
try {
4578
result = (swig::PySwigIterator *)(arg1)->incr(arg2);
4579
}
4580
catch(swig::stop_iteration &_e) {
4581
{
4582
(void)_e;
4583
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4584
SWIG_fail;
4585
}
4586
}
4587
4588
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4589
return resultobj;
4590
fail:
4591
return NULL;
4592
}
4593
4594
4595
SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4596
PyObject *resultobj = 0;
4597
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4598
void *argp1 = 0 ;
4599
int res1 = 0 ;
4600
PyObject * obj0 = 0 ;
4601
swig::PySwigIterator *result = 0 ;
4602
4603
if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_incr",&obj0)) SWIG_fail;
4604
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4605
if (!SWIG_IsOK(res1)) {
4606
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4607
}
4608
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4609
try {
4610
result = (swig::PySwigIterator *)(arg1)->incr();
4611
}
4612
catch(swig::stop_iteration &_e) {
4613
{
4614
(void)_e;
4615
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4616
SWIG_fail;
4617
}
4618
}
4619
4620
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4621
return resultobj;
4622
fail:
4623
return NULL;
4624
}
4625
4626
4627
SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
4628
int argc;
4629
PyObject *argv[3];
4630
int ii;
4631
4632
if (!PyTuple_Check(args)) SWIG_fail;
4633
argc = (int)PyObject_Length(args);
4634
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
4635
argv[ii] = PyTuple_GET_ITEM(args,ii);
4636
}
4637
if (argc == 1) {
4638
int _v;
4639
void *vptr = 0;
4640
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4641
_v = SWIG_CheckState(res);
4642
if (_v) {
4643
return _wrap_PySwigIterator_incr__SWIG_1(self, args);
4644
}
4645
}
4646
if (argc == 2) {
4647
int _v;
4648
void *vptr = 0;
4649
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4650
_v = SWIG_CheckState(res);
4651
if (_v) {
4652
{
4653
int res = SWIG_AsVal_size_t(argv[1], NULL);
4654
_v = SWIG_CheckState(res);
4655
}
4656
if (_v) {
4657
return _wrap_PySwigIterator_incr__SWIG_0(self, args);
4658
}
4659
}
4660
}
4661
4662
fail:
4663
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_incr'.\n"
4664
" Possible C/C++ prototypes are:\n"
4665
" incr(swig::PySwigIterator *,size_t)\n"
4666
" incr(swig::PySwigIterator *)\n");
4667
return NULL;
4668
}
4669
4670
4671
SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4672
PyObject *resultobj = 0;
4673
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4674
size_t arg2 ;
4675
void *argp1 = 0 ;
4676
int res1 = 0 ;
4677
size_t val2 ;
4678
int ecode2 = 0 ;
4679
PyObject * obj0 = 0 ;
4680
PyObject * obj1 = 0 ;
4681
swig::PySwigIterator *result = 0 ;
4682
4683
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_decr",&obj0,&obj1)) SWIG_fail;
4684
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4685
if (!SWIG_IsOK(res1)) {
4686
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4687
}
4688
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4689
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
4690
if (!SWIG_IsOK(ecode2)) {
4691
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_decr" "', argument " "2"" of type '" "size_t""'");
4692
}
4693
arg2 = static_cast< size_t >(val2);
4694
try {
4695
result = (swig::PySwigIterator *)(arg1)->decr(arg2);
4696
}
4697
catch(swig::stop_iteration &_e) {
4698
{
4699
(void)_e;
4700
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4701
SWIG_fail;
4702
}
4703
}
4704
4705
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4706
return resultobj;
4707
fail:
4708
return NULL;
4709
}
4710
4711
4712
SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4713
PyObject *resultobj = 0;
4714
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4715
void *argp1 = 0 ;
4716
int res1 = 0 ;
4717
PyObject * obj0 = 0 ;
4718
swig::PySwigIterator *result = 0 ;
4719
4720
if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_decr",&obj0)) SWIG_fail;
4721
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4722
if (!SWIG_IsOK(res1)) {
4723
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4724
}
4725
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4726
try {
4727
result = (swig::PySwigIterator *)(arg1)->decr();
4728
}
4729
catch(swig::stop_iteration &_e) {
4730
{
4731
(void)_e;
4732
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4733
SWIG_fail;
4734
}
4735
}
4736
4737
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4738
return resultobj;
4739
fail:
4740
return NULL;
4741
}
4742
4743
4744
SWIGINTERN PyObject *_wrap_PySwigIterator_decr(PyObject *self, PyObject *args) {
4745
int argc;
4746
PyObject *argv[3];
4747
int ii;
4748
4749
if (!PyTuple_Check(args)) SWIG_fail;
4750
argc = (int)PyObject_Length(args);
4751
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
4752
argv[ii] = PyTuple_GET_ITEM(args,ii);
4753
}
4754
if (argc == 1) {
4755
int _v;
4756
void *vptr = 0;
4757
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4758
_v = SWIG_CheckState(res);
4759
if (_v) {
4760
return _wrap_PySwigIterator_decr__SWIG_1(self, args);
4761
}
4762
}
4763
if (argc == 2) {
4764
int _v;
4765
void *vptr = 0;
4766
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4767
_v = SWIG_CheckState(res);
4768
if (_v) {
4769
{
4770
int res = SWIG_AsVal_size_t(argv[1], NULL);
4771
_v = SWIG_CheckState(res);
4772
}
4773
if (_v) {
4774
return _wrap_PySwigIterator_decr__SWIG_0(self, args);
4775
}
4776
}
4777
}
4778
4779
fail:
4780
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_decr'.\n"
4781
" Possible C/C++ prototypes are:\n"
4782
" decr(swig::PySwigIterator *,size_t)\n"
4783
" decr(swig::PySwigIterator *)\n");
4784
return NULL;
4785
}
4786
4787
4788
SWIGINTERN PyObject *_wrap_PySwigIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4789
PyObject *resultobj = 0;
4790
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4791
swig::PySwigIterator *arg2 = 0 ;
4792
void *argp1 = 0 ;
4793
int res1 = 0 ;
4794
void *argp2 = 0 ;
4795
int res2 = 0 ;
4796
PyObject * obj0 = 0 ;
4797
PyObject * obj1 = 0 ;
4798
ptrdiff_t result;
4799
4800
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_distance",&obj0,&obj1)) SWIG_fail;
4801
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4802
if (!SWIG_IsOK(res1)) {
4803
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_distance" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4804
}
4805
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4806
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
4807
if (!SWIG_IsOK(res2)) {
4808
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4809
}
4810
if (!argp2) {
4811
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4812
}
4813
arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
4814
try {
4815
result = ((swig::PySwigIterator const *)arg1)->distance((swig::PySwigIterator const &)*arg2);
4816
}
4817
catch(std::invalid_argument &_e) {
4818
SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
4819
}
4820
4821
resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
4822
return resultobj;
4823
fail:
4824
return NULL;
4825
}
4826
4827
4828
SWIGINTERN PyObject *_wrap_PySwigIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4829
PyObject *resultobj = 0;
4830
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4831
swig::PySwigIterator *arg2 = 0 ;
4832
void *argp1 = 0 ;
4833
int res1 = 0 ;
4834
void *argp2 = 0 ;
4835
int res2 = 0 ;
4836
PyObject * obj0 = 0 ;
4837
PyObject * obj1 = 0 ;
4838
bool result;
4839
4840
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_equal",&obj0,&obj1)) SWIG_fail;
4841
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4842
if (!SWIG_IsOK(res1)) {
4843
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_equal" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4844
}
4845
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4846
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
4847
if (!SWIG_IsOK(res2)) {
4848
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4849
}
4850
if (!argp2) {
4851
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4852
}
4853
arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
4854
try {
4855
result = (bool)((swig::PySwigIterator const *)arg1)->equal((swig::PySwigIterator const &)*arg2);
4856
}
4857
catch(std::invalid_argument &_e) {
4858
SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
4859
}
4860
4861
resultobj = SWIG_From_bool(static_cast< bool >(result));
4862
return resultobj;
4863
fail:
4864
return NULL;
4865
}
4866
4867
4868
SWIGINTERN PyObject *_wrap_PySwigIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4869
PyObject *resultobj = 0;
4870
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4871
void *argp1 = 0 ;
4872
int res1 = 0 ;
4873
PyObject * obj0 = 0 ;
4874
swig::PySwigIterator *result = 0 ;
4875
4876
if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_copy",&obj0)) SWIG_fail;
4877
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4878
if (!SWIG_IsOK(res1)) {
4879
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_copy" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4880
}
4881
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4882
result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->copy();
4883
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
4884
return resultobj;
4885
fail:
4886
return NULL;
4887
}
4888
4889
4890
SWIGINTERN PyObject *_wrap_PySwigIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4891
PyObject *resultobj = 0;
4892
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4893
void *argp1 = 0 ;
4894
int res1 = 0 ;
4895
PyObject * obj0 = 0 ;
4896
PyObject *result = 0 ;
4897
4898
if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_next",&obj0)) SWIG_fail;
4899
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4900
if (!SWIG_IsOK(res1)) {
4901
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_next" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4902
}
4903
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4904
try {
4905
result = (PyObject *)(arg1)->next();
4906
}
4907
catch(swig::stop_iteration &_e) {
4908
{
4909
(void)_e;
4910
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4911
SWIG_fail;
4912
}
4913
}
4914
4915
resultobj = result;
4916
return resultobj;
4917
fail:
4918
return NULL;
4919
}
4920
4921
4922
SWIGINTERN PyObject *_wrap_PySwigIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4923
PyObject *resultobj = 0;
4924
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4925
void *argp1 = 0 ;
4926
int res1 = 0 ;
4927
PyObject * obj0 = 0 ;
4928
PyObject *result = 0 ;
4929
4930
if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_previous",&obj0)) SWIG_fail;
4931
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4932
if (!SWIG_IsOK(res1)) {
4933
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_previous" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4934
}
4935
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4936
try {
4937
result = (PyObject *)(arg1)->previous();
4938
}
4939
catch(swig::stop_iteration &_e) {
4940
{
4941
(void)_e;
4942
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4943
SWIG_fail;
4944
}
4945
}
4946
4947
resultobj = result;
4948
return resultobj;
4949
fail:
4950
return NULL;
4951
}
4952
4953
4954
SWIGINTERN PyObject *_wrap_PySwigIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4955
PyObject *resultobj = 0;
4956
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4957
ptrdiff_t arg2 ;
4958
void *argp1 = 0 ;
4959
int res1 = 0 ;
4960
ptrdiff_t val2 ;
4961
int ecode2 = 0 ;
4962
PyObject * obj0 = 0 ;
4963
PyObject * obj1 = 0 ;
4964
swig::PySwigIterator *result = 0 ;
4965
4966
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_advance",&obj0,&obj1)) SWIG_fail;
4967
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4968
if (!SWIG_IsOK(res1)) {
4969
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_advance" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4970
}
4971
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4972
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
4973
if (!SWIG_IsOK(ecode2)) {
4974
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
4975
}
4976
arg2 = static_cast< ptrdiff_t >(val2);
4977
try {
4978
result = (swig::PySwigIterator *)(arg1)->advance(arg2);
4979
}
4980
catch(swig::stop_iteration &_e) {
4981
{
4982
(void)_e;
4983
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4984
SWIG_fail;
4985
}
4986
}
4987
4988
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4989
return resultobj;
4990
fail:
4991
return NULL;
4992
}
4993
4994
4995
SWIGINTERN PyObject *_wrap_PySwigIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4996
PyObject *resultobj = 0;
4997
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4998
swig::PySwigIterator *arg2 = 0 ;
4999
void *argp1 = 0 ;
5000
int res1 = 0 ;
5001
void *argp2 = 0 ;
5002
int res2 = 0 ;
5003
PyObject * obj0 = 0 ;
5004
PyObject * obj1 = 0 ;
5005
bool result;
5006
5007
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___eq__",&obj0,&obj1)) SWIG_fail;
5008
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5009
if (!SWIG_IsOK(res1)) {
5010
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___eq__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5011
}
5012
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5013
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
5014
if (!SWIG_IsOK(res2)) {
5015
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5016
}
5017
if (!argp2) {
5018
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5019
}
5020
arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5021
result = (bool)((swig::PySwigIterator const *)arg1)->operator ==((swig::PySwigIterator const &)*arg2);
5022
resultobj = SWIG_From_bool(static_cast< bool >(result));
5023
return resultobj;
5024
fail:
5025
return NULL;
5026
}
5027
5028
5029
SWIGINTERN PyObject *_wrap_PySwigIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5030
PyObject *resultobj = 0;
5031
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5032
swig::PySwigIterator *arg2 = 0 ;
5033
void *argp1 = 0 ;
5034
int res1 = 0 ;
5035
void *argp2 = 0 ;
5036
int res2 = 0 ;
5037
PyObject * obj0 = 0 ;
5038
PyObject * obj1 = 0 ;
5039
bool result;
5040
5041
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___ne__",&obj0,&obj1)) SWIG_fail;
5042
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5043
if (!SWIG_IsOK(res1)) {
5044
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___ne__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5045
}
5046
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5047
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
5048
if (!SWIG_IsOK(res2)) {
5049
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5050
}
5051
if (!argp2) {
5052
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5053
}
5054
arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5055
result = (bool)((swig::PySwigIterator const *)arg1)->operator !=((swig::PySwigIterator const &)*arg2);
5056
resultobj = SWIG_From_bool(static_cast< bool >(result));
5057
return resultobj;
5058
fail:
5059
return NULL;
5060
}
5061
5062
5063
SWIGINTERN PyObject *_wrap_PySwigIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5064
PyObject *resultobj = 0;
5065
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5066
ptrdiff_t arg2 ;
5067
void *argp1 = 0 ;
5068
int res1 = 0 ;
5069
ptrdiff_t val2 ;
5070
int ecode2 = 0 ;
5071
PyObject * obj0 = 0 ;
5072
PyObject * obj1 = 0 ;
5073
swig::PySwigIterator *result = 0 ;
5074
5075
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___iadd__",&obj0,&obj1)) SWIG_fail;
5076
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
5077
if (!SWIG_IsOK(res1)) {
5078
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___iadd__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5079
}
5080
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5081
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5082
if (!SWIG_IsOK(ecode2)) {
5083
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
5084
}
5085
arg2 = static_cast< ptrdiff_t >(val2);
5086
try {
5087
{
5088
swig::PySwigIterator &_result_ref = (arg1)->operator +=(arg2);
5089
result = (swig::PySwigIterator *) &_result_ref;
5090
}
5091
}
5092
catch(swig::stop_iteration &_e) {
5093
{
5094
(void)_e;
5095
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5096
SWIG_fail;
5097
}
5098
}
5099
5100
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
5101
return resultobj;
5102
fail:
5103
return NULL;
5104
}
5105
5106
5107
SWIGINTERN PyObject *_wrap_PySwigIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5108
PyObject *resultobj = 0;
5109
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5110
ptrdiff_t arg2 ;
5111
void *argp1 = 0 ;
5112
int res1 = 0 ;
5113
ptrdiff_t val2 ;
5114
int ecode2 = 0 ;
5115
PyObject * obj0 = 0 ;
5116
PyObject * obj1 = 0 ;
5117
swig::PySwigIterator *result = 0 ;
5118
5119
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___isub__",&obj0,&obj1)) SWIG_fail;
5120
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
5121
if (!SWIG_IsOK(res1)) {
5122
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___isub__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5123
}
5124
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5125
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5126
if (!SWIG_IsOK(ecode2)) {
5127
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
5128
}
5129
arg2 = static_cast< ptrdiff_t >(val2);
5130
try {
5131
{
5132
swig::PySwigIterator &_result_ref = (arg1)->operator -=(arg2);
5133
result = (swig::PySwigIterator *) &_result_ref;
5134
}
5135
}
5136
catch(swig::stop_iteration &_e) {
5137
{
5138
(void)_e;
5139
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5140
SWIG_fail;
5141
}
5142
}
5143
5144
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
5145
return resultobj;
5146
fail:
5147
return NULL;
5148
}
5149
5150
5151
SWIGINTERN PyObject *_wrap_PySwigIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5152
PyObject *resultobj = 0;
5153
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5154
ptrdiff_t arg2 ;
5155
void *argp1 = 0 ;
5156
int res1 = 0 ;
5157
ptrdiff_t val2 ;
5158
int ecode2 = 0 ;
5159
PyObject * obj0 = 0 ;
5160
PyObject * obj1 = 0 ;
5161
swig::PySwigIterator *result = 0 ;
5162
5163
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___add__",&obj0,&obj1)) SWIG_fail;
5164
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5165
if (!SWIG_IsOK(res1)) {
5166
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___add__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5167
}
5168
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5169
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5170
if (!SWIG_IsOK(ecode2)) {
5171
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
5172
}
5173
arg2 = static_cast< ptrdiff_t >(val2);
5174
try {
5175
result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator +(arg2);
5176
}
5177
catch(swig::stop_iteration &_e) {
5178
{
5179
(void)_e;
5180
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5181
SWIG_fail;
5182
}
5183
}
5184
5185
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
5186
return resultobj;
5187
fail:
5188
return NULL;
5189
}
5190
5191
5192
SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5193
PyObject *resultobj = 0;
5194
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5195
ptrdiff_t arg2 ;
5196
void *argp1 = 0 ;
5197
int res1 = 0 ;
5198
ptrdiff_t val2 ;
5199
int ecode2 = 0 ;
5200
PyObject * obj0 = 0 ;
5201
PyObject * obj1 = 0 ;
5202
swig::PySwigIterator *result = 0 ;
5203
5204
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
5205
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5206
if (!SWIG_IsOK(res1)) {
5207
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5208
}
5209
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5210
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5211
if (!SWIG_IsOK(ecode2)) {
5212
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
5213
}
5214
arg2 = static_cast< ptrdiff_t >(val2);
5215
try {
5216
result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator -(arg2);
5217
}
5218
catch(swig::stop_iteration &_e) {
5219
{
5220
(void)_e;
5221
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5222
SWIG_fail;
5223
}
5224
}
5225
5226
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
5227
return resultobj;
5228
fail:
5229
return NULL;
5230
}
5231
5232
5233
SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5234
PyObject *resultobj = 0;
5235
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5236
swig::PySwigIterator *arg2 = 0 ;
5237
void *argp1 = 0 ;
5238
int res1 = 0 ;
5239
void *argp2 = 0 ;
5240
int res2 = 0 ;
5241
PyObject * obj0 = 0 ;
5242
PyObject * obj1 = 0 ;
5243
ptrdiff_t result;
5244
5245
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
5246
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5247
if (!SWIG_IsOK(res1)) {
5248
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5249
}
5250
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5251
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
5252
if (!SWIG_IsOK(res2)) {
5253
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5254
}
5255
if (!argp2) {
5256
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5257
}
5258
arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5259
result = ((swig::PySwigIterator const *)arg1)->operator -((swig::PySwigIterator const &)*arg2);
5260
resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
5261
return resultobj;
5262
fail:
5263
return NULL;
5264
}
5265
5266
5267
SWIGINTERN PyObject *_wrap_PySwigIterator___sub__(PyObject *self, PyObject *args) {
5268
int argc;
5269
PyObject *argv[3];
5270
int ii;
5271
5272
if (!PyTuple_Check(args)) SWIG_fail;
5273
argc = (int)PyObject_Length(args);
5274
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5275
argv[ii] = PyTuple_GET_ITEM(args,ii);
5276
}
5277
if (argc == 2) {
5278
int _v;
5279
void *vptr = 0;
5280
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5281
_v = SWIG_CheckState(res);
5282
if (_v) {
5283
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__PySwigIterator, 0);
5284
_v = SWIG_CheckState(res);
5285
if (_v) {
5286
return _wrap_PySwigIterator___sub____SWIG_1(self, args);
5287
}
5288
}
5289
}
5290
if (argc == 2) {
5291
int _v;
5292
void *vptr = 0;
5293
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5294
_v = SWIG_CheckState(res);
5295
if (_v) {
5296
{
5297
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
5298
_v = SWIG_CheckState(res);
5299
}
5300
if (_v) {
5301
return _wrap_PySwigIterator___sub____SWIG_0(self, args);
5302
}
5303
}
5304
}
5305
5306
fail:
5307
Py_INCREF(Py_NotImplemented);
5308
return Py_NotImplemented;
5309
}
5310
5311
5312
SWIGINTERN PyObject *PySwigIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5313
PyObject *obj;
5314
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5315
SWIG_TypeNewClientData(SWIGTYPE_p_swig__PySwigIterator, SWIG_NewClientData(obj));
5316
return SWIG_Py_Void();
5317
}
5318
5319
SWIGINTERN PyObject *_wrap_TestResult_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5320
PyObject *resultobj = 0;
5321
OT::String *result = 0 ;
5322
5323
if (!PyArg_ParseTuple(args,(char *)":TestResult_GetClassName")) SWIG_fail;
5324
{
5325
try {
5326
{
5327
OT::String const &_result_ref = OpenTURNS::Base::Stat::TestResult::GetClassName();
5328
result = (OT::String *) &_result_ref;
5329
}
5330
}
5331
catch (OT::Base::Common::InvalidArgumentException & ex) {
5332
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
5333
}
5334
catch (OT::Base::Common::OutOfBoundException & ex) {
5335
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
5336
}
5337
catch (OT::Base::Common::Exception & ex) {
5338
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
5339
}
5340
catch (std::out_of_range & ex) {
5341
SWIG_exception(SWIG_IndexError,ex.what());
5342
}
5343
catch (std::exception & ex) {
5344
SWIG_exception(SWIG_RuntimeError,ex.what());
5345
}
5346
}
5347
resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
5348
return resultobj;
5349
fail:
5350
return NULL;
5351
}
5352
5353
5354
SWIGINTERN PyObject *_wrap_TestResult_getClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5355
PyObject *resultobj = 0;
5356
OpenTURNS::Base::Stat::TestResult *arg1 = (OpenTURNS::Base::Stat::TestResult *) 0 ;
5357
void *argp1 = 0 ;
5358
int res1 = 0 ;
5359
PyObject * obj0 = 0 ;
5360
OT::String *result = 0 ;
5361
5362
if (!PyArg_ParseTuple(args,(char *)"O:TestResult_getClassName",&obj0)) SWIG_fail;
5363
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0 );
5364
if (!SWIG_IsOK(res1)) {
5365
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResult_getClassName" "', argument " "1"" of type '" "OpenTURNS::Base::Stat::TestResult const *""'");
5366
}
5367
arg1 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp1);
5368
{
5369
try {
5370
{
5371
OT::String const &_result_ref = ((OpenTURNS::Base::Stat::TestResult const *)arg1)->getClassName();
5372
result = (OT::String *) &_result_ref;
5373
}
5374
}
5375
catch (OT::Base::Common::InvalidArgumentException & ex) {
5376
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
5377
}
5378
catch (OT::Base::Common::OutOfBoundException & ex) {
5379
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
5380
}
5381
catch (OT::Base::Common::Exception & ex) {
5382
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
5383
}
5384
catch (std::out_of_range & ex) {
5385
SWIG_exception(SWIG_IndexError,ex.what());
5386
}
5387
catch (std::exception & ex) {
5388
SWIG_exception(SWIG_RuntimeError,ex.what());
5389
}
5390
}
5391
resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
5392
return resultobj;
5393
fail:
5394
return NULL;
5395
}
5396
5397
5398
SWIGINTERN PyObject *_wrap_new_TestResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5399
PyObject *resultobj = 0;
5400
OpenTURNS::Base::Stat::TestResult *result = 0 ;
5401
5402
if (!PyArg_ParseTuple(args,(char *)":new_TestResult")) SWIG_fail;
5403
{
5404
try {
5405
result = (OpenTURNS::Base::Stat::TestResult *)new OpenTURNS::Base::Stat::TestResult();
5406
}
5407
catch (OT::Base::Common::InvalidArgumentException & ex) {
5408
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
5409
}
5410
catch (OT::Base::Common::OutOfBoundException & ex) {
5411
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
5412
}
5413
catch (OT::Base::Common::Exception & ex) {
5414
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
5415
}
5416
catch (std::out_of_range & ex) {
5417
SWIG_exception(SWIG_IndexError,ex.what());
5418
}
5419
catch (std::exception & ex) {
5420
SWIG_exception(SWIG_RuntimeError,ex.what());
5421
}
5422
}
5423
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_NEW | 0 );
5424
return resultobj;
5425
fail:
5426
return NULL;
5427
}
5428
5429
5430
SWIGINTERN PyObject *_wrap_new_TestResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5431
PyObject *resultobj = 0;
5432
OpenTURNS::String *arg1 = 0 ;
5433
OpenTURNS::Bool arg2 ;
5434
OpenTURNS::NumericalScalar arg3 ;
5435
OpenTURNS::NumericalScalar arg4 ;
5436
int res1 = SWIG_OLDOBJ ;
5437
bool val2 ;
5438
int ecode2 = 0 ;
5439
double val3 ;
5440
int ecode3 = 0 ;
5441
double val4 ;
5442
int ecode4 = 0 ;
5443
PyObject * obj0 = 0 ;
5444
PyObject * obj1 = 0 ;
5445
PyObject * obj2 = 0 ;
5446
PyObject * obj3 = 0 ;
5447
OpenTURNS::Base::Stat::TestResult *result = 0 ;
5448
5449
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_TestResult",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5450
{
5451
std::string *ptr = (std::string *)0;
5452
res1 = SWIG_AsPtr_std_string(obj0, &ptr);
5453
if (!SWIG_IsOK(res1)) {
5454
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TestResult" "', argument " "1"" of type '" "OpenTURNS::String const &""'");
5455
}
5456
if (!ptr) {
5457
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TestResult" "', argument " "1"" of type '" "OpenTURNS::String const &""'");
5458
}
5459
arg1 = ptr;
5460
}
5461
ecode2 = SWIG_AsVal_bool(obj1, &val2);
5462
if (!SWIG_IsOK(ecode2)) {
5463
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TestResult" "', argument " "2"" of type '" "OpenTURNS::Bool""'");
5464
}
5465
arg2 = static_cast< OpenTURNS::Bool >(val2);
5466
ecode3 = SWIG_AsVal_double(obj2, &val3);
5467
if (!SWIG_IsOK(ecode3)) {
5468
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TestResult" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
5469
}
5470
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
5471
ecode4 = SWIG_AsVal_double(obj3, &val4);
5472
if (!SWIG_IsOK(ecode4)) {
5473
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TestResult" "', argument " "4"" of type '" "OpenTURNS::NumericalScalar""'");
5474
}
5475
arg4 = static_cast< OpenTURNS::NumericalScalar >(val4);
5476
{
5477
try {
5478
result = (OpenTURNS::Base::Stat::TestResult *)new OpenTURNS::Base::Stat::TestResult((OpenTURNS::String const &)*arg1,arg2,arg3,arg4);
5479
}
5480
catch (OT::Base::Common::InvalidArgumentException & ex) {
5481
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
5482
}
5483
catch (OT::Base::Common::OutOfBoundException & ex) {
5484
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
5485
}
5486
catch (OT::Base::Common::Exception & ex) {
5487
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
5488
}
5489
catch (std::out_of_range & ex) {
5490
SWIG_exception(SWIG_IndexError,ex.what());
5491
}
5492
catch (std::exception & ex) {
5493
SWIG_exception(SWIG_RuntimeError,ex.what());
5494
}
5495
}
5496
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_NEW | 0 );
5497
if (SWIG_IsNewObj(res1)) delete arg1;
5498
return resultobj;
5499
fail:
5500
if (SWIG_IsNewObj(res1)) delete arg1;
5501
return NULL;
5502
}
5503
5504
5505
SWIGINTERN PyObject *_wrap_TestResult_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5506
PyObject *resultobj = 0;
5507
OpenTURNS::Base::Stat::TestResult *arg1 = (OpenTURNS::Base::Stat::TestResult *) 0 ;
5508
void *argp1 = 0 ;
5509
int res1 = 0 ;
5510
PyObject * obj0 = 0 ;
5511
OpenTURNS::Base::Stat::TestResult *result = 0 ;
5512
5513
if (!PyArg_ParseTuple(args,(char *)"O:TestResult_clone",&obj0)) SWIG_fail;
5514
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0 );
5515
if (!SWIG_IsOK(res1)) {
5516
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResult_clone" "', argument " "1"" of type '" "OpenTURNS::Base::Stat::TestResult const *""'");
5517
}
5518
arg1 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp1);
5519
{
5520
try {
5521
result = (OpenTURNS::Base::Stat::TestResult *)((OpenTURNS::Base::Stat::TestResult const *)arg1)->clone();
5522
}
5523
catch (OT::Base::Common::InvalidArgumentException & ex) {
5524
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
5525
}
5526
catch (OT::Base::Common::OutOfBoundException & ex) {
5527
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
5528
}
5529
catch (OT::Base::Common::Exception & ex) {
5530
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
5531
}
5532
catch (std::out_of_range & ex) {
5533
SWIG_exception(SWIG_IndexError,ex.what());
5534
}
5535
catch (std::exception & ex) {
5536
SWIG_exception(SWIG_RuntimeError,ex.what());
5537
}
5538
}
5539
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0 );
5540
return resultobj;
5541
fail:
5542
return NULL;
5543
}
5544
5545
5546
SWIGINTERN PyObject *_wrap_TestResult_setDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5547
PyObject *resultobj = 0;
5548
OpenTURNS::Base::Stat::TestResult *arg1 = (OpenTURNS::Base::Stat::TestResult *) 0 ;
5549
OpenTURNS::Base::Stat::TestResult::Description *arg2 = 0 ;
5550
void *argp1 = 0 ;
5551
int res1 = 0 ;
5552
void *argp2 = 0 ;
5553
int res2 = 0 ;
5554
PyObject * obj0 = 0 ;
5555
PyObject * obj1 = 0 ;
5556
5557
if (!PyArg_ParseTuple(args,(char *)"OO:TestResult_setDescription",&obj0,&obj1)) SWIG_fail;
5558
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0 );
5559
if (!SWIG_IsOK(res1)) {
5560
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResult_setDescription" "', argument " "1"" of type '" "OpenTURNS::Base::Stat::TestResult *""'");
5561
}
5562
arg1 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp1);
5563
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Type__Description, 0 | 0);
5564
if (!SWIG_IsOK(res2)) {
5565
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TestResult_setDescription" "', argument " "2"" of type '" "OpenTURNS::Base::Stat::TestResult::Description const &""'");
5566
}
5567
if (!argp2) {
5568
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TestResult_setDescription" "', argument " "2"" of type '" "OpenTURNS::Base::Stat::TestResult::Description const &""'");
5569
}
5570
arg2 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult::Description * >(argp2);
5571
{
5572
try {
5573
(arg1)->setDescription((OpenTURNS::Base::Stat::TestResult::Description const &)*arg2);
5574
}
5575
catch (OT::Base::Common::InvalidArgumentException & ex) {
5576
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
5577
}
5578
catch (OT::Base::Common::OutOfBoundException & ex) {
5579
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
5580
}
5581
catch (OT::Base::Common::Exception & ex) {
5582
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
5583
}
5584
catch (std::out_of_range & ex) {
5585
SWIG_exception(SWIG_IndexError,ex.what());
5586
}
5587
catch (std::exception & ex) {
5588
SWIG_exception(SWIG_RuntimeError,ex.what());
5589
}
5590
}
5591
resultobj = SWIG_Py_Void();
5592
return resultobj;
5593
fail:
5594
return NULL;
5595
}
5596
5597
5598
SWIGINTERN PyObject *_wrap_TestResult_getDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5599
PyObject *resultobj = 0;
5600
OpenTURNS::Base::Stat::TestResult *arg1 = (OpenTURNS::Base::Stat::TestResult *) 0 ;
5601
void *argp1 = 0 ;
5602
int res1 = 0 ;
5603
PyObject * obj0 = 0 ;
5604
OpenTURNS::Base::Stat::TestResult::Description result;
5605
5606
if (!PyArg_ParseTuple(args,(char *)"O:TestResult_getDescription",&obj0)) SWIG_fail;
5607
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0 );
5608
if (!SWIG_IsOK(res1)) {
5609
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResult_getDescription" "', argument " "1"" of type '" "OpenTURNS::Base::Stat::TestResult const *""'");
5610
}
5611
arg1 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp1);
5612
{
5613
try {
5614
result = ((OpenTURNS::Base::Stat::TestResult const *)arg1)->getDescription();
5615
}
5616
catch (OT::Base::Common::InvalidArgumentException & ex) {
5617
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
5618
}
5619
catch (OT::Base::Common::OutOfBoundException & ex) {
5620
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
5621
}
5622
catch (OT::Base::Common::Exception & ex) {
5623
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
5624
}
5625
catch (std::out_of_range & ex) {
5626
SWIG_exception(SWIG_IndexError,ex.what());
5627
}
5628
catch (std::exception & ex) {
5629
SWIG_exception(SWIG_RuntimeError,ex.what());
5630
}
5631
}
5632
resultobj = SWIG_NewPointerObj((new OpenTURNS::Base::Stat::TestResult::Description(static_cast< const OpenTURNS::Base::Stat::TestResult::Description& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__Description, SWIG_POINTER_OWN | 0 );
5633
return resultobj;
5634
fail:
5635
return NULL;
5636
}
5637
5638
5639
SWIGINTERN PyObject *_wrap_TestResult___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5640
PyObject *resultobj = 0;
5641
OpenTURNS::Base::Stat::TestResult *arg1 = (OpenTURNS::Base::Stat::TestResult *) 0 ;
5642
void *argp1 = 0 ;
5643
int res1 = 0 ;
5644
PyObject * obj0 = 0 ;
5645
OpenTURNS::String result;
5646
5647
if (!PyArg_ParseTuple(args,(char *)"O:TestResult___repr__",&obj0)) SWIG_fail;
5648
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0 );
5649
if (!SWIG_IsOK(res1)) {
5650
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResult___repr__" "', argument " "1"" of type '" "OpenTURNS::Base::Stat::TestResult const *""'");
5651
}
5652
arg1 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp1);
5653
{
5654
try {
5655
result = ((OpenTURNS::Base::Stat::TestResult const *)arg1)->__repr__();
5656
}
5657
catch (OT::Base::Common::InvalidArgumentException & ex) {
5658
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
5659
}
5660
catch (OT::Base::Common::OutOfBoundException & ex) {
5661
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
5662
}
5663
catch (OT::Base::Common::Exception & ex) {
5664
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
5665
}
5666
catch (std::out_of_range & ex) {
5667
SWIG_exception(SWIG_IndexError,ex.what());
5668
}
5669
catch (std::exception & ex) {
5670
SWIG_exception(SWIG_RuntimeError,ex.what());
5671
}
5672
}
5673
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
5674
return resultobj;
5675
fail:
5676
return NULL;
5677
}
5678
5679
5680
SWIGINTERN PyObject *_wrap_TestResult_getBinaryQualityMeasure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5681
PyObject *resultobj = 0;
5682
OpenTURNS::Base::Stat::TestResult *arg1 = (OpenTURNS::Base::Stat::TestResult *) 0 ;
5683
void *argp1 = 0 ;
5684
int res1 = 0 ;
5685
PyObject * obj0 = 0 ;
5686
OpenTURNS::Bool result;
5687
5688
if (!PyArg_ParseTuple(args,(char *)"O:TestResult_getBinaryQualityMeasure",&obj0)) SWIG_fail;
5689
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0 );
5690
if (!SWIG_IsOK(res1)) {
5691
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResult_getBinaryQualityMeasure" "', argument " "1"" of type '" "OpenTURNS::Base::Stat::TestResult const *""'");
5692
}
5693
arg1 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp1);
5694
{
5695
try {
5696
result = (OpenTURNS::Bool)((OpenTURNS::Base::Stat::TestResult const *)arg1)->getBinaryQualityMeasure();
5697
}
5698
catch (OT::Base::Common::InvalidArgumentException & ex) {
5699
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
5700
}
5701
catch (OT::Base::Common::OutOfBoundException & ex) {
5702
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
5703
}
5704
catch (OT::Base::Common::Exception & ex) {
5705
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
5706
}
5707
catch (std::out_of_range & ex) {
5708
SWIG_exception(SWIG_IndexError,ex.what());
5709
}
5710
catch (std::exception & ex) {
5711
SWIG_exception(SWIG_RuntimeError,ex.what());
5712
}
5713
}
5714
resultobj = SWIG_From_bool(static_cast< bool >(result));
5715
return resultobj;
5716
fail:
5717
return NULL;
5718
}
5719
5720
5721
SWIGINTERN PyObject *_wrap_TestResult_getPValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5722
PyObject *resultobj = 0;
5723
OpenTURNS::Base::Stat::TestResult *arg1 = (OpenTURNS::Base::Stat::TestResult *) 0 ;
5724
void *argp1 = 0 ;
5725
int res1 = 0 ;
5726
PyObject * obj0 = 0 ;
5727
OpenTURNS::NumericalScalar result;
5728
5729
if (!PyArg_ParseTuple(args,(char *)"O:TestResult_getPValue",&obj0)) SWIG_fail;
5730
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0 );
5731
if (!SWIG_IsOK(res1)) {
5732
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResult_getPValue" "', argument " "1"" of type '" "OpenTURNS::Base::Stat::TestResult const *""'");
5733
}
5734
arg1 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp1);
5735
{
5736
try {
5737
result = (OpenTURNS::NumericalScalar)((OpenTURNS::Base::Stat::TestResult const *)arg1)->getPValue();
5738
}
5739
catch (OT::Base::Common::InvalidArgumentException & ex) {
5740
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
5741
}
5742
catch (OT::Base::Common::OutOfBoundException & ex) {
5743
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
5744
}
5745
catch (OT::Base::Common::Exception & ex) {
5746
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
5747
}
5748
catch (std::out_of_range & ex) {
5749
SWIG_exception(SWIG_IndexError,ex.what());
5750
}
5751
catch (std::exception & ex) {
5752
SWIG_exception(SWIG_RuntimeError,ex.what());
5753
}
5754
}
5755
resultobj = SWIG_From_double(static_cast< double >(result));
5756
return resultobj;
5757
fail:
5758
return NULL;
5759
}
5760
5761
5762
SWIGINTERN PyObject *_wrap_TestResult_getThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5763
PyObject *resultobj = 0;
5764
OpenTURNS::Base::Stat::TestResult *arg1 = (OpenTURNS::Base::Stat::TestResult *) 0 ;
5765
void *argp1 = 0 ;
5766
int res1 = 0 ;
5767
PyObject * obj0 = 0 ;
5768
OpenTURNS::NumericalScalar result;
5769
5770
if (!PyArg_ParseTuple(args,(char *)"O:TestResult_getThreshold",&obj0)) SWIG_fail;
5771
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0 );
5772
if (!SWIG_IsOK(res1)) {
5773
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResult_getThreshold" "', argument " "1"" of type '" "OpenTURNS::Base::Stat::TestResult const *""'");
5774
}
5775
arg1 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp1);
5776
{
5777
try {
5778
result = (OpenTURNS::NumericalScalar)((OpenTURNS::Base::Stat::TestResult const *)arg1)->getThreshold();
5779
}
5780
catch (OT::Base::Common::InvalidArgumentException & ex) {
5781
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
5782
}
5783
catch (OT::Base::Common::OutOfBoundException & ex) {
5784
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
5785
}
5786
catch (OT::Base::Common::Exception & ex) {
5787
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
5788
}
5789
catch (std::out_of_range & ex) {
5790
SWIG_exception(SWIG_IndexError,ex.what());
5791
}
5792
catch (std::exception & ex) {
5793
SWIG_exception(SWIG_RuntimeError,ex.what());
5794
}
5795
}
5796
resultobj = SWIG_From_double(static_cast< double >(result));
5797
return resultobj;
5798
fail:
5799
return NULL;
5800
}
5801
5802
5803
SWIGINTERN PyObject *_wrap_TestResult_getTestType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5804
PyObject *resultobj = 0;
5805
OpenTURNS::Base::Stat::TestResult *arg1 = (OpenTURNS::Base::Stat::TestResult *) 0 ;
5806
void *argp1 = 0 ;
5807
int res1 = 0 ;
5808
PyObject * obj0 = 0 ;
5809
OpenTURNS::String result;
5810
5811
if (!PyArg_ParseTuple(args,(char *)"O:TestResult_getTestType",&obj0)) SWIG_fail;
5812
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0 );
5813
if (!SWIG_IsOK(res1)) {
5814
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResult_getTestType" "', argument " "1"" of type '" "OpenTURNS::Base::Stat::TestResult const *""'");
5815
}
5816
arg1 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp1);
5817
{
5818
try {
5819
result = ((OpenTURNS::Base::Stat::TestResult const *)arg1)->getTestType();
5820
}
5821
catch (OT::Base::Common::InvalidArgumentException & ex) {
5822
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
5823
}
5824
catch (OT::Base::Common::OutOfBoundException & ex) {
5825
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
5826
}
5827
catch (OT::Base::Common::Exception & ex) {
5828
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
5829
}
5830
catch (std::out_of_range & ex) {
5831
SWIG_exception(SWIG_IndexError,ex.what());
5832
}
5833
catch (std::exception & ex) {
5834
SWIG_exception(SWIG_RuntimeError,ex.what());
5835
}
5836
}
5837
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
5838
return resultobj;
5839
fail:
5840
return NULL;
5841
}
5842
5843
5844
SWIGINTERN PyObject *_wrap_TestResult___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5845
PyObject *resultobj = 0;
5846
OpenTURNS::Base::Stat::TestResult *arg1 = (OpenTURNS::Base::Stat::TestResult *) 0 ;
5847
OpenTURNS::Base::Stat::TestResult *arg2 = 0 ;
5848
void *argp1 = 0 ;
5849
int res1 = 0 ;
5850
void *argp2 = 0 ;
5851
int res2 = 0 ;
5852
PyObject * obj0 = 0 ;
5853
PyObject * obj1 = 0 ;
5854
OpenTURNS::Bool result;
5855
5856
if (!PyArg_ParseTuple(args,(char *)"OO:TestResult___eq__",&obj0,&obj1)) SWIG_fail;
5857
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0 );
5858
if (!SWIG_IsOK(res1)) {
5859
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResult___eq__" "', argument " "1"" of type '" "OpenTURNS::Base::Stat::TestResult const *""'");
5860
}
5861
arg1 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp1);
5862
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0);
5863
if (!SWIG_IsOK(res2)) {
5864
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TestResult___eq__" "', argument " "2"" of type '" "OpenTURNS::Base::Stat::TestResult const &""'");
5865
}
5866
if (!argp2) {
5867
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TestResult___eq__" "', argument " "2"" of type '" "OpenTURNS::Base::Stat::TestResult const &""'");
5868
}
5869
arg2 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp2);
5870
{
5871
try {
5872
result = (OpenTURNS::Bool)((OpenTURNS::Base::Stat::TestResult const *)arg1)->operator ==((OpenTURNS::Base::Stat::TestResult const &)*arg2);
5873
}
5874
catch (OT::Base::Common::InvalidArgumentException & ex) {
5875
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
5876
}
5877
catch (OT::Base::Common::OutOfBoundException & ex) {
5878
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
5879
}
5880
catch (OT::Base::Common::Exception & ex) {
5881
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
5882
}
5883
catch (std::out_of_range & ex) {
5884
SWIG_exception(SWIG_IndexError,ex.what());
5885
}
5886
catch (std::exception & ex) {
5887
SWIG_exception(SWIG_RuntimeError,ex.what());
5888
}
5889
}
5890
resultobj = SWIG_From_bool(static_cast< bool >(result));
5891
return resultobj;
5892
fail:
5893
return NULL;
5894
}
5895
5896
5897
SWIGINTERN PyObject *_wrap_new_TestResult__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5898
PyObject *resultobj = 0;
5899
OpenTURNS::Base::Stat::TestResult *arg1 = 0 ;
5900
void *argp1 = 0 ;
5901
int res1 = 0 ;
5902
PyObject * obj0 = 0 ;
5903
OpenTURNS::Base::Stat::TestResult *result = 0 ;
5904
5905
if (!PyArg_ParseTuple(args,(char *)"O:new_TestResult",&obj0)) SWIG_fail;
5906
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0);
5907
if (!SWIG_IsOK(res1)) {
5908
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TestResult" "', argument " "1"" of type '" "OpenTURNS::Base::Stat::TestResult const &""'");
5909
}
5910
if (!argp1) {
5911
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TestResult" "', argument " "1"" of type '" "OpenTURNS::Base::Stat::TestResult const &""'");
5912
}
5913
arg1 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp1);
5914
{
5915
try {
5916
result = (OpenTURNS::Base::Stat::TestResult *)new_OpenTURNS_Base_Stat_TestResult__SWIG_2((OpenTURNS::Base::Stat::TestResult const &)*arg1);
5917
}
5918
catch (OT::Base::Common::InvalidArgumentException & ex) {
5919
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
5920
}
5921
catch (OT::Base::Common::OutOfBoundException & ex) {
5922
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
5923
}
5924
catch (OT::Base::Common::Exception & ex) {
5925
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
5926
}
5927
catch (std::out_of_range & ex) {
5928
SWIG_exception(SWIG_IndexError,ex.what());
5929
}
5930
catch (std::exception & ex) {
5931
SWIG_exception(SWIG_RuntimeError,ex.what());
5932
}
5933
}
5934
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_NEW | 0 );
5935
return resultobj;
5936
fail:
5937
return NULL;
5938
}
5939
5940
5941
SWIGINTERN PyObject *_wrap_new_TestResult__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5942
PyObject *resultobj = 0;
5943
PyObject *arg1 = (PyObject *) 0 ;
5944
PyObject * obj0 = 0 ;
5945
OpenTURNS::Base::Stat::TestResult *result = 0 ;
5946
5947
if (!PyArg_ParseTuple(args,(char *)"O:new_TestResult",&obj0)) SWIG_fail;
5948
arg1 = obj0;
5949
{
5950
try {
5951
result = (OpenTURNS::Base::Stat::TestResult *)new_OpenTURNS_Base_Stat_TestResult__SWIG_3(arg1);
5952
}
5953
catch (OT::Base::Common::InvalidArgumentException & ex) {
5954
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
5955
}
5956
catch (OT::Base::Common::OutOfBoundException & ex) {
5957
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
5958
}
5959
catch (OT::Base::Common::Exception & ex) {
5960
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
5961
}
5962
catch (std::out_of_range & ex) {
5963
SWIG_exception(SWIG_IndexError,ex.what());
5964
}
5965
catch (std::exception & ex) {
5966
SWIG_exception(SWIG_RuntimeError,ex.what());
5967
}
5968
}
5969
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_NEW | 0 );
5970
return resultobj;
5971
fail:
5972
return NULL;
5973
}
5974
5975
5976
SWIGINTERN PyObject *_wrap_new_TestResult(PyObject *self, PyObject *args) {
5977
int argc;
5978
PyObject *argv[5];
5979
int ii;
5980
5981
if (!PyTuple_Check(args)) SWIG_fail;
5982
argc = (int)PyObject_Length(args);
5983
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
5984
argv[ii] = PyTuple_GET_ITEM(args,ii);
5985
}
5986
if (argc == 0) {
5987
return _wrap_new_TestResult__SWIG_0(self, args);
5988
}
5989
if (argc == 1) {
5990
int _v;
5991
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0);
5992
_v = SWIG_CheckState(res);
5993
if (_v) {
5994
return _wrap_new_TestResult__SWIG_2(self, args);
5995
}
5996
}
5997
if (argc == 1) {
5998
int _v;
5999
_v = (argv[0] != 0);
6000
if (_v) {
6001
return _wrap_new_TestResult__SWIG_3(self, args);
6002
}
6003
}
6004
if (argc == 4) {
6005
int _v;
6006
int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
6007
_v = SWIG_CheckState(res);
6008
if (_v) {
6009
{
6010
int res = SWIG_AsVal_bool(argv[1], NULL);
6011
_v = SWIG_CheckState(res);
6012
}
6013
if (_v) {
6014
{
6015
int res = SWIG_AsVal_double(argv[2], NULL);
6016
_v = SWIG_CheckState(res);
6017
}
6018
if (_v) {
6019
{
6020
int res = SWIG_AsVal_double(argv[3], NULL);
6021
_v = SWIG_CheckState(res);
6022
}
6023
if (_v) {
6024
return _wrap_new_TestResult__SWIG_1(self, args);
6025
}
6026
}
6027
}
6028
}
6029
}
6030
6031
fail:
6032
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TestResult'.\n"
6033
" Possible C/C++ prototypes are:\n"
6034
" OpenTURNS::Base::Stat::TestResult()\n"
6035
" OpenTURNS::Base::Stat::TestResult(OpenTURNS::String const &,OpenTURNS::Bool const,OpenTURNS::NumericalScalar const,OpenTURNS::NumericalScalar const)\n"
6036
" OpenTURNS::Base::Stat::TestResult(OpenTURNS::Base::Stat::TestResult const &)\n"
6037
" OpenTURNS::Base::Stat::TestResult(PyObject *)\n");
6038
return NULL;
6039
}
6040
6041
6042
SWIGINTERN PyObject *_wrap_delete_TestResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6043
PyObject *resultobj = 0;
6044
OpenTURNS::Base::Stat::TestResult *arg1 = (OpenTURNS::Base::Stat::TestResult *) 0 ;
6045
void *argp1 = 0 ;
6046
int res1 = 0 ;
6047
PyObject * obj0 = 0 ;
6048
6049
if (!PyArg_ParseTuple(args,(char *)"O:delete_TestResult",&obj0)) SWIG_fail;
6050
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_DISOWN | 0 );
6051
if (!SWIG_IsOK(res1)) {
6052
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TestResult" "', argument " "1"" of type '" "OpenTURNS::Base::Stat::TestResult *""'");
6053
}
6054
arg1 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp1);
6055
{
6056
try {
6057
delete arg1;
6058
}
6059
catch (OT::Base::Common::InvalidArgumentException & ex) {
6060
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
6061
}
6062
catch (OT::Base::Common::OutOfBoundException & ex) {
6063
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
6064
}
6065
catch (OT::Base::Common::Exception & ex) {
6066
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
6067
}
6068
catch (std::out_of_range & ex) {
6069
SWIG_exception(SWIG_IndexError,ex.what());
6070
}
6071
catch (std::exception & ex) {
6072
SWIG_exception(SWIG_RuntimeError,ex.what());
6073
}
6074
}
6075
resultobj = SWIG_Py_Void();
6076
return resultobj;
6077
fail:
6078
return NULL;
6079
}
6080
6081
6082
SWIGINTERN PyObject *TestResult_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6083
PyObject *obj;
6084
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
6085
SWIG_TypeNewClientData(SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_NewClientData(obj));
6086
return SWIG_Py_Void();
6087
}
6088
6089
SWIGINTERN PyObject *_wrap_new_VisualTest__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6090
PyObject *resultobj = 0;
6091
OpenTURNS::Uncertainty::StatTest::VisualTest *result = 0 ;
6092
6093
if (!PyArg_ParseTuple(args,(char *)":new_VisualTest")) SWIG_fail;
6094
{
6095
try {
6096
result = (OpenTURNS::Uncertainty::StatTest::VisualTest *)new OpenTURNS::Uncertainty::StatTest::VisualTest();
6097
}
6098
catch (OT::Base::Common::InvalidArgumentException & ex) {
6099
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
6100
}
6101
catch (OT::Base::Common::OutOfBoundException & ex) {
6102
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
6103
}
6104
catch (OT::Base::Common::Exception & ex) {
6105
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
6106
}
6107
catch (std::out_of_range & ex) {
6108
SWIG_exception(SWIG_IndexError,ex.what());
6109
}
6110
catch (std::exception & ex) {
6111
SWIG_exception(SWIG_RuntimeError,ex.what());
6112
}
6113
}
6114
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__VisualTest, SWIG_POINTER_NEW | 0 );
6115
return resultobj;
6116
fail:
6117
return NULL;
6118
}
6119
6120
6121
SWIGINTERN PyObject *_wrap_VisualTest_DrawEmpiricalCDF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6122
PyObject *resultobj = 0;
6123
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg1 = 0 ;
6124
OpenTURNS::NumericalScalar arg2 ;
6125
OpenTURNS::NumericalScalar arg3 ;
6126
void *argp1 = 0 ;
6127
int res1 = 0 ;
6128
double val2 ;
6129
int ecode2 = 0 ;
6130
double val3 ;
6131
int ecode3 = 0 ;
6132
PyObject * obj0 = 0 ;
6133
PyObject * obj1 = 0 ;
6134
PyObject * obj2 = 0 ;
6135
OpenTURNS::Uncertainty::StatTest::VisualTest::Graph result;
6136
6137
if (!PyArg_ParseTuple(args,(char *)"OOO:VisualTest_DrawEmpiricalCDF",&obj0,&obj1,&obj2)) SWIG_fail;
6138
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6139
if (!SWIG_IsOK(res1)) {
6140
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualTest_DrawEmpiricalCDF" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6141
}
6142
if (!argp1) {
6143
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawEmpiricalCDF" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6144
}
6145
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp1);
6146
ecode2 = SWIG_AsVal_double(obj1, &val2);
6147
if (!SWIG_IsOK(ecode2)) {
6148
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VisualTest_DrawEmpiricalCDF" "', argument " "2"" of type '" "OpenTURNS::NumericalScalar""'");
6149
}
6150
arg2 = static_cast< OpenTURNS::NumericalScalar >(val2);
6151
ecode3 = SWIG_AsVal_double(obj2, &val3);
6152
if (!SWIG_IsOK(ecode3)) {
6153
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VisualTest_DrawEmpiricalCDF" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
6154
}
6155
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
6156
{
6157
try {
6158
result = OpenTURNS::Uncertainty::StatTest::VisualTest::DrawEmpiricalCDF((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,arg2,arg3);
6159
}
6160
catch (OT::Base::Common::InvalidArgumentException & ex) {
6161
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
6162
}
6163
catch (OT::Base::Common::OutOfBoundException & ex) {
6164
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
6165
}
6166
catch (OT::Base::Common::Exception & ex) {
6167
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
6168
}
6169
catch (std::out_of_range & ex) {
6170
SWIG_exception(SWIG_IndexError,ex.what());
6171
}
6172
catch (std::exception & ex) {
6173
SWIG_exception(SWIG_RuntimeError,ex.what());
6174
}
6175
}
6176
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::VisualTest::Graph(static_cast< const OpenTURNS::Uncertainty::StatTest::VisualTest::Graph& >(result))), SWIGTYPE_p_OpenTURNS__Base__Graph__Graph, SWIG_POINTER_OWN | 0 );
6177
return resultobj;
6178
fail:
6179
return NULL;
6180
}
6181
6182
6183
SWIGINTERN PyObject *_wrap_VisualTest_DrawHistogram__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6184
PyObject *resultobj = 0;
6185
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg1 = 0 ;
6186
OpenTURNS::UnsignedLong arg2 ;
6187
void *argp1 = 0 ;
6188
int res1 = 0 ;
6189
unsigned long val2 ;
6190
int ecode2 = 0 ;
6191
PyObject * obj0 = 0 ;
6192
PyObject * obj1 = 0 ;
6193
OpenTURNS::Uncertainty::StatTest::VisualTest::Graph result;
6194
6195
if (!PyArg_ParseTuple(args,(char *)"OO:VisualTest_DrawHistogram",&obj0,&obj1)) SWIG_fail;
6196
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6197
if (!SWIG_IsOK(res1)) {
6198
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualTest_DrawHistogram" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6199
}
6200
if (!argp1) {
6201
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawHistogram" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6202
}
6203
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp1);
6204
ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
6205
if (!SWIG_IsOK(ecode2)) {
6206
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VisualTest_DrawHistogram" "', argument " "2"" of type '" "OpenTURNS::UnsignedLong""'");
6207
}
6208
arg2 = static_cast< OpenTURNS::UnsignedLong >(val2);
6209
{
6210
try {
6211
result = OpenTURNS::Uncertainty::StatTest::VisualTest::DrawHistogram((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,arg2);
6212
}
6213
catch (OT::Base::Common::InvalidArgumentException & ex) {
6214
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
6215
}
6216
catch (OT::Base::Common::OutOfBoundException & ex) {
6217
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
6218
}
6219
catch (OT::Base::Common::Exception & ex) {
6220
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
6221
}
6222
catch (std::out_of_range & ex) {
6223
SWIG_exception(SWIG_IndexError,ex.what());
6224
}
6225
catch (std::exception & ex) {
6226
SWIG_exception(SWIG_RuntimeError,ex.what());
6227
}
6228
}
6229
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::VisualTest::Graph(static_cast< const OpenTURNS::Uncertainty::StatTest::VisualTest::Graph& >(result))), SWIGTYPE_p_OpenTURNS__Base__Graph__Graph, SWIG_POINTER_OWN | 0 );
6230
return resultobj;
6231
fail:
6232
return NULL;
6233
}
6234
6235
6236
SWIGINTERN PyObject *_wrap_VisualTest_DrawHistogram__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6237
PyObject *resultobj = 0;
6238
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg1 = 0 ;
6239
void *argp1 = 0 ;
6240
int res1 = 0 ;
6241
PyObject * obj0 = 0 ;
6242
OpenTURNS::Uncertainty::StatTest::VisualTest::Graph result;
6243
6244
if (!PyArg_ParseTuple(args,(char *)"O:VisualTest_DrawHistogram",&obj0)) SWIG_fail;
6245
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6246
if (!SWIG_IsOK(res1)) {
6247
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualTest_DrawHistogram" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6248
}
6249
if (!argp1) {
6250
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawHistogram" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6251
}
6252
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp1);
6253
{
6254
try {
6255
result = OpenTURNS::Uncertainty::StatTest::VisualTest::DrawHistogram((OpenTURNS::Base::Stat::NumericalSample const &)*arg1);
6256
}
6257
catch (OT::Base::Common::InvalidArgumentException & ex) {
6258
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
6259
}
6260
catch (OT::Base::Common::OutOfBoundException & ex) {
6261
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
6262
}
6263
catch (OT::Base::Common::Exception & ex) {
6264
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
6265
}
6266
catch (std::out_of_range & ex) {
6267
SWIG_exception(SWIG_IndexError,ex.what());
6268
}
6269
catch (std::exception & ex) {
6270
SWIG_exception(SWIG_RuntimeError,ex.what());
6271
}
6272
}
6273
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::VisualTest::Graph(static_cast< const OpenTURNS::Uncertainty::StatTest::VisualTest::Graph& >(result))), SWIGTYPE_p_OpenTURNS__Base__Graph__Graph, SWIG_POINTER_OWN | 0 );
6274
return resultobj;
6275
fail:
6276
return NULL;
6277
}
6278
6279
6280
SWIGINTERN PyObject *_wrap_VisualTest_DrawHistogram(PyObject *self, PyObject *args) {
6281
int argc;
6282
PyObject *argv[3];
6283
int ii;
6284
6285
if (!PyTuple_Check(args)) SWIG_fail;
6286
argc = (int)PyObject_Length(args);
6287
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
6288
argv[ii] = PyTuple_GET_ITEM(args,ii);
6289
}
6290
if (argc == 1) {
6291
int _v;
6292
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
6293
_v = SWIG_CheckState(res);
6294
if (_v) {
6295
return _wrap_VisualTest_DrawHistogram__SWIG_1(self, args);
6296
}
6297
}
6298
if (argc == 2) {
6299
int _v;
6300
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
6301
_v = SWIG_CheckState(res);
6302
if (_v) {
6303
{
6304
int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
6305
_v = SWIG_CheckState(res);
6306
}
6307
if (_v) {
6308
return _wrap_VisualTest_DrawHistogram__SWIG_0(self, args);
6309
}
6310
}
6311
}
6312
6313
fail:
6314
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VisualTest_DrawHistogram'.\n"
6315
" Possible C/C++ prototypes are:\n"
6316
" DrawHistogram(OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &,OpenTURNS::UnsignedLong const)\n"
6317
" OpenTURNS::Uncertainty::StatTest::VisualTest::DrawHistogram(OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &)\n");
6318
return NULL;
6319
}
6320
6321
6322
SWIGINTERN PyObject *_wrap_VisualTest_DrawQQplot__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6323
PyObject *resultobj = 0;
6324
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg1 = 0 ;
6325
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg2 = 0 ;
6326
OpenTURNS::UnsignedLong arg3 ;
6327
void *argp1 = 0 ;
6328
int res1 = 0 ;
6329
void *argp2 = 0 ;
6330
int res2 = 0 ;
6331
unsigned long val3 ;
6332
int ecode3 = 0 ;
6333
PyObject * obj0 = 0 ;
6334
PyObject * obj1 = 0 ;
6335
PyObject * obj2 = 0 ;
6336
OpenTURNS::Uncertainty::StatTest::VisualTest::Graph result;
6337
6338
if (!PyArg_ParseTuple(args,(char *)"OOO:VisualTest_DrawQQplot",&obj0,&obj1,&obj2)) SWIG_fail;
6339
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6340
if (!SWIG_IsOK(res1)) {
6341
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualTest_DrawQQplot" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6342
}
6343
if (!argp1) {
6344
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawQQplot" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6345
}
6346
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp1);
6347
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6348
if (!SWIG_IsOK(res2)) {
6349
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualTest_DrawQQplot" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6350
}
6351
if (!argp2) {
6352
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawQQplot" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6353
}
6354
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp2);
6355
ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
6356
if (!SWIG_IsOK(ecode3)) {
6357
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VisualTest_DrawQQplot" "', argument " "3"" of type '" "OpenTURNS::UnsignedLong""'");
6358
}
6359
arg3 = static_cast< OpenTURNS::UnsignedLong >(val3);
6360
{
6361
try {
6362
result = OpenTURNS::Uncertainty::StatTest::VisualTest::DrawQQplot((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,arg3);
6363
}
6364
catch (OT::Base::Common::InvalidArgumentException & ex) {
6365
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
6366
}
6367
catch (OT::Base::Common::OutOfBoundException & ex) {
6368
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
6369
}
6370
catch (OT::Base::Common::Exception & ex) {
6371
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
6372
}
6373
catch (std::out_of_range & ex) {
6374
SWIG_exception(SWIG_IndexError,ex.what());
6375
}
6376
catch (std::exception & ex) {
6377
SWIG_exception(SWIG_RuntimeError,ex.what());
6378
}
6379
}
6380
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::VisualTest::Graph(static_cast< const OpenTURNS::Uncertainty::StatTest::VisualTest::Graph& >(result))), SWIGTYPE_p_OpenTURNS__Base__Graph__Graph, SWIG_POINTER_OWN | 0 );
6381
return resultobj;
6382
fail:
6383
return NULL;
6384
}
6385
6386
6387
SWIGINTERN PyObject *_wrap_VisualTest_DrawQQplot__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6388
PyObject *resultobj = 0;
6389
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg1 = 0 ;
6390
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg2 = 0 ;
6391
void *argp1 = 0 ;
6392
int res1 = 0 ;
6393
void *argp2 = 0 ;
6394
int res2 = 0 ;
6395
PyObject * obj0 = 0 ;
6396
PyObject * obj1 = 0 ;
6397
OpenTURNS::Uncertainty::StatTest::VisualTest::Graph result;
6398
6399
if (!PyArg_ParseTuple(args,(char *)"OO:VisualTest_DrawQQplot",&obj0,&obj1)) SWIG_fail;
6400
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6401
if (!SWIG_IsOK(res1)) {
6402
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualTest_DrawQQplot" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6403
}
6404
if (!argp1) {
6405
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawQQplot" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6406
}
6407
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp1);
6408
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6409
if (!SWIG_IsOK(res2)) {
6410
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualTest_DrawQQplot" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6411
}
6412
if (!argp2) {
6413
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawQQplot" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6414
}
6415
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp2);
6416
{
6417
try {
6418
result = OpenTURNS::Uncertainty::StatTest::VisualTest::DrawQQplot((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2);
6419
}
6420
catch (OT::Base::Common::InvalidArgumentException & ex) {
6421
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
6422
}
6423
catch (OT::Base::Common::OutOfBoundException & ex) {
6424
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
6425
}
6426
catch (OT::Base::Common::Exception & ex) {
6427
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
6428
}
6429
catch (std::out_of_range & ex) {
6430
SWIG_exception(SWIG_IndexError,ex.what());
6431
}
6432
catch (std::exception & ex) {
6433
SWIG_exception(SWIG_RuntimeError,ex.what());
6434
}
6435
}
6436
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::VisualTest::Graph(static_cast< const OpenTURNS::Uncertainty::StatTest::VisualTest::Graph& >(result))), SWIGTYPE_p_OpenTURNS__Base__Graph__Graph, SWIG_POINTER_OWN | 0 );
6437
return resultobj;
6438
fail:
6439
return NULL;
6440
}
6441
6442
6443
SWIGINTERN PyObject *_wrap_VisualTest_DrawQQplot__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6444
PyObject *resultobj = 0;
6445
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg1 = 0 ;
6446
OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution *arg2 = 0 ;
6447
OpenTURNS::UnsignedLong arg3 ;
6448
void *argp1 = 0 ;
6449
int res1 = 0 ;
6450
void *argp2 = 0 ;
6451
int res2 = 0 ;
6452
unsigned long val3 ;
6453
int ecode3 = 0 ;
6454
PyObject * obj0 = 0 ;
6455
PyObject * obj1 = 0 ;
6456
PyObject * obj2 = 0 ;
6457
OpenTURNS::Uncertainty::StatTest::VisualTest::Graph result;
6458
6459
if (!PyArg_ParseTuple(args,(char *)"OOO:VisualTest_DrawQQplot",&obj0,&obj1,&obj2)) SWIG_fail;
6460
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6461
if (!SWIG_IsOK(res1)) {
6462
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualTest_DrawQQplot" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6463
}
6464
if (!argp1) {
6465
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawQQplot" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6466
}
6467
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp1);
6468
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0 | 0);
6469
if (!SWIG_IsOK(res2)) {
6470
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualTest_DrawQQplot" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution const &""'");
6471
}
6472
if (!argp2) {
6473
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawQQplot" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution const &""'");
6474
}
6475
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution * >(argp2);
6476
ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
6477
if (!SWIG_IsOK(ecode3)) {
6478
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VisualTest_DrawQQplot" "', argument " "3"" of type '" "OpenTURNS::UnsignedLong""'");
6479
}
6480
arg3 = static_cast< OpenTURNS::UnsignedLong >(val3);
6481
{
6482
try {
6483
result = OpenTURNS::Uncertainty::StatTest::VisualTest::DrawQQplot((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::Distribution const &)*arg2,arg3);
6484
}
6485
catch (OT::Base::Common::InvalidArgumentException & ex) {
6486
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
6487
}
6488
catch (OT::Base::Common::OutOfBoundException & ex) {
6489
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
6490
}
6491
catch (OT::Base::Common::Exception & ex) {
6492
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
6493
}
6494
catch (std::out_of_range & ex) {
6495
SWIG_exception(SWIG_IndexError,ex.what());
6496
}
6497
catch (std::exception & ex) {
6498
SWIG_exception(SWIG_RuntimeError,ex.what());
6499
}
6500
}
6501
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::VisualTest::Graph(static_cast< const OpenTURNS::Uncertainty::StatTest::VisualTest::Graph& >(result))), SWIGTYPE_p_OpenTURNS__Base__Graph__Graph, SWIG_POINTER_OWN | 0 );
6502
return resultobj;
6503
fail:
6504
return NULL;
6505
}
6506
6507
6508
SWIGINTERN PyObject *_wrap_VisualTest_DrawQQplot__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6509
PyObject *resultobj = 0;
6510
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg1 = 0 ;
6511
OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution *arg2 = 0 ;
6512
void *argp1 = 0 ;
6513
int res1 = 0 ;
6514
void *argp2 = 0 ;
6515
int res2 = 0 ;
6516
PyObject * obj0 = 0 ;
6517
PyObject * obj1 = 0 ;
6518
OpenTURNS::Uncertainty::StatTest::VisualTest::Graph result;
6519
6520
if (!PyArg_ParseTuple(args,(char *)"OO:VisualTest_DrawQQplot",&obj0,&obj1)) SWIG_fail;
6521
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6522
if (!SWIG_IsOK(res1)) {
6523
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualTest_DrawQQplot" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6524
}
6525
if (!argp1) {
6526
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawQQplot" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6527
}
6528
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp1);
6529
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0 | 0);
6530
if (!SWIG_IsOK(res2)) {
6531
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualTest_DrawQQplot" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution const &""'");
6532
}
6533
if (!argp2) {
6534
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawQQplot" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution const &""'");
6535
}
6536
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution * >(argp2);
6537
{
6538
try {
6539
result = OpenTURNS::Uncertainty::StatTest::VisualTest::DrawQQplot((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::Distribution const &)*arg2);
6540
}
6541
catch (OT::Base::Common::InvalidArgumentException & ex) {
6542
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
6543
}
6544
catch (OT::Base::Common::OutOfBoundException & ex) {
6545
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
6546
}
6547
catch (OT::Base::Common::Exception & ex) {
6548
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
6549
}
6550
catch (std::out_of_range & ex) {
6551
SWIG_exception(SWIG_IndexError,ex.what());
6552
}
6553
catch (std::exception & ex) {
6554
SWIG_exception(SWIG_RuntimeError,ex.what());
6555
}
6556
}
6557
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::VisualTest::Graph(static_cast< const OpenTURNS::Uncertainty::StatTest::VisualTest::Graph& >(result))), SWIGTYPE_p_OpenTURNS__Base__Graph__Graph, SWIG_POINTER_OWN | 0 );
6558
return resultobj;
6559
fail:
6560
return NULL;
6561
}
6562
6563
6564
SWIGINTERN PyObject *_wrap_VisualTest_DrawQQplot(PyObject *self, PyObject *args) {
6565
int argc;
6566
PyObject *argv[4];
6567
int ii;
6568
6569
if (!PyTuple_Check(args)) SWIG_fail;
6570
argc = (int)PyObject_Length(args);
6571
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
6572
argv[ii] = PyTuple_GET_ITEM(args,ii);
6573
}
6574
if (argc == 2) {
6575
int _v;
6576
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
6577
_v = SWIG_CheckState(res);
6578
if (_v) {
6579
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
6580
_v = SWIG_CheckState(res);
6581
if (_v) {
6582
return _wrap_VisualTest_DrawQQplot__SWIG_1(self, args);
6583
}
6584
}
6585
}
6586
if (argc == 2) {
6587
int _v;
6588
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
6589
_v = SWIG_CheckState(res);
6590
if (_v) {
6591
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0);
6592
_v = SWIG_CheckState(res);
6593
if (_v) {
6594
return _wrap_VisualTest_DrawQQplot__SWIG_3(self, args);
6595
}
6596
}
6597
}
6598
if (argc == 3) {
6599
int _v;
6600
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
6601
_v = SWIG_CheckState(res);
6602
if (_v) {
6603
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0);
6604
_v = SWIG_CheckState(res);
6605
if (_v) {
6606
{
6607
int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
6608
_v = SWIG_CheckState(res);
6609
}
6610
if (_v) {
6611
return _wrap_VisualTest_DrawQQplot__SWIG_2(self, args);
6612
}
6613
}
6614
}
6615
}
6616
if (argc == 3) {
6617
int _v;
6618
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
6619
_v = SWIG_CheckState(res);
6620
if (_v) {
6621
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
6622
_v = SWIG_CheckState(res);
6623
if (_v) {
6624
{
6625
int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
6626
_v = SWIG_CheckState(res);
6627
}
6628
if (_v) {
6629
return _wrap_VisualTest_DrawQQplot__SWIG_0(self, args);
6630
}
6631
}
6632
}
6633
}
6634
6635
fail:
6636
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VisualTest_DrawQQplot'.\n"
6637
" Possible C/C++ prototypes are:\n"
6638
" DrawQQplot(OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &,OpenTURNS::UnsignedLong const)\n"
6639
" DrawQQplot(OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &)\n"
6640
" DrawQQplot(OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution const &,OpenTURNS::UnsignedLong const)\n"
6641
" OpenTURNS::Uncertainty::StatTest::VisualTest::DrawQQplot(OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution const &)\n");
6642
return NULL;
6643
}
6644
6645
6646
SWIGINTERN PyObject *_wrap_VisualTest_DrawHenryLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6647
PyObject *resultobj = 0;
6648
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg1 = 0 ;
6649
void *argp1 = 0 ;
6650
int res1 = 0 ;
6651
PyObject * obj0 = 0 ;
6652
OpenTURNS::Uncertainty::StatTest::VisualTest::Graph result;
6653
6654
if (!PyArg_ParseTuple(args,(char *)"O:VisualTest_DrawHenryLine",&obj0)) SWIG_fail;
6655
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6656
if (!SWIG_IsOK(res1)) {
6657
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualTest_DrawHenryLine" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6658
}
6659
if (!argp1) {
6660
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawHenryLine" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6661
}
6662
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp1);
6663
{
6664
try {
6665
result = OpenTURNS::Uncertainty::StatTest::VisualTest::DrawHenryLine((OpenTURNS::Base::Stat::NumericalSample const &)*arg1);
6666
}
6667
catch (OT::Base::Common::InvalidArgumentException & ex) {
6668
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
6669
}
6670
catch (OT::Base::Common::OutOfBoundException & ex) {
6671
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
6672
}
6673
catch (OT::Base::Common::Exception & ex) {
6674
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
6675
}
6676
catch (std::out_of_range & ex) {
6677
SWIG_exception(SWIG_IndexError,ex.what());
6678
}
6679
catch (std::exception & ex) {
6680
SWIG_exception(SWIG_RuntimeError,ex.what());
6681
}
6682
}
6683
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::VisualTest::Graph(static_cast< const OpenTURNS::Uncertainty::StatTest::VisualTest::Graph& >(result))), SWIGTYPE_p_OpenTURNS__Base__Graph__Graph, SWIG_POINTER_OWN | 0 );
6684
return resultobj;
6685
fail:
6686
return NULL;
6687
}
6688
6689
6690
SWIGINTERN PyObject *_wrap_VisualTest_DrawClouds__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6691
PyObject *resultobj = 0;
6692
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg1 = 0 ;
6693
OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution *arg2 = 0 ;
6694
void *argp1 = 0 ;
6695
int res1 = 0 ;
6696
void *argp2 = 0 ;
6697
int res2 = 0 ;
6698
PyObject * obj0 = 0 ;
6699
PyObject * obj1 = 0 ;
6700
OpenTURNS::Uncertainty::StatTest::VisualTest::Graph result;
6701
6702
if (!PyArg_ParseTuple(args,(char *)"OO:VisualTest_DrawClouds",&obj0,&obj1)) SWIG_fail;
6703
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6704
if (!SWIG_IsOK(res1)) {
6705
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualTest_DrawClouds" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6706
}
6707
if (!argp1) {
6708
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawClouds" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6709
}
6710
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp1);
6711
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0 | 0);
6712
if (!SWIG_IsOK(res2)) {
6713
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualTest_DrawClouds" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution const &""'");
6714
}
6715
if (!argp2) {
6716
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawClouds" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution const &""'");
6717
}
6718
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution * >(argp2);
6719
{
6720
try {
6721
result = OpenTURNS::Uncertainty::StatTest::VisualTest::DrawClouds((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::Distribution const &)*arg2);
6722
}
6723
catch (OT::Base::Common::InvalidArgumentException & ex) {
6724
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
6725
}
6726
catch (OT::Base::Common::OutOfBoundException & ex) {
6727
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
6728
}
6729
catch (OT::Base::Common::Exception & ex) {
6730
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
6731
}
6732
catch (std::out_of_range & ex) {
6733
SWIG_exception(SWIG_IndexError,ex.what());
6734
}
6735
catch (std::exception & ex) {
6736
SWIG_exception(SWIG_RuntimeError,ex.what());
6737
}
6738
}
6739
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::VisualTest::Graph(static_cast< const OpenTURNS::Uncertainty::StatTest::VisualTest::Graph& >(result))), SWIGTYPE_p_OpenTURNS__Base__Graph__Graph, SWIG_POINTER_OWN | 0 );
6740
return resultobj;
6741
fail:
6742
return NULL;
6743
}
6744
6745
6746
SWIGINTERN PyObject *_wrap_VisualTest_DrawClouds__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6747
PyObject *resultobj = 0;
6748
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg1 = 0 ;
6749
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg2 = 0 ;
6750
void *argp1 = 0 ;
6751
int res1 = 0 ;
6752
void *argp2 = 0 ;
6753
int res2 = 0 ;
6754
PyObject * obj0 = 0 ;
6755
PyObject * obj1 = 0 ;
6756
OpenTURNS::Uncertainty::StatTest::VisualTest::Graph result;
6757
6758
if (!PyArg_ParseTuple(args,(char *)"OO:VisualTest_DrawClouds",&obj0,&obj1)) SWIG_fail;
6759
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6760
if (!SWIG_IsOK(res1)) {
6761
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualTest_DrawClouds" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6762
}
6763
if (!argp1) {
6764
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawClouds" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6765
}
6766
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp1);
6767
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6768
if (!SWIG_IsOK(res2)) {
6769
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualTest_DrawClouds" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6770
}
6771
if (!argp2) {
6772
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawClouds" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6773
}
6774
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp2);
6775
{
6776
try {
6777
result = OpenTURNS::Uncertainty::StatTest::VisualTest::DrawClouds((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2);
6778
}
6779
catch (OT::Base::Common::InvalidArgumentException & ex) {
6780
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
6781
}
6782
catch (OT::Base::Common::OutOfBoundException & ex) {
6783
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
6784
}
6785
catch (OT::Base::Common::Exception & ex) {
6786
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
6787
}
6788
catch (std::out_of_range & ex) {
6789
SWIG_exception(SWIG_IndexError,ex.what());
6790
}
6791
catch (std::exception & ex) {
6792
SWIG_exception(SWIG_RuntimeError,ex.what());
6793
}
6794
}
6795
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::VisualTest::Graph(static_cast< const OpenTURNS::Uncertainty::StatTest::VisualTest::Graph& >(result))), SWIGTYPE_p_OpenTURNS__Base__Graph__Graph, SWIG_POINTER_OWN | 0 );
6796
return resultobj;
6797
fail:
6798
return NULL;
6799
}
6800
6801
6802
SWIGINTERN PyObject *_wrap_VisualTest_DrawClouds(PyObject *self, PyObject *args) {
6803
int argc;
6804
PyObject *argv[3];
6805
int ii;
6806
6807
if (!PyTuple_Check(args)) SWIG_fail;
6808
argc = (int)PyObject_Length(args);
6809
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
6810
argv[ii] = PyTuple_GET_ITEM(args,ii);
6811
}
6812
if (argc == 2) {
6813
int _v;
6814
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
6815
_v = SWIG_CheckState(res);
6816
if (_v) {
6817
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0);
6818
_v = SWIG_CheckState(res);
6819
if (_v) {
6820
return _wrap_VisualTest_DrawClouds__SWIG_0(self, args);
6821
}
6822
}
6823
}
6824
if (argc == 2) {
6825
int _v;
6826
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
6827
_v = SWIG_CheckState(res);
6828
if (_v) {
6829
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
6830
_v = SWIG_CheckState(res);
6831
if (_v) {
6832
return _wrap_VisualTest_DrawClouds__SWIG_1(self, args);
6833
}
6834
}
6835
}
6836
6837
fail:
6838
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VisualTest_DrawClouds'.\n"
6839
" Possible C/C++ prototypes are:\n"
6840
" DrawClouds(OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution const &)\n"
6841
" OpenTURNS::Uncertainty::StatTest::VisualTest::DrawClouds(OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &)\n");
6842
return NULL;
6843
}
6844
6845
6846
SWIGINTERN PyObject *_wrap_VisualTest_DrawLMVisualTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6847
PyObject *resultobj = 0;
6848
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg1 = 0 ;
6849
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg2 = 0 ;
6850
OpenTURNS::Uncertainty::StatTest::VisualTest::LinearModel *arg3 = 0 ;
6851
void *argp1 = 0 ;
6852
int res1 = 0 ;
6853
void *argp2 = 0 ;
6854
int res2 = 0 ;
6855
void *argp3 = 0 ;
6856
int res3 = 0 ;
6857
PyObject * obj0 = 0 ;
6858
PyObject * obj1 = 0 ;
6859
PyObject * obj2 = 0 ;
6860
OpenTURNS::Uncertainty::StatTest::VisualTest::Graph result;
6861
6862
if (!PyArg_ParseTuple(args,(char *)"OOO:VisualTest_DrawLMVisualTest",&obj0,&obj1,&obj2)) SWIG_fail;
6863
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6864
if (!SWIG_IsOK(res1)) {
6865
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualTest_DrawLMVisualTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6866
}
6867
if (!argp1) {
6868
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawLMVisualTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6869
}
6870
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp1);
6871
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6872
if (!SWIG_IsOK(res2)) {
6873
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualTest_DrawLMVisualTest" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6874
}
6875
if (!argp2) {
6876
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawLMVisualTest" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6877
}
6878
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp2);
6879
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0 | 0);
6880
if (!SWIG_IsOK(res3)) {
6881
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VisualTest_DrawLMVisualTest" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::LinearModel const &""'");
6882
}
6883
if (!argp3) {
6884
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawLMVisualTest" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::LinearModel const &""'");
6885
}
6886
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::LinearModel * >(argp3);
6887
{
6888
try {
6889
result = OpenTURNS::Uncertainty::StatTest::VisualTest::DrawLMVisualTest((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Stat::LinearModel const &)*arg3);
6890
}
6891
catch (OT::Base::Common::InvalidArgumentException & ex) {
6892
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
6893
}
6894
catch (OT::Base::Common::OutOfBoundException & ex) {
6895
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
6896
}
6897
catch (OT::Base::Common::Exception & ex) {
6898
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
6899
}
6900
catch (std::out_of_range & ex) {
6901
SWIG_exception(SWIG_IndexError,ex.what());
6902
}
6903
catch (std::exception & ex) {
6904
SWIG_exception(SWIG_RuntimeError,ex.what());
6905
}
6906
}
6907
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::VisualTest::Graph(static_cast< const OpenTURNS::Uncertainty::StatTest::VisualTest::Graph& >(result))), SWIGTYPE_p_OpenTURNS__Base__Graph__Graph, SWIG_POINTER_OWN | 0 );
6908
return resultobj;
6909
fail:
6910
return NULL;
6911
}
6912
6913
6914
SWIGINTERN PyObject *_wrap_VisualTest_DrawLMResidualTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6915
PyObject *resultobj = 0;
6916
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg1 = 0 ;
6917
OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *arg2 = 0 ;
6918
OpenTURNS::Uncertainty::StatTest::VisualTest::LinearModel *arg3 = 0 ;
6919
void *argp1 = 0 ;
6920
int res1 = 0 ;
6921
void *argp2 = 0 ;
6922
int res2 = 0 ;
6923
void *argp3 = 0 ;
6924
int res3 = 0 ;
6925
PyObject * obj0 = 0 ;
6926
PyObject * obj1 = 0 ;
6927
PyObject * obj2 = 0 ;
6928
OpenTURNS::Uncertainty::StatTest::VisualTest::Graph result;
6929
6930
if (!PyArg_ParseTuple(args,(char *)"OOO:VisualTest_DrawLMResidualTest",&obj0,&obj1,&obj2)) SWIG_fail;
6931
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6932
if (!SWIG_IsOK(res1)) {
6933
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualTest_DrawLMResidualTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6934
}
6935
if (!argp1) {
6936
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawLMResidualTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6937
}
6938
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp1);
6939
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
6940
if (!SWIG_IsOK(res2)) {
6941
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualTest_DrawLMResidualTest" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6942
}
6943
if (!argp2) {
6944
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawLMResidualTest" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample const &""'");
6945
}
6946
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample * >(argp2);
6947
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0 | 0);
6948
if (!SWIG_IsOK(res3)) {
6949
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VisualTest_DrawLMResidualTest" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::LinearModel const &""'");
6950
}
6951
if (!argp3) {
6952
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VisualTest_DrawLMResidualTest" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest::LinearModel const &""'");
6953
}
6954
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest::LinearModel * >(argp3);
6955
{
6956
try {
6957
result = OpenTURNS::Uncertainty::StatTest::VisualTest::DrawLMResidualTest((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Stat::LinearModel const &)*arg3);
6958
}
6959
catch (OT::Base::Common::InvalidArgumentException & ex) {
6960
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
6961
}
6962
catch (OT::Base::Common::OutOfBoundException & ex) {
6963
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
6964
}
6965
catch (OT::Base::Common::Exception & ex) {
6966
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
6967
}
6968
catch (std::out_of_range & ex) {
6969
SWIG_exception(SWIG_IndexError,ex.what());
6970
}
6971
catch (std::exception & ex) {
6972
SWIG_exception(SWIG_RuntimeError,ex.what());
6973
}
6974
}
6975
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::VisualTest::Graph(static_cast< const OpenTURNS::Uncertainty::StatTest::VisualTest::Graph& >(result))), SWIGTYPE_p_OpenTURNS__Base__Graph__Graph, SWIG_POINTER_OWN | 0 );
6976
return resultobj;
6977
fail:
6978
return NULL;
6979
}
6980
6981
6982
SWIGINTERN PyObject *_wrap_new_VisualTest__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6983
PyObject *resultobj = 0;
6984
OpenTURNS::Uncertainty::StatTest::VisualTest *arg1 = 0 ;
6985
void *argp1 = 0 ;
6986
int res1 = 0 ;
6987
PyObject * obj0 = 0 ;
6988
OpenTURNS::Uncertainty::StatTest::VisualTest *result = 0 ;
6989
6990
if (!PyArg_ParseTuple(args,(char *)"O:new_VisualTest",&obj0)) SWIG_fail;
6991
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__VisualTest, 0 | 0);
6992
if (!SWIG_IsOK(res1)) {
6993
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VisualTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest const &""'");
6994
}
6995
if (!argp1) {
6996
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VisualTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest const &""'");
6997
}
6998
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest * >(argp1);
6999
{
7000
try {
7001
result = (OpenTURNS::Uncertainty::StatTest::VisualTest *)new_OpenTURNS_Uncertainty_StatTest_VisualTest__SWIG_1((OpenTURNS::Uncertainty::StatTest::VisualTest const &)*arg1);
7002
}
7003
catch (OT::Base::Common::InvalidArgumentException & ex) {
7004
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
7005
}
7006
catch (OT::Base::Common::OutOfBoundException & ex) {
7007
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
7008
}
7009
catch (OT::Base::Common::Exception & ex) {
7010
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
7011
}
7012
catch (std::out_of_range & ex) {
7013
SWIG_exception(SWIG_IndexError,ex.what());
7014
}
7015
catch (std::exception & ex) {
7016
SWIG_exception(SWIG_RuntimeError,ex.what());
7017
}
7018
}
7019
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__VisualTest, SWIG_POINTER_NEW | 0 );
7020
return resultobj;
7021
fail:
7022
return NULL;
7023
}
7024
7025
7026
SWIGINTERN PyObject *_wrap_new_VisualTest(PyObject *self, PyObject *args) {
7027
int argc;
7028
PyObject *argv[2];
7029
int ii;
7030
7031
if (!PyTuple_Check(args)) SWIG_fail;
7032
argc = (int)PyObject_Length(args);
7033
for (ii = 0; (ii < argc) && (ii < 1); ii++) {
7034
argv[ii] = PyTuple_GET_ITEM(args,ii);
7035
}
7036
if (argc == 0) {
7037
return _wrap_new_VisualTest__SWIG_0(self, args);
7038
}
7039
if (argc == 1) {
7040
int _v;
7041
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__VisualTest, 0);
7042
_v = SWIG_CheckState(res);
7043
if (_v) {
7044
return _wrap_new_VisualTest__SWIG_1(self, args);
7045
}
7046
}
7047
7048
fail:
7049
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VisualTest'.\n"
7050
" Possible C/C++ prototypes are:\n"
7051
" OpenTURNS::Uncertainty::StatTest::VisualTest()\n"
7052
" OpenTURNS::Uncertainty::StatTest::VisualTest(OpenTURNS::Uncertainty::StatTest::VisualTest const &)\n");
7053
return NULL;
7054
}
7055
7056
7057
SWIGINTERN PyObject *_wrap_delete_VisualTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7058
PyObject *resultobj = 0;
7059
OpenTURNS::Uncertainty::StatTest::VisualTest *arg1 = (OpenTURNS::Uncertainty::StatTest::VisualTest *) 0 ;
7060
void *argp1 = 0 ;
7061
int res1 = 0 ;
7062
PyObject * obj0 = 0 ;
7063
7064
if (!PyArg_ParseTuple(args,(char *)"O:delete_VisualTest",&obj0)) SWIG_fail;
7065
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__VisualTest, SWIG_POINTER_DISOWN | 0 );
7066
if (!SWIG_IsOK(res1)) {
7067
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::VisualTest *""'");
7068
}
7069
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::VisualTest * >(argp1);
7070
{
7071
try {
7072
delete arg1;
7073
}
7074
catch (OT::Base::Common::InvalidArgumentException & ex) {
7075
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
7076
}
7077
catch (OT::Base::Common::OutOfBoundException & ex) {
7078
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
7079
}
7080
catch (OT::Base::Common::Exception & ex) {
7081
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
7082
}
7083
catch (std::out_of_range & ex) {
7084
SWIG_exception(SWIG_IndexError,ex.what());
7085
}
7086
catch (std::exception & ex) {
7087
SWIG_exception(SWIG_RuntimeError,ex.what());
7088
}
7089
}
7090
resultobj = SWIG_Py_Void();
7091
return resultobj;
7092
fail:
7093
return NULL;
7094
}
7095
7096
7097
SWIGINTERN PyObject *VisualTest_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7098
PyObject *obj;
7099
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
7100
SWIG_TypeNewClientData(SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__VisualTest, SWIG_NewClientData(obj));
7101
return SWIG_Py_Void();
7102
}
7103
7104
SWIGINTERN PyObject *_wrap_new_FittingTest__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7105
PyObject *resultobj = 0;
7106
OpenTURNS::Uncertainty::StatTest::FittingTest *result = 0 ;
7107
7108
if (!PyArg_ParseTuple(args,(char *)":new_FittingTest")) SWIG_fail;
7109
{
7110
try {
7111
result = (OpenTURNS::Uncertainty::StatTest::FittingTest *)new OpenTURNS::Uncertainty::StatTest::FittingTest();
7112
}
7113
catch (OT::Base::Common::InvalidArgumentException & ex) {
7114
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
7115
}
7116
catch (OT::Base::Common::OutOfBoundException & ex) {
7117
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
7118
}
7119
catch (OT::Base::Common::Exception & ex) {
7120
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
7121
}
7122
catch (std::out_of_range & ex) {
7123
SWIG_exception(SWIG_IndexError,ex.what());
7124
}
7125
catch (std::exception & ex) {
7126
SWIG_exception(SWIG_RuntimeError,ex.what());
7127
}
7128
}
7129
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__FittingTest, SWIG_POINTER_NEW | 0 );
7130
return resultobj;
7131
fail:
7132
return NULL;
7133
}
7134
7135
7136
SWIGINTERN PyObject *_wrap_FittingTest_BestModelBIC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7137
PyObject *resultobj = 0;
7138
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
7139
OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection *arg2 = 0 ;
7140
void *argp1 = 0 ;
7141
int res1 = 0 ;
7142
void *argp2 = 0 ;
7143
int res2 = 0 ;
7144
PyObject * obj0 = 0 ;
7145
PyObject * obj1 = 0 ;
7146
OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution result;
7147
7148
if (!PyArg_ParseTuple(args,(char *)"OO:FittingTest_BestModelBIC",&obj0,&obj1)) SWIG_fail;
7149
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
7150
if (!SWIG_IsOK(res1)) {
7151
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_BestModelBIC" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7152
}
7153
if (!argp1) {
7154
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BestModelBIC" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7155
}
7156
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
7157
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__DistributionFactory_t, 0 | 0);
7158
if (!SWIG_IsOK(res2)) {
7159
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_BestModelBIC" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection const &""'");
7160
}
7161
if (!argp2) {
7162
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BestModelBIC" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection const &""'");
7163
}
7164
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection * >(argp2);
7165
{
7166
try {
7167
result = OpenTURNS::Uncertainty::StatTest::FittingTest::BestModelBIC((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Type::Collection< OpenTURNS::Uncertainty::Model::DistributionFactory > const &)*arg2);
7168
}
7169
catch (OT::Base::Common::InvalidArgumentException & ex) {
7170
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
7171
}
7172
catch (OT::Base::Common::OutOfBoundException & ex) {
7173
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
7174
}
7175
catch (OT::Base::Common::Exception & ex) {
7176
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
7177
}
7178
catch (std::out_of_range & ex) {
7179
SWIG_exception(SWIG_IndexError,ex.what());
7180
}
7181
catch (std::exception & ex) {
7182
SWIG_exception(SWIG_RuntimeError,ex.what());
7183
}
7184
}
7185
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution& >(result))), SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, SWIG_POINTER_OWN | 0 );
7186
return resultobj;
7187
fail:
7188
return NULL;
7189
}
7190
7191
7192
SWIGINTERN PyObject *_wrap_FittingTest_BestModelBIC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7193
PyObject *resultobj = 0;
7194
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
7195
OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection *arg2 = 0 ;
7196
void *argp1 = 0 ;
7197
int res1 = 0 ;
7198
void *argp2 = 0 ;
7199
int res2 = 0 ;
7200
PyObject * obj0 = 0 ;
7201
PyObject * obj1 = 0 ;
7202
OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution result;
7203
7204
if (!PyArg_ParseTuple(args,(char *)"OO:FittingTest_BestModelBIC",&obj0,&obj1)) SWIG_fail;
7205
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
7206
if (!SWIG_IsOK(res1)) {
7207
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_BestModelBIC" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7208
}
7209
if (!argp1) {
7210
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BestModelBIC" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7211
}
7212
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
7213
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__Distribution_t, 0 | 0);
7214
if (!SWIG_IsOK(res2)) {
7215
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_BestModelBIC" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection const &""'");
7216
}
7217
if (!argp2) {
7218
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BestModelBIC" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection const &""'");
7219
}
7220
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection * >(argp2);
7221
{
7222
try {
7223
result = OpenTURNS::Uncertainty::StatTest::FittingTest::BestModelBIC((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Type::Collection< OpenTURNS::Uncertainty::Model::Distribution > const &)*arg2);
7224
}
7225
catch (OT::Base::Common::InvalidArgumentException & ex) {
7226
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
7227
}
7228
catch (OT::Base::Common::OutOfBoundException & ex) {
7229
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
7230
}
7231
catch (OT::Base::Common::Exception & ex) {
7232
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
7233
}
7234
catch (std::out_of_range & ex) {
7235
SWIG_exception(SWIG_IndexError,ex.what());
7236
}
7237
catch (std::exception & ex) {
7238
SWIG_exception(SWIG_RuntimeError,ex.what());
7239
}
7240
}
7241
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution& >(result))), SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, SWIG_POINTER_OWN | 0 );
7242
return resultobj;
7243
fail:
7244
return NULL;
7245
}
7246
7247
7248
SWIGINTERN PyObject *_wrap_FittingTest_BestModelBIC(PyObject *self, PyObject *args) {
7249
int argc;
7250
PyObject *argv[3];
7251
int ii;
7252
7253
if (!PyTuple_Check(args)) SWIG_fail;
7254
argc = (int)PyObject_Length(args);
7255
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
7256
argv[ii] = PyTuple_GET_ITEM(args,ii);
7257
}
7258
if (argc == 2) {
7259
int _v;
7260
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
7261
_v = SWIG_CheckState(res);
7262
if (_v) {
7263
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__DistributionFactory_t, 0);
7264
_v = SWIG_CheckState(res);
7265
if (_v) {
7266
return _wrap_FittingTest_BestModelBIC__SWIG_0(self, args);
7267
}
7268
}
7269
}
7270
if (argc == 2) {
7271
int _v;
7272
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
7273
_v = SWIG_CheckState(res);
7274
if (_v) {
7275
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__Distribution_t, 0);
7276
_v = SWIG_CheckState(res);
7277
if (_v) {
7278
return _wrap_FittingTest_BestModelBIC__SWIG_1(self, args);
7279
}
7280
}
7281
}
7282
7283
fail:
7284
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FittingTest_BestModelBIC'.\n"
7285
" Possible C/C++ prototypes are:\n"
7286
" BestModelBIC(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection const &)\n"
7287
" OpenTURNS::Uncertainty::StatTest::FittingTest::BestModelBIC(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection const &)\n");
7288
return NULL;
7289
}
7290
7291
7292
SWIGINTERN PyObject *_wrap_FittingTest_BestModelKolmogorov__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7293
PyObject *resultobj = 0;
7294
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
7295
OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection *arg2 = 0 ;
7296
void *argp1 = 0 ;
7297
int res1 = 0 ;
7298
void *argp2 = 0 ;
7299
int res2 = 0 ;
7300
PyObject * obj0 = 0 ;
7301
PyObject * obj1 = 0 ;
7302
OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution result;
7303
7304
if (!PyArg_ParseTuple(args,(char *)"OO:FittingTest_BestModelKolmogorov",&obj0,&obj1)) SWIG_fail;
7305
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
7306
if (!SWIG_IsOK(res1)) {
7307
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_BestModelKolmogorov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7308
}
7309
if (!argp1) {
7310
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BestModelKolmogorov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7311
}
7312
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
7313
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__DistributionFactory_t, 0 | 0);
7314
if (!SWIG_IsOK(res2)) {
7315
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_BestModelKolmogorov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection const &""'");
7316
}
7317
if (!argp2) {
7318
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BestModelKolmogorov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection const &""'");
7319
}
7320
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection * >(argp2);
7321
{
7322
try {
7323
result = OpenTURNS::Uncertainty::StatTest::FittingTest::BestModelKolmogorov((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Type::Collection< OpenTURNS::Uncertainty::Model::DistributionFactory > const &)*arg2);
7324
}
7325
catch (OT::Base::Common::InvalidArgumentException & ex) {
7326
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
7327
}
7328
catch (OT::Base::Common::OutOfBoundException & ex) {
7329
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
7330
}
7331
catch (OT::Base::Common::Exception & ex) {
7332
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
7333
}
7334
catch (std::out_of_range & ex) {
7335
SWIG_exception(SWIG_IndexError,ex.what());
7336
}
7337
catch (std::exception & ex) {
7338
SWIG_exception(SWIG_RuntimeError,ex.what());
7339
}
7340
}
7341
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution& >(result))), SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, SWIG_POINTER_OWN | 0 );
7342
return resultobj;
7343
fail:
7344
return NULL;
7345
}
7346
7347
7348
SWIGINTERN PyObject *_wrap_FittingTest_BestModelKolmogorov__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7349
PyObject *resultobj = 0;
7350
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
7351
OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection *arg2 = 0 ;
7352
void *argp1 = 0 ;
7353
int res1 = 0 ;
7354
void *argp2 = 0 ;
7355
int res2 = 0 ;
7356
PyObject * obj0 = 0 ;
7357
PyObject * obj1 = 0 ;
7358
OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution result;
7359
7360
if (!PyArg_ParseTuple(args,(char *)"OO:FittingTest_BestModelKolmogorov",&obj0,&obj1)) SWIG_fail;
7361
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
7362
if (!SWIG_IsOK(res1)) {
7363
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_BestModelKolmogorov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7364
}
7365
if (!argp1) {
7366
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BestModelKolmogorov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7367
}
7368
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
7369
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__Distribution_t, 0 | 0);
7370
if (!SWIG_IsOK(res2)) {
7371
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_BestModelKolmogorov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection const &""'");
7372
}
7373
if (!argp2) {
7374
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BestModelKolmogorov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection const &""'");
7375
}
7376
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection * >(argp2);
7377
{
7378
try {
7379
result = OpenTURNS::Uncertainty::StatTest::FittingTest::BestModelKolmogorov((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Type::Collection< OpenTURNS::Uncertainty::Model::Distribution > const &)*arg2);
7380
}
7381
catch (OT::Base::Common::InvalidArgumentException & ex) {
7382
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
7383
}
7384
catch (OT::Base::Common::OutOfBoundException & ex) {
7385
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
7386
}
7387
catch (OT::Base::Common::Exception & ex) {
7388
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
7389
}
7390
catch (std::out_of_range & ex) {
7391
SWIG_exception(SWIG_IndexError,ex.what());
7392
}
7393
catch (std::exception & ex) {
7394
SWIG_exception(SWIG_RuntimeError,ex.what());
7395
}
7396
}
7397
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution& >(result))), SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, SWIG_POINTER_OWN | 0 );
7398
return resultobj;
7399
fail:
7400
return NULL;
7401
}
7402
7403
7404
SWIGINTERN PyObject *_wrap_FittingTest_BestModelKolmogorov(PyObject *self, PyObject *args) {
7405
int argc;
7406
PyObject *argv[3];
7407
int ii;
7408
7409
if (!PyTuple_Check(args)) SWIG_fail;
7410
argc = (int)PyObject_Length(args);
7411
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
7412
argv[ii] = PyTuple_GET_ITEM(args,ii);
7413
}
7414
if (argc == 2) {
7415
int _v;
7416
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
7417
_v = SWIG_CheckState(res);
7418
if (_v) {
7419
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__DistributionFactory_t, 0);
7420
_v = SWIG_CheckState(res);
7421
if (_v) {
7422
return _wrap_FittingTest_BestModelKolmogorov__SWIG_0(self, args);
7423
}
7424
}
7425
}
7426
if (argc == 2) {
7427
int _v;
7428
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
7429
_v = SWIG_CheckState(res);
7430
if (_v) {
7431
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__Distribution_t, 0);
7432
_v = SWIG_CheckState(res);
7433
if (_v) {
7434
return _wrap_FittingTest_BestModelKolmogorov__SWIG_1(self, args);
7435
}
7436
}
7437
}
7438
7439
fail:
7440
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FittingTest_BestModelKolmogorov'.\n"
7441
" Possible C/C++ prototypes are:\n"
7442
" BestModelKolmogorov(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection const &)\n"
7443
" OpenTURNS::Uncertainty::StatTest::FittingTest::BestModelKolmogorov(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection const &)\n");
7444
return NULL;
7445
}
7446
7447
7448
SWIGINTERN PyObject *_wrap_FittingTest_BestModelChiSquared__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7449
PyObject *resultobj = 0;
7450
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
7451
OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection *arg2 = 0 ;
7452
void *argp1 = 0 ;
7453
int res1 = 0 ;
7454
void *argp2 = 0 ;
7455
int res2 = 0 ;
7456
PyObject * obj0 = 0 ;
7457
PyObject * obj1 = 0 ;
7458
OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution result;
7459
7460
if (!PyArg_ParseTuple(args,(char *)"OO:FittingTest_BestModelChiSquared",&obj0,&obj1)) SWIG_fail;
7461
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
7462
if (!SWIG_IsOK(res1)) {
7463
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_BestModelChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7464
}
7465
if (!argp1) {
7466
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BestModelChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7467
}
7468
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
7469
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__DistributionFactory_t, 0 | 0);
7470
if (!SWIG_IsOK(res2)) {
7471
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_BestModelChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection const &""'");
7472
}
7473
if (!argp2) {
7474
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BestModelChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection const &""'");
7475
}
7476
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection * >(argp2);
7477
{
7478
try {
7479
result = OpenTURNS::Uncertainty::StatTest::FittingTest::BestModelChiSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Type::Collection< OpenTURNS::Uncertainty::Model::DistributionFactory > const &)*arg2);
7480
}
7481
catch (OT::Base::Common::InvalidArgumentException & ex) {
7482
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
7483
}
7484
catch (OT::Base::Common::OutOfBoundException & ex) {
7485
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
7486
}
7487
catch (OT::Base::Common::Exception & ex) {
7488
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
7489
}
7490
catch (std::out_of_range & ex) {
7491
SWIG_exception(SWIG_IndexError,ex.what());
7492
}
7493
catch (std::exception & ex) {
7494
SWIG_exception(SWIG_RuntimeError,ex.what());
7495
}
7496
}
7497
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution& >(result))), SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, SWIG_POINTER_OWN | 0 );
7498
return resultobj;
7499
fail:
7500
return NULL;
7501
}
7502
7503
7504
SWIGINTERN PyObject *_wrap_FittingTest_BestModelChiSquared__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7505
PyObject *resultobj = 0;
7506
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
7507
OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection *arg2 = 0 ;
7508
void *argp1 = 0 ;
7509
int res1 = 0 ;
7510
void *argp2 = 0 ;
7511
int res2 = 0 ;
7512
PyObject * obj0 = 0 ;
7513
PyObject * obj1 = 0 ;
7514
OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution result;
7515
7516
if (!PyArg_ParseTuple(args,(char *)"OO:FittingTest_BestModelChiSquared",&obj0,&obj1)) SWIG_fail;
7517
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
7518
if (!SWIG_IsOK(res1)) {
7519
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_BestModelChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7520
}
7521
if (!argp1) {
7522
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BestModelChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7523
}
7524
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
7525
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__Distribution_t, 0 | 0);
7526
if (!SWIG_IsOK(res2)) {
7527
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_BestModelChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection const &""'");
7528
}
7529
if (!argp2) {
7530
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BestModelChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection const &""'");
7531
}
7532
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection * >(argp2);
7533
{
7534
try {
7535
result = OpenTURNS::Uncertainty::StatTest::FittingTest::BestModelChiSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Type::Collection< OpenTURNS::Uncertainty::Model::Distribution > const &)*arg2);
7536
}
7537
catch (OT::Base::Common::InvalidArgumentException & ex) {
7538
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
7539
}
7540
catch (OT::Base::Common::OutOfBoundException & ex) {
7541
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
7542
}
7543
catch (OT::Base::Common::Exception & ex) {
7544
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
7545
}
7546
catch (std::out_of_range & ex) {
7547
SWIG_exception(SWIG_IndexError,ex.what());
7548
}
7549
catch (std::exception & ex) {
7550
SWIG_exception(SWIG_RuntimeError,ex.what());
7551
}
7552
}
7553
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution& >(result))), SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, SWIG_POINTER_OWN | 0 );
7554
return resultobj;
7555
fail:
7556
return NULL;
7557
}
7558
7559
7560
SWIGINTERN PyObject *_wrap_FittingTest_BestModelChiSquared(PyObject *self, PyObject *args) {
7561
int argc;
7562
PyObject *argv[3];
7563
int ii;
7564
7565
if (!PyTuple_Check(args)) SWIG_fail;
7566
argc = (int)PyObject_Length(args);
7567
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
7568
argv[ii] = PyTuple_GET_ITEM(args,ii);
7569
}
7570
if (argc == 2) {
7571
int _v;
7572
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
7573
_v = SWIG_CheckState(res);
7574
if (_v) {
7575
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__DistributionFactory_t, 0);
7576
_v = SWIG_CheckState(res);
7577
if (_v) {
7578
return _wrap_FittingTest_BestModelChiSquared__SWIG_0(self, args);
7579
}
7580
}
7581
}
7582
if (argc == 2) {
7583
int _v;
7584
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
7585
_v = SWIG_CheckState(res);
7586
if (_v) {
7587
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__Distribution_t, 0);
7588
_v = SWIG_CheckState(res);
7589
if (_v) {
7590
return _wrap_FittingTest_BestModelChiSquared__SWIG_1(self, args);
7591
}
7592
}
7593
}
7594
7595
fail:
7596
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FittingTest_BestModelChiSquared'.\n"
7597
" Possible C/C++ prototypes are:\n"
7598
" BestModelChiSquared(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection const &)\n"
7599
" OpenTURNS::Uncertainty::StatTest::FittingTest::BestModelChiSquared(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection const &)\n");
7600
return NULL;
7601
}
7602
7603
7604
SWIGINTERN PyObject *_wrap_FittingTest_BIC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7605
PyObject *resultobj = 0;
7606
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
7607
OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution *arg2 = 0 ;
7608
OpenTURNS::UnsignedLong arg3 ;
7609
void *argp1 = 0 ;
7610
int res1 = 0 ;
7611
void *argp2 = 0 ;
7612
int res2 = 0 ;
7613
unsigned long val3 ;
7614
int ecode3 = 0 ;
7615
PyObject * obj0 = 0 ;
7616
PyObject * obj1 = 0 ;
7617
PyObject * obj2 = 0 ;
7618
OpenTURNS::NumericalScalar result;
7619
7620
if (!PyArg_ParseTuple(args,(char *)"OOO:FittingTest_BIC",&obj0,&obj1,&obj2)) SWIG_fail;
7621
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
7622
if (!SWIG_IsOK(res1)) {
7623
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_BIC" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7624
}
7625
if (!argp1) {
7626
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BIC" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7627
}
7628
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
7629
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0 | 0);
7630
if (!SWIG_IsOK(res2)) {
7631
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_BIC" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
7632
}
7633
if (!argp2) {
7634
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BIC" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
7635
}
7636
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution * >(argp2);
7637
ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
7638
if (!SWIG_IsOK(ecode3)) {
7639
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FittingTest_BIC" "', argument " "3"" of type '" "OpenTURNS::UnsignedLong""'");
7640
}
7641
arg3 = static_cast< OpenTURNS::UnsignedLong >(val3);
7642
{
7643
try {
7644
result = (OpenTURNS::NumericalScalar)OpenTURNS::Uncertainty::StatTest::FittingTest::BIC((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::Distribution const &)*arg2,arg3);
7645
}
7646
catch (OT::Base::Common::InvalidArgumentException & ex) {
7647
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
7648
}
7649
catch (OT::Base::Common::OutOfBoundException & ex) {
7650
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
7651
}
7652
catch (OT::Base::Common::Exception & ex) {
7653
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
7654
}
7655
catch (std::out_of_range & ex) {
7656
SWIG_exception(SWIG_IndexError,ex.what());
7657
}
7658
catch (std::exception & ex) {
7659
SWIG_exception(SWIG_RuntimeError,ex.what());
7660
}
7661
}
7662
resultobj = SWIG_From_double(static_cast< double >(result));
7663
return resultobj;
7664
fail:
7665
return NULL;
7666
}
7667
7668
7669
SWIGINTERN PyObject *_wrap_FittingTest_BIC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7670
PyObject *resultobj = 0;
7671
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
7672
OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution *arg2 = 0 ;
7673
void *argp1 = 0 ;
7674
int res1 = 0 ;
7675
void *argp2 = 0 ;
7676
int res2 = 0 ;
7677
PyObject * obj0 = 0 ;
7678
PyObject * obj1 = 0 ;
7679
OpenTURNS::NumericalScalar result;
7680
7681
if (!PyArg_ParseTuple(args,(char *)"OO:FittingTest_BIC",&obj0,&obj1)) SWIG_fail;
7682
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
7683
if (!SWIG_IsOK(res1)) {
7684
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_BIC" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7685
}
7686
if (!argp1) {
7687
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BIC" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7688
}
7689
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
7690
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0 | 0);
7691
if (!SWIG_IsOK(res2)) {
7692
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_BIC" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
7693
}
7694
if (!argp2) {
7695
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BIC" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
7696
}
7697
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution * >(argp2);
7698
{
7699
try {
7700
result = (OpenTURNS::NumericalScalar)OpenTURNS::Uncertainty::StatTest::FittingTest::BIC((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::Distribution const &)*arg2);
7701
}
7702
catch (OT::Base::Common::InvalidArgumentException & ex) {
7703
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
7704
}
7705
catch (OT::Base::Common::OutOfBoundException & ex) {
7706
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
7707
}
7708
catch (OT::Base::Common::Exception & ex) {
7709
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
7710
}
7711
catch (std::out_of_range & ex) {
7712
SWIG_exception(SWIG_IndexError,ex.what());
7713
}
7714
catch (std::exception & ex) {
7715
SWIG_exception(SWIG_RuntimeError,ex.what());
7716
}
7717
}
7718
resultobj = SWIG_From_double(static_cast< double >(result));
7719
return resultobj;
7720
fail:
7721
return NULL;
7722
}
7723
7724
7725
SWIGINTERN PyObject *_wrap_FittingTest_BIC__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7726
PyObject *resultobj = 0;
7727
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
7728
OpenTURNS::Uncertainty::StatTest::FittingTest::Factory *arg2 = 0 ;
7729
void *argp1 = 0 ;
7730
int res1 = 0 ;
7731
void *argp2 = 0 ;
7732
int res2 = 0 ;
7733
PyObject * obj0 = 0 ;
7734
PyObject * obj1 = 0 ;
7735
OpenTURNS::NumericalScalar result;
7736
7737
if (!PyArg_ParseTuple(args,(char *)"OO:FittingTest_BIC",&obj0,&obj1)) SWIG_fail;
7738
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
7739
if (!SWIG_IsOK(res1)) {
7740
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_BIC" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7741
}
7742
if (!argp1) {
7743
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BIC" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7744
}
7745
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
7746
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__DistributionFactory, 0 | 0);
7747
if (!SWIG_IsOK(res2)) {
7748
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_BIC" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Factory const &""'");
7749
}
7750
if (!argp2) {
7751
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_BIC" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Factory const &""'");
7752
}
7753
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::Factory * >(argp2);
7754
{
7755
try {
7756
result = (OpenTURNS::NumericalScalar)OpenTURNS::Uncertainty::StatTest::FittingTest::BIC((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::DistributionFactory const &)*arg2);
7757
}
7758
catch (OT::Base::Common::InvalidArgumentException & ex) {
7759
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
7760
}
7761
catch (OT::Base::Common::OutOfBoundException & ex) {
7762
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
7763
}
7764
catch (OT::Base::Common::Exception & ex) {
7765
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
7766
}
7767
catch (std::out_of_range & ex) {
7768
SWIG_exception(SWIG_IndexError,ex.what());
7769
}
7770
catch (std::exception & ex) {
7771
SWIG_exception(SWIG_RuntimeError,ex.what());
7772
}
7773
}
7774
resultobj = SWIG_From_double(static_cast< double >(result));
7775
return resultobj;
7776
fail:
7777
return NULL;
7778
}
7779
7780
7781
SWIGINTERN PyObject *_wrap_FittingTest_BIC(PyObject *self, PyObject *args) {
7782
int argc;
7783
PyObject *argv[4];
7784
int ii;
7785
7786
if (!PyTuple_Check(args)) SWIG_fail;
7787
argc = (int)PyObject_Length(args);
7788
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
7789
argv[ii] = PyTuple_GET_ITEM(args,ii);
7790
}
7791
if (argc == 2) {
7792
int _v;
7793
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
7794
_v = SWIG_CheckState(res);
7795
if (_v) {
7796
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0);
7797
_v = SWIG_CheckState(res);
7798
if (_v) {
7799
return _wrap_FittingTest_BIC__SWIG_1(self, args);
7800
}
7801
}
7802
}
7803
if (argc == 2) {
7804
int _v;
7805
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
7806
_v = SWIG_CheckState(res);
7807
if (_v) {
7808
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__DistributionFactory, 0);
7809
_v = SWIG_CheckState(res);
7810
if (_v) {
7811
return _wrap_FittingTest_BIC__SWIG_2(self, args);
7812
}
7813
}
7814
}
7815
if (argc == 3) {
7816
int _v;
7817
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
7818
_v = SWIG_CheckState(res);
7819
if (_v) {
7820
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0);
7821
_v = SWIG_CheckState(res);
7822
if (_v) {
7823
{
7824
int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
7825
_v = SWIG_CheckState(res);
7826
}
7827
if (_v) {
7828
return _wrap_FittingTest_BIC__SWIG_0(self, args);
7829
}
7830
}
7831
}
7832
}
7833
7834
fail:
7835
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FittingTest_BIC'.\n"
7836
" Possible C/C++ prototypes are:\n"
7837
" BIC(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &,OpenTURNS::UnsignedLong const)\n"
7838
" BIC(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &)\n"
7839
" OpenTURNS::Uncertainty::StatTest::FittingTest::BIC(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::Factory const &)\n");
7840
return NULL;
7841
}
7842
7843
7844
SWIGINTERN PyObject *_wrap_FittingTest_Kolmogorov__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7845
PyObject *resultobj = 0;
7846
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
7847
OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution *arg2 = 0 ;
7848
OpenTURNS::NumericalScalar arg3 ;
7849
OpenTURNS::UnsignedLong arg4 ;
7850
void *argp1 = 0 ;
7851
int res1 = 0 ;
7852
void *argp2 = 0 ;
7853
int res2 = 0 ;
7854
double val3 ;
7855
int ecode3 = 0 ;
7856
unsigned long val4 ;
7857
int ecode4 = 0 ;
7858
PyObject * obj0 = 0 ;
7859
PyObject * obj1 = 0 ;
7860
PyObject * obj2 = 0 ;
7861
PyObject * obj3 = 0 ;
7862
OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult result;
7863
7864
if (!PyArg_ParseTuple(args,(char *)"OOOO:FittingTest_Kolmogorov",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7865
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
7866
if (!SWIG_IsOK(res1)) {
7867
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_Kolmogorov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7868
}
7869
if (!argp1) {
7870
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_Kolmogorov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7871
}
7872
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
7873
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0 | 0);
7874
if (!SWIG_IsOK(res2)) {
7875
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_Kolmogorov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
7876
}
7877
if (!argp2) {
7878
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_Kolmogorov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
7879
}
7880
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution * >(argp2);
7881
ecode3 = SWIG_AsVal_double(obj2, &val3);
7882
if (!SWIG_IsOK(ecode3)) {
7883
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FittingTest_Kolmogorov" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
7884
}
7885
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
7886
ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
7887
if (!SWIG_IsOK(ecode4)) {
7888
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FittingTest_Kolmogorov" "', argument " "4"" of type '" "OpenTURNS::UnsignedLong""'");
7889
}
7890
arg4 = static_cast< OpenTURNS::UnsignedLong >(val4);
7891
{
7892
try {
7893
result = OpenTURNS::Uncertainty::StatTest::FittingTest::Kolmogorov((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::Distribution const &)*arg2,arg3,arg4);
7894
}
7895
catch (OT::Base::Common::InvalidArgumentException & ex) {
7896
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
7897
}
7898
catch (OT::Base::Common::OutOfBoundException & ex) {
7899
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
7900
}
7901
catch (OT::Base::Common::Exception & ex) {
7902
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
7903
}
7904
catch (std::out_of_range & ex) {
7905
SWIG_exception(SWIG_IndexError,ex.what());
7906
}
7907
catch (std::exception & ex) {
7908
SWIG_exception(SWIG_RuntimeError,ex.what());
7909
}
7910
}
7911
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
7912
return resultobj;
7913
fail:
7914
return NULL;
7915
}
7916
7917
7918
SWIGINTERN PyObject *_wrap_FittingTest_Kolmogorov__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7919
PyObject *resultobj = 0;
7920
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
7921
OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution *arg2 = 0 ;
7922
OpenTURNS::NumericalScalar arg3 ;
7923
void *argp1 = 0 ;
7924
int res1 = 0 ;
7925
void *argp2 = 0 ;
7926
int res2 = 0 ;
7927
double val3 ;
7928
int ecode3 = 0 ;
7929
PyObject * obj0 = 0 ;
7930
PyObject * obj1 = 0 ;
7931
PyObject * obj2 = 0 ;
7932
OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult result;
7933
7934
if (!PyArg_ParseTuple(args,(char *)"OOO:FittingTest_Kolmogorov",&obj0,&obj1,&obj2)) SWIG_fail;
7935
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
7936
if (!SWIG_IsOK(res1)) {
7937
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_Kolmogorov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7938
}
7939
if (!argp1) {
7940
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_Kolmogorov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7941
}
7942
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
7943
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0 | 0);
7944
if (!SWIG_IsOK(res2)) {
7945
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_Kolmogorov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
7946
}
7947
if (!argp2) {
7948
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_Kolmogorov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
7949
}
7950
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution * >(argp2);
7951
ecode3 = SWIG_AsVal_double(obj2, &val3);
7952
if (!SWIG_IsOK(ecode3)) {
7953
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FittingTest_Kolmogorov" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
7954
}
7955
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
7956
{
7957
try {
7958
result = OpenTURNS::Uncertainty::StatTest::FittingTest::Kolmogorov((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::Distribution const &)*arg2,arg3);
7959
}
7960
catch (OT::Base::Common::InvalidArgumentException & ex) {
7961
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
7962
}
7963
catch (OT::Base::Common::OutOfBoundException & ex) {
7964
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
7965
}
7966
catch (OT::Base::Common::Exception & ex) {
7967
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
7968
}
7969
catch (std::out_of_range & ex) {
7970
SWIG_exception(SWIG_IndexError,ex.what());
7971
}
7972
catch (std::exception & ex) {
7973
SWIG_exception(SWIG_RuntimeError,ex.what());
7974
}
7975
}
7976
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
7977
return resultobj;
7978
fail:
7979
return NULL;
7980
}
7981
7982
7983
SWIGINTERN PyObject *_wrap_FittingTest_Kolmogorov__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7984
PyObject *resultobj = 0;
7985
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
7986
OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution *arg2 = 0 ;
7987
void *argp1 = 0 ;
7988
int res1 = 0 ;
7989
void *argp2 = 0 ;
7990
int res2 = 0 ;
7991
PyObject * obj0 = 0 ;
7992
PyObject * obj1 = 0 ;
7993
OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult result;
7994
7995
if (!PyArg_ParseTuple(args,(char *)"OO:FittingTest_Kolmogorov",&obj0,&obj1)) SWIG_fail;
7996
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
7997
if (!SWIG_IsOK(res1)) {
7998
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_Kolmogorov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
7999
}
8000
if (!argp1) {
8001
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_Kolmogorov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
8002
}
8003
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
8004
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0 | 0);
8005
if (!SWIG_IsOK(res2)) {
8006
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_Kolmogorov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
8007
}
8008
if (!argp2) {
8009
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_Kolmogorov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
8010
}
8011
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution * >(argp2);
8012
{
8013
try {
8014
result = OpenTURNS::Uncertainty::StatTest::FittingTest::Kolmogorov((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::Distribution const &)*arg2);
8015
}
8016
catch (OT::Base::Common::InvalidArgumentException & ex) {
8017
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
8018
}
8019
catch (OT::Base::Common::OutOfBoundException & ex) {
8020
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
8021
}
8022
catch (OT::Base::Common::Exception & ex) {
8023
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
8024
}
8025
catch (std::out_of_range & ex) {
8026
SWIG_exception(SWIG_IndexError,ex.what());
8027
}
8028
catch (std::exception & ex) {
8029
SWIG_exception(SWIG_RuntimeError,ex.what());
8030
}
8031
}
8032
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
8033
return resultobj;
8034
fail:
8035
return NULL;
8036
}
8037
8038
8039
SWIGINTERN PyObject *_wrap_FittingTest_Kolmogorov__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8040
PyObject *resultobj = 0;
8041
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
8042
OpenTURNS::Uncertainty::StatTest::FittingTest::Factory *arg2 = 0 ;
8043
OpenTURNS::NumericalScalar arg3 ;
8044
void *argp1 = 0 ;
8045
int res1 = 0 ;
8046
void *argp2 = 0 ;
8047
int res2 = 0 ;
8048
double val3 ;
8049
int ecode3 = 0 ;
8050
PyObject * obj0 = 0 ;
8051
PyObject * obj1 = 0 ;
8052
PyObject * obj2 = 0 ;
8053
OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult result;
8054
8055
if (!PyArg_ParseTuple(args,(char *)"OOO:FittingTest_Kolmogorov",&obj0,&obj1,&obj2)) SWIG_fail;
8056
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
8057
if (!SWIG_IsOK(res1)) {
8058
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_Kolmogorov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
8059
}
8060
if (!argp1) {
8061
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_Kolmogorov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
8062
}
8063
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
8064
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__DistributionFactory, 0 | 0);
8065
if (!SWIG_IsOK(res2)) {
8066
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_Kolmogorov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Factory const &""'");
8067
}
8068
if (!argp2) {
8069
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_Kolmogorov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Factory const &""'");
8070
}
8071
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::Factory * >(argp2);
8072
ecode3 = SWIG_AsVal_double(obj2, &val3);
8073
if (!SWIG_IsOK(ecode3)) {
8074
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FittingTest_Kolmogorov" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
8075
}
8076
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
8077
{
8078
try {
8079
result = OpenTURNS::Uncertainty::StatTest::FittingTest::Kolmogorov((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::DistributionFactory const &)*arg2,arg3);
8080
}
8081
catch (OT::Base::Common::InvalidArgumentException & ex) {
8082
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
8083
}
8084
catch (OT::Base::Common::OutOfBoundException & ex) {
8085
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
8086
}
8087
catch (OT::Base::Common::Exception & ex) {
8088
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
8089
}
8090
catch (std::out_of_range & ex) {
8091
SWIG_exception(SWIG_IndexError,ex.what());
8092
}
8093
catch (std::exception & ex) {
8094
SWIG_exception(SWIG_RuntimeError,ex.what());
8095
}
8096
}
8097
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
8098
return resultobj;
8099
fail:
8100
return NULL;
8101
}
8102
8103
8104
SWIGINTERN PyObject *_wrap_FittingTest_Kolmogorov__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8105
PyObject *resultobj = 0;
8106
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
8107
OpenTURNS::Uncertainty::StatTest::FittingTest::Factory *arg2 = 0 ;
8108
void *argp1 = 0 ;
8109
int res1 = 0 ;
8110
void *argp2 = 0 ;
8111
int res2 = 0 ;
8112
PyObject * obj0 = 0 ;
8113
PyObject * obj1 = 0 ;
8114
OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult result;
8115
8116
if (!PyArg_ParseTuple(args,(char *)"OO:FittingTest_Kolmogorov",&obj0,&obj1)) SWIG_fail;
8117
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
8118
if (!SWIG_IsOK(res1)) {
8119
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_Kolmogorov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
8120
}
8121
if (!argp1) {
8122
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_Kolmogorov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
8123
}
8124
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
8125
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__DistributionFactory, 0 | 0);
8126
if (!SWIG_IsOK(res2)) {
8127
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_Kolmogorov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Factory const &""'");
8128
}
8129
if (!argp2) {
8130
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_Kolmogorov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Factory const &""'");
8131
}
8132
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::Factory * >(argp2);
8133
{
8134
try {
8135
result = OpenTURNS::Uncertainty::StatTest::FittingTest::Kolmogorov((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::DistributionFactory const &)*arg2);
8136
}
8137
catch (OT::Base::Common::InvalidArgumentException & ex) {
8138
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
8139
}
8140
catch (OT::Base::Common::OutOfBoundException & ex) {
8141
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
8142
}
8143
catch (OT::Base::Common::Exception & ex) {
8144
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
8145
}
8146
catch (std::out_of_range & ex) {
8147
SWIG_exception(SWIG_IndexError,ex.what());
8148
}
8149
catch (std::exception & ex) {
8150
SWIG_exception(SWIG_RuntimeError,ex.what());
8151
}
8152
}
8153
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
8154
return resultobj;
8155
fail:
8156
return NULL;
8157
}
8158
8159
8160
SWIGINTERN PyObject *_wrap_FittingTest_Kolmogorov(PyObject *self, PyObject *args) {
8161
int argc;
8162
PyObject *argv[5];
8163
int ii;
8164
8165
if (!PyTuple_Check(args)) SWIG_fail;
8166
argc = (int)PyObject_Length(args);
8167
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
8168
argv[ii] = PyTuple_GET_ITEM(args,ii);
8169
}
8170
if (argc == 2) {
8171
int _v;
8172
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
8173
_v = SWIG_CheckState(res);
8174
if (_v) {
8175
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0);
8176
_v = SWIG_CheckState(res);
8177
if (_v) {
8178
return _wrap_FittingTest_Kolmogorov__SWIG_2(self, args);
8179
}
8180
}
8181
}
8182
if (argc == 2) {
8183
int _v;
8184
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
8185
_v = SWIG_CheckState(res);
8186
if (_v) {
8187
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__DistributionFactory, 0);
8188
_v = SWIG_CheckState(res);
8189
if (_v) {
8190
return _wrap_FittingTest_Kolmogorov__SWIG_4(self, args);
8191
}
8192
}
8193
}
8194
if (argc == 3) {
8195
int _v;
8196
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
8197
_v = SWIG_CheckState(res);
8198
if (_v) {
8199
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__DistributionFactory, 0);
8200
_v = SWIG_CheckState(res);
8201
if (_v) {
8202
{
8203
int res = SWIG_AsVal_double(argv[2], NULL);
8204
_v = SWIG_CheckState(res);
8205
}
8206
if (_v) {
8207
return _wrap_FittingTest_Kolmogorov__SWIG_3(self, args);
8208
}
8209
}
8210
}
8211
}
8212
if (argc == 3) {
8213
int _v;
8214
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
8215
_v = SWIG_CheckState(res);
8216
if (_v) {
8217
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0);
8218
_v = SWIG_CheckState(res);
8219
if (_v) {
8220
{
8221
int res = SWIG_AsVal_double(argv[2], NULL);
8222
_v = SWIG_CheckState(res);
8223
}
8224
if (_v) {
8225
return _wrap_FittingTest_Kolmogorov__SWIG_1(self, args);
8226
}
8227
}
8228
}
8229
}
8230
if (argc == 4) {
8231
int _v;
8232
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
8233
_v = SWIG_CheckState(res);
8234
if (_v) {
8235
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0);
8236
_v = SWIG_CheckState(res);
8237
if (_v) {
8238
{
8239
int res = SWIG_AsVal_double(argv[2], NULL);
8240
_v = SWIG_CheckState(res);
8241
}
8242
if (_v) {
8243
{
8244
int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
8245
_v = SWIG_CheckState(res);
8246
}
8247
if (_v) {
8248
return _wrap_FittingTest_Kolmogorov__SWIG_0(self, args);
8249
}
8250
}
8251
}
8252
}
8253
}
8254
8255
fail:
8256
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FittingTest_Kolmogorov'.\n"
8257
" Possible C/C++ prototypes are:\n"
8258
" Kolmogorov(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &,OpenTURNS::NumericalScalar const,OpenTURNS::UnsignedLong const)\n"
8259
" Kolmogorov(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &,OpenTURNS::NumericalScalar const)\n"
8260
" Kolmogorov(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &)\n"
8261
" Kolmogorov(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::Factory const &,OpenTURNS::NumericalScalar const)\n"
8262
" OpenTURNS::Uncertainty::StatTest::FittingTest::Kolmogorov(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::Factory const &)\n");
8263
return NULL;
8264
}
8265
8266
8267
SWIGINTERN PyObject *_wrap_FittingTest_ChiSquared__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8268
PyObject *resultobj = 0;
8269
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
8270
OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution *arg2 = 0 ;
8271
OpenTURNS::NumericalScalar arg3 ;
8272
OpenTURNS::UnsignedLong arg4 ;
8273
void *argp1 = 0 ;
8274
int res1 = 0 ;
8275
void *argp2 = 0 ;
8276
int res2 = 0 ;
8277
double val3 ;
8278
int ecode3 = 0 ;
8279
unsigned long val4 ;
8280
int ecode4 = 0 ;
8281
PyObject * obj0 = 0 ;
8282
PyObject * obj1 = 0 ;
8283
PyObject * obj2 = 0 ;
8284
PyObject * obj3 = 0 ;
8285
OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult result;
8286
8287
if (!PyArg_ParseTuple(args,(char *)"OOOO:FittingTest_ChiSquared",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8288
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
8289
if (!SWIG_IsOK(res1)) {
8290
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_ChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
8291
}
8292
if (!argp1) {
8293
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_ChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
8294
}
8295
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
8296
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0 | 0);
8297
if (!SWIG_IsOK(res2)) {
8298
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_ChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
8299
}
8300
if (!argp2) {
8301
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_ChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
8302
}
8303
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution * >(argp2);
8304
ecode3 = SWIG_AsVal_double(obj2, &val3);
8305
if (!SWIG_IsOK(ecode3)) {
8306
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FittingTest_ChiSquared" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
8307
}
8308
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
8309
ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
8310
if (!SWIG_IsOK(ecode4)) {
8311
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FittingTest_ChiSquared" "', argument " "4"" of type '" "OpenTURNS::UnsignedLong""'");
8312
}
8313
arg4 = static_cast< OpenTURNS::UnsignedLong >(val4);
8314
{
8315
try {
8316
result = OpenTURNS::Uncertainty::StatTest::FittingTest::ChiSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::Distribution const &)*arg2,arg3,arg4);
8317
}
8318
catch (OT::Base::Common::InvalidArgumentException & ex) {
8319
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
8320
}
8321
catch (OT::Base::Common::OutOfBoundException & ex) {
8322
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
8323
}
8324
catch (OT::Base::Common::Exception & ex) {
8325
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
8326
}
8327
catch (std::out_of_range & ex) {
8328
SWIG_exception(SWIG_IndexError,ex.what());
8329
}
8330
catch (std::exception & ex) {
8331
SWIG_exception(SWIG_RuntimeError,ex.what());
8332
}
8333
}
8334
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
8335
return resultobj;
8336
fail:
8337
return NULL;
8338
}
8339
8340
8341
SWIGINTERN PyObject *_wrap_FittingTest_ChiSquared__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8342
PyObject *resultobj = 0;
8343
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
8344
OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution *arg2 = 0 ;
8345
OpenTURNS::NumericalScalar arg3 ;
8346
void *argp1 = 0 ;
8347
int res1 = 0 ;
8348
void *argp2 = 0 ;
8349
int res2 = 0 ;
8350
double val3 ;
8351
int ecode3 = 0 ;
8352
PyObject * obj0 = 0 ;
8353
PyObject * obj1 = 0 ;
8354
PyObject * obj2 = 0 ;
8355
OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult result;
8356
8357
if (!PyArg_ParseTuple(args,(char *)"OOO:FittingTest_ChiSquared",&obj0,&obj1,&obj2)) SWIG_fail;
8358
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
8359
if (!SWIG_IsOK(res1)) {
8360
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_ChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
8361
}
8362
if (!argp1) {
8363
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_ChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
8364
}
8365
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
8366
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0 | 0);
8367
if (!SWIG_IsOK(res2)) {
8368
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_ChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
8369
}
8370
if (!argp2) {
8371
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_ChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
8372
}
8373
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution * >(argp2);
8374
ecode3 = SWIG_AsVal_double(obj2, &val3);
8375
if (!SWIG_IsOK(ecode3)) {
8376
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FittingTest_ChiSquared" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
8377
}
8378
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
8379
{
8380
try {
8381
result = OpenTURNS::Uncertainty::StatTest::FittingTest::ChiSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::Distribution const &)*arg2,arg3);
8382
}
8383
catch (OT::Base::Common::InvalidArgumentException & ex) {
8384
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
8385
}
8386
catch (OT::Base::Common::OutOfBoundException & ex) {
8387
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
8388
}
8389
catch (OT::Base::Common::Exception & ex) {
8390
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
8391
}
8392
catch (std::out_of_range & ex) {
8393
SWIG_exception(SWIG_IndexError,ex.what());
8394
}
8395
catch (std::exception & ex) {
8396
SWIG_exception(SWIG_RuntimeError,ex.what());
8397
}
8398
}
8399
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
8400
return resultobj;
8401
fail:
8402
return NULL;
8403
}
8404
8405
8406
SWIGINTERN PyObject *_wrap_FittingTest_ChiSquared__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8407
PyObject *resultobj = 0;
8408
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
8409
OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution *arg2 = 0 ;
8410
void *argp1 = 0 ;
8411
int res1 = 0 ;
8412
void *argp2 = 0 ;
8413
int res2 = 0 ;
8414
PyObject * obj0 = 0 ;
8415
PyObject * obj1 = 0 ;
8416
OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult result;
8417
8418
if (!PyArg_ParseTuple(args,(char *)"OO:FittingTest_ChiSquared",&obj0,&obj1)) SWIG_fail;
8419
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
8420
if (!SWIG_IsOK(res1)) {
8421
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_ChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
8422
}
8423
if (!argp1) {
8424
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_ChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
8425
}
8426
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
8427
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0 | 0);
8428
if (!SWIG_IsOK(res2)) {
8429
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_ChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
8430
}
8431
if (!argp2) {
8432
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_ChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &""'");
8433
}
8434
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution * >(argp2);
8435
{
8436
try {
8437
result = OpenTURNS::Uncertainty::StatTest::FittingTest::ChiSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::Distribution const &)*arg2);
8438
}
8439
catch (OT::Base::Common::InvalidArgumentException & ex) {
8440
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
8441
}
8442
catch (OT::Base::Common::OutOfBoundException & ex) {
8443
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
8444
}
8445
catch (OT::Base::Common::Exception & ex) {
8446
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
8447
}
8448
catch (std::out_of_range & ex) {
8449
SWIG_exception(SWIG_IndexError,ex.what());
8450
}
8451
catch (std::exception & ex) {
8452
SWIG_exception(SWIG_RuntimeError,ex.what());
8453
}
8454
}
8455
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
8456
return resultobj;
8457
fail:
8458
return NULL;
8459
}
8460
8461
8462
SWIGINTERN PyObject *_wrap_FittingTest_ChiSquared__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8463
PyObject *resultobj = 0;
8464
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
8465
OpenTURNS::Uncertainty::StatTest::FittingTest::Factory *arg2 = 0 ;
8466
OpenTURNS::NumericalScalar arg3 ;
8467
void *argp1 = 0 ;
8468
int res1 = 0 ;
8469
void *argp2 = 0 ;
8470
int res2 = 0 ;
8471
double val3 ;
8472
int ecode3 = 0 ;
8473
PyObject * obj0 = 0 ;
8474
PyObject * obj1 = 0 ;
8475
PyObject * obj2 = 0 ;
8476
OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult result;
8477
8478
if (!PyArg_ParseTuple(args,(char *)"OOO:FittingTest_ChiSquared",&obj0,&obj1,&obj2)) SWIG_fail;
8479
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
8480
if (!SWIG_IsOK(res1)) {
8481
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_ChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
8482
}
8483
if (!argp1) {
8484
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_ChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
8485
}
8486
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
8487
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__DistributionFactory, 0 | 0);
8488
if (!SWIG_IsOK(res2)) {
8489
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_ChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Factory const &""'");
8490
}
8491
if (!argp2) {
8492
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_ChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Factory const &""'");
8493
}
8494
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::Factory * >(argp2);
8495
ecode3 = SWIG_AsVal_double(obj2, &val3);
8496
if (!SWIG_IsOK(ecode3)) {
8497
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FittingTest_ChiSquared" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
8498
}
8499
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
8500
{
8501
try {
8502
result = OpenTURNS::Uncertainty::StatTest::FittingTest::ChiSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::DistributionFactory const &)*arg2,arg3);
8503
}
8504
catch (OT::Base::Common::InvalidArgumentException & ex) {
8505
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
8506
}
8507
catch (OT::Base::Common::OutOfBoundException & ex) {
8508
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
8509
}
8510
catch (OT::Base::Common::Exception & ex) {
8511
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
8512
}
8513
catch (std::out_of_range & ex) {
8514
SWIG_exception(SWIG_IndexError,ex.what());
8515
}
8516
catch (std::exception & ex) {
8517
SWIG_exception(SWIG_RuntimeError,ex.what());
8518
}
8519
}
8520
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
8521
return resultobj;
8522
fail:
8523
return NULL;
8524
}
8525
8526
8527
SWIGINTERN PyObject *_wrap_FittingTest_ChiSquared__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8528
PyObject *resultobj = 0;
8529
OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *arg1 = 0 ;
8530
OpenTURNS::Uncertainty::StatTest::FittingTest::Factory *arg2 = 0 ;
8531
void *argp1 = 0 ;
8532
int res1 = 0 ;
8533
void *argp2 = 0 ;
8534
int res2 = 0 ;
8535
PyObject * obj0 = 0 ;
8536
PyObject * obj1 = 0 ;
8537
OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult result;
8538
8539
if (!PyArg_ParseTuple(args,(char *)"OO:FittingTest_ChiSquared",&obj0,&obj1)) SWIG_fail;
8540
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
8541
if (!SWIG_IsOK(res1)) {
8542
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingTest_ChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
8543
}
8544
if (!argp1) {
8545
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_ChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &""'");
8546
}
8547
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample * >(argp1);
8548
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__DistributionFactory, 0 | 0);
8549
if (!SWIG_IsOK(res2)) {
8550
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FittingTest_ChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Factory const &""'");
8551
}
8552
if (!argp2) {
8553
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FittingTest_ChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest::Factory const &""'");
8554
}
8555
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest::Factory * >(argp2);
8556
{
8557
try {
8558
result = OpenTURNS::Uncertainty::StatTest::FittingTest::ChiSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Uncertainty::Model::DistributionFactory const &)*arg2);
8559
}
8560
catch (OT::Base::Common::InvalidArgumentException & ex) {
8561
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
8562
}
8563
catch (OT::Base::Common::OutOfBoundException & ex) {
8564
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
8565
}
8566
catch (OT::Base::Common::Exception & ex) {
8567
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
8568
}
8569
catch (std::out_of_range & ex) {
8570
SWIG_exception(SWIG_IndexError,ex.what());
8571
}
8572
catch (std::exception & ex) {
8573
SWIG_exception(SWIG_RuntimeError,ex.what());
8574
}
8575
}
8576
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
8577
return resultobj;
8578
fail:
8579
return NULL;
8580
}
8581
8582
8583
SWIGINTERN PyObject *_wrap_FittingTest_ChiSquared(PyObject *self, PyObject *args) {
8584
int argc;
8585
PyObject *argv[5];
8586
int ii;
8587
8588
if (!PyTuple_Check(args)) SWIG_fail;
8589
argc = (int)PyObject_Length(args);
8590
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
8591
argv[ii] = PyTuple_GET_ITEM(args,ii);
8592
}
8593
if (argc == 2) {
8594
int _v;
8595
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
8596
_v = SWIG_CheckState(res);
8597
if (_v) {
8598
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0);
8599
_v = SWIG_CheckState(res);
8600
if (_v) {
8601
return _wrap_FittingTest_ChiSquared__SWIG_2(self, args);
8602
}
8603
}
8604
}
8605
if (argc == 2) {
8606
int _v;
8607
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
8608
_v = SWIG_CheckState(res);
8609
if (_v) {
8610
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__DistributionFactory, 0);
8611
_v = SWIG_CheckState(res);
8612
if (_v) {
8613
return _wrap_FittingTest_ChiSquared__SWIG_4(self, args);
8614
}
8615
}
8616
}
8617
if (argc == 3) {
8618
int _v;
8619
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
8620
_v = SWIG_CheckState(res);
8621
if (_v) {
8622
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__DistributionFactory, 0);
8623
_v = SWIG_CheckState(res);
8624
if (_v) {
8625
{
8626
int res = SWIG_AsVal_double(argv[2], NULL);
8627
_v = SWIG_CheckState(res);
8628
}
8629
if (_v) {
8630
return _wrap_FittingTest_ChiSquared__SWIG_3(self, args);
8631
}
8632
}
8633
}
8634
}
8635
if (argc == 3) {
8636
int _v;
8637
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
8638
_v = SWIG_CheckState(res);
8639
if (_v) {
8640
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0);
8641
_v = SWIG_CheckState(res);
8642
if (_v) {
8643
{
8644
int res = SWIG_AsVal_double(argv[2], NULL);
8645
_v = SWIG_CheckState(res);
8646
}
8647
if (_v) {
8648
return _wrap_FittingTest_ChiSquared__SWIG_1(self, args);
8649
}
8650
}
8651
}
8652
}
8653
if (argc == 4) {
8654
int _v;
8655
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
8656
_v = SWIG_CheckState(res);
8657
if (_v) {
8658
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__Model__Distribution, 0);
8659
_v = SWIG_CheckState(res);
8660
if (_v) {
8661
{
8662
int res = SWIG_AsVal_double(argv[2], NULL);
8663
_v = SWIG_CheckState(res);
8664
}
8665
if (_v) {
8666
{
8667
int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
8668
_v = SWIG_CheckState(res);
8669
}
8670
if (_v) {
8671
return _wrap_FittingTest_ChiSquared__SWIG_0(self, args);
8672
}
8673
}
8674
}
8675
}
8676
}
8677
8678
fail:
8679
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FittingTest_ChiSquared'.\n"
8680
" Possible C/C++ prototypes are:\n"
8681
" ChiSquared(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &,OpenTURNS::NumericalScalar const,OpenTURNS::UnsignedLong const)\n"
8682
" ChiSquared(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &,OpenTURNS::NumericalScalar const)\n"
8683
" ChiSquared(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution const &)\n"
8684
" ChiSquared(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::Factory const &,OpenTURNS::NumericalScalar const)\n"
8685
" OpenTURNS::Uncertainty::StatTest::FittingTest::ChiSquared(OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::FittingTest::Factory const &)\n");
8686
return NULL;
8687
}
8688
8689
8690
SWIGINTERN PyObject *_wrap_FittingTest_GetLastResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8691
PyObject *resultobj = 0;
8692
OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult result;
8693
8694
if (!PyArg_ParseTuple(args,(char *)":FittingTest_GetLastResult")) SWIG_fail;
8695
{
8696
try {
8697
result = OpenTURNS::Uncertainty::StatTest::FittingTest::GetLastResult();
8698
}
8699
catch (OT::Base::Common::InvalidArgumentException & ex) {
8700
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
8701
}
8702
catch (OT::Base::Common::OutOfBoundException & ex) {
8703
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
8704
}
8705
catch (OT::Base::Common::Exception & ex) {
8706
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
8707
}
8708
catch (std::out_of_range & ex) {
8709
SWIG_exception(SWIG_IndexError,ex.what());
8710
}
8711
catch (std::exception & ex) {
8712
SWIG_exception(SWIG_RuntimeError,ex.what());
8713
}
8714
}
8715
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
8716
return resultobj;
8717
fail:
8718
return NULL;
8719
}
8720
8721
8722
SWIGINTERN PyObject *_wrap_new_FittingTest__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8723
PyObject *resultobj = 0;
8724
OpenTURNS::Uncertainty::StatTest::FittingTest *arg1 = 0 ;
8725
void *argp1 = 0 ;
8726
int res1 = 0 ;
8727
PyObject * obj0 = 0 ;
8728
OpenTURNS::Uncertainty::StatTest::FittingTest *result = 0 ;
8729
8730
if (!PyArg_ParseTuple(args,(char *)"O:new_FittingTest",&obj0)) SWIG_fail;
8731
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__FittingTest, 0 | 0);
8732
if (!SWIG_IsOK(res1)) {
8733
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FittingTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest const &""'");
8734
}
8735
if (!argp1) {
8736
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittingTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest const &""'");
8737
}
8738
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest * >(argp1);
8739
{
8740
try {
8741
result = (OpenTURNS::Uncertainty::StatTest::FittingTest *)new_OpenTURNS_Uncertainty_StatTest_FittingTest__SWIG_1((OpenTURNS::Uncertainty::StatTest::FittingTest const &)*arg1);
8742
}
8743
catch (OT::Base::Common::InvalidArgumentException & ex) {
8744
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
8745
}
8746
catch (OT::Base::Common::OutOfBoundException & ex) {
8747
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
8748
}
8749
catch (OT::Base::Common::Exception & ex) {
8750
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
8751
}
8752
catch (std::out_of_range & ex) {
8753
SWIG_exception(SWIG_IndexError,ex.what());
8754
}
8755
catch (std::exception & ex) {
8756
SWIG_exception(SWIG_RuntimeError,ex.what());
8757
}
8758
}
8759
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__FittingTest, SWIG_POINTER_NEW | 0 );
8760
return resultobj;
8761
fail:
8762
return NULL;
8763
}
8764
8765
8766
SWIGINTERN PyObject *_wrap_new_FittingTest(PyObject *self, PyObject *args) {
8767
int argc;
8768
PyObject *argv[2];
8769
int ii;
8770
8771
if (!PyTuple_Check(args)) SWIG_fail;
8772
argc = (int)PyObject_Length(args);
8773
for (ii = 0; (ii < argc) && (ii < 1); ii++) {
8774
argv[ii] = PyTuple_GET_ITEM(args,ii);
8775
}
8776
if (argc == 0) {
8777
return _wrap_new_FittingTest__SWIG_0(self, args);
8778
}
8779
if (argc == 1) {
8780
int _v;
8781
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__FittingTest, 0);
8782
_v = SWIG_CheckState(res);
8783
if (_v) {
8784
return _wrap_new_FittingTest__SWIG_1(self, args);
8785
}
8786
}
8787
8788
fail:
8789
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FittingTest'.\n"
8790
" Possible C/C++ prototypes are:\n"
8791
" OpenTURNS::Uncertainty::StatTest::FittingTest()\n"
8792
" OpenTURNS::Uncertainty::StatTest::FittingTest(OpenTURNS::Uncertainty::StatTest::FittingTest const &)\n");
8793
return NULL;
8794
}
8795
8796
8797
SWIGINTERN PyObject *_wrap_delete_FittingTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8798
PyObject *resultobj = 0;
8799
OpenTURNS::Uncertainty::StatTest::FittingTest *arg1 = (OpenTURNS::Uncertainty::StatTest::FittingTest *) 0 ;
8800
void *argp1 = 0 ;
8801
int res1 = 0 ;
8802
PyObject * obj0 = 0 ;
8803
8804
if (!PyArg_ParseTuple(args,(char *)"O:delete_FittingTest",&obj0)) SWIG_fail;
8805
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__FittingTest, SWIG_POINTER_DISOWN | 0 );
8806
if (!SWIG_IsOK(res1)) {
8807
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FittingTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::FittingTest *""'");
8808
}
8809
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::FittingTest * >(argp1);
8810
{
8811
try {
8812
delete arg1;
8813
}
8814
catch (OT::Base::Common::InvalidArgumentException & ex) {
8815
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
8816
}
8817
catch (OT::Base::Common::OutOfBoundException & ex) {
8818
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
8819
}
8820
catch (OT::Base::Common::Exception & ex) {
8821
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
8822
}
8823
catch (std::out_of_range & ex) {
8824
SWIG_exception(SWIG_IndexError,ex.what());
8825
}
8826
catch (std::exception & ex) {
8827
SWIG_exception(SWIG_RuntimeError,ex.what());
8828
}
8829
}
8830
resultobj = SWIG_Py_Void();
8831
return resultobj;
8832
fail:
8833
return NULL;
8834
}
8835
8836
8837
SWIGINTERN PyObject *FittingTest_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8838
PyObject *obj;
8839
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
8840
SWIG_TypeNewClientData(SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__FittingTest, SWIG_NewClientData(obj));
8841
return SWIG_Py_Void();
8842
}
8843
8844
SWIGINTERN PyObject *_wrap_new_TestResultCollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8845
PyObject *resultobj = 0;
8846
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *result = 0 ;
8847
8848
if (!PyArg_ParseTuple(args,(char *)":new_TestResultCollection")) SWIG_fail;
8849
{
8850
try {
8851
result = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *)new OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult >();
8852
}
8853
catch (OT::Base::Common::InvalidArgumentException & ex) {
8854
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
8855
}
8856
catch (OT::Base::Common::OutOfBoundException & ex) {
8857
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
8858
}
8859
catch (OT::Base::Common::Exception & ex) {
8860
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
8861
}
8862
catch (std::out_of_range & ex) {
8863
SWIG_exception(SWIG_IndexError,ex.what());
8864
}
8865
catch (std::exception & ex) {
8866
SWIG_exception(SWIG_RuntimeError,ex.what());
8867
}
8868
}
8869
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_NEW | 0 );
8870
return resultobj;
8871
fail:
8872
return NULL;
8873
}
8874
8875
8876
SWIGINTERN PyObject *_wrap_new_TestResultCollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8877
PyObject *resultobj = 0;
8878
OpenTURNS::UnsignedLong arg1 ;
8879
unsigned long val1 ;
8880
int ecode1 = 0 ;
8881
PyObject * obj0 = 0 ;
8882
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *result = 0 ;
8883
8884
if (!PyArg_ParseTuple(args,(char *)"O:new_TestResultCollection",&obj0)) SWIG_fail;
8885
ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
8886
if (!SWIG_IsOK(ecode1)) {
8887
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TestResultCollection" "', argument " "1"" of type '" "OpenTURNS::UnsignedLong""'");
8888
}
8889
arg1 = static_cast< OpenTURNS::UnsignedLong >(val1);
8890
{
8891
try {
8892
result = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *)new OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult >(arg1);
8893
}
8894
catch (OT::Base::Common::InvalidArgumentException & ex) {
8895
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
8896
}
8897
catch (OT::Base::Common::OutOfBoundException & ex) {
8898
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
8899
}
8900
catch (OT::Base::Common::Exception & ex) {
8901
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
8902
}
8903
catch (std::out_of_range & ex) {
8904
SWIG_exception(SWIG_IndexError,ex.what());
8905
}
8906
catch (std::exception & ex) {
8907
SWIG_exception(SWIG_RuntimeError,ex.what());
8908
}
8909
}
8910
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_NEW | 0 );
8911
return resultobj;
8912
fail:
8913
return NULL;
8914
}
8915
8916
8917
SWIGINTERN PyObject *_wrap_new_TestResultCollection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8918
PyObject *resultobj = 0;
8919
OpenTURNS::UnsignedLong arg1 ;
8920
OpenTURNS::Base::Stat::TestResult *arg2 = 0 ;
8921
unsigned long val1 ;
8922
int ecode1 = 0 ;
8923
void *argp2 = 0 ;
8924
int res2 = 0 ;
8925
PyObject * obj0 = 0 ;
8926
PyObject * obj1 = 0 ;
8927
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *result = 0 ;
8928
8929
if (!PyArg_ParseTuple(args,(char *)"OO:new_TestResultCollection",&obj0,&obj1)) SWIG_fail;
8930
ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
8931
if (!SWIG_IsOK(ecode1)) {
8932
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TestResultCollection" "', argument " "1"" of type '" "OpenTURNS::UnsignedLong""'");
8933
}
8934
arg1 = static_cast< OpenTURNS::UnsignedLong >(val1);
8935
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0);
8936
if (!SWIG_IsOK(res2)) {
8937
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TestResultCollection" "', argument " "2"" of type '" "OpenTURNS::Base::Stat::TestResult const &""'");
8938
}
8939
if (!argp2) {
8940
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TestResultCollection" "', argument " "2"" of type '" "OpenTURNS::Base::Stat::TestResult const &""'");
8941
}
8942
arg2 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp2);
8943
{
8944
try {
8945
result = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *)new OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult >(arg1,(OpenTURNS::Base::Stat::TestResult const &)*arg2);
8946
}
8947
catch (OT::Base::Common::InvalidArgumentException & ex) {
8948
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
8949
}
8950
catch (OT::Base::Common::OutOfBoundException & ex) {
8951
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
8952
}
8953
catch (OT::Base::Common::Exception & ex) {
8954
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
8955
}
8956
catch (std::out_of_range & ex) {
8957
SWIG_exception(SWIG_IndexError,ex.what());
8958
}
8959
catch (std::exception & ex) {
8960
SWIG_exception(SWIG_RuntimeError,ex.what());
8961
}
8962
}
8963
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_NEW | 0 );
8964
return resultobj;
8965
fail:
8966
return NULL;
8967
}
8968
8969
8970
SWIGINTERN PyObject *_wrap_TestResultCollection_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8971
PyObject *resultobj = 0;
8972
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
8973
void *argp1 = 0 ;
8974
int res1 = 0 ;
8975
PyObject * obj0 = 0 ;
8976
8977
if (!PyArg_ParseTuple(args,(char *)"O:TestResultCollection_clear",&obj0)) SWIG_fail;
8978
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0 );
8979
if (!SWIG_IsOK(res1)) {
8980
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResultCollection_clear" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *""'");
8981
}
8982
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
8983
{
8984
try {
8985
(arg1)->clear();
8986
}
8987
catch (OT::Base::Common::InvalidArgumentException & ex) {
8988
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
8989
}
8990
catch (OT::Base::Common::OutOfBoundException & ex) {
8991
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
8992
}
8993
catch (OT::Base::Common::Exception & ex) {
8994
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
8995
}
8996
catch (std::out_of_range & ex) {
8997
SWIG_exception(SWIG_IndexError,ex.what());
8998
}
8999
catch (std::exception & ex) {
9000
SWIG_exception(SWIG_RuntimeError,ex.what());
9001
}
9002
}
9003
resultobj = SWIG_Py_Void();
9004
return resultobj;
9005
fail:
9006
return NULL;
9007
}
9008
9009
9010
SWIGINTERN PyObject *_wrap_TestResultCollection___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9011
PyObject *resultobj = 0;
9012
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
9013
void *argp1 = 0 ;
9014
int res1 = 0 ;
9015
PyObject * obj0 = 0 ;
9016
OpenTURNS::UnsignedLong result;
9017
9018
if (!PyArg_ParseTuple(args,(char *)"O:TestResultCollection___len__",&obj0)) SWIG_fail;
9019
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0 );
9020
if (!SWIG_IsOK(res1)) {
9021
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResultCollection___len__" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *""'");
9022
}
9023
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
9024
{
9025
try {
9026
result = (OpenTURNS::UnsignedLong)((OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *)arg1)->__len__();
9027
}
9028
catch (OT::Base::Common::InvalidArgumentException & ex) {
9029
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9030
}
9031
catch (OT::Base::Common::OutOfBoundException & ex) {
9032
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9033
}
9034
catch (OT::Base::Common::Exception & ex) {
9035
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9036
}
9037
catch (std::out_of_range & ex) {
9038
SWIG_exception(SWIG_IndexError,ex.what());
9039
}
9040
catch (std::exception & ex) {
9041
SWIG_exception(SWIG_RuntimeError,ex.what());
9042
}
9043
}
9044
resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
9045
return resultobj;
9046
fail:
9047
return NULL;
9048
}
9049
9050
9051
SWIGINTERN PyObject *_wrap_TestResultCollection___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9052
PyObject *resultobj = 0;
9053
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
9054
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg2 = 0 ;
9055
void *argp1 = 0 ;
9056
int res1 = 0 ;
9057
void *argp2 = 0 ;
9058
int res2 = 0 ;
9059
PyObject * obj0 = 0 ;
9060
PyObject * obj1 = 0 ;
9061
OpenTURNS::Bool result;
9062
9063
if (!PyArg_ParseTuple(args,(char *)"OO:TestResultCollection___eq__",&obj0,&obj1)) SWIG_fail;
9064
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0 );
9065
if (!SWIG_IsOK(res1)) {
9066
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResultCollection___eq__" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *""'");
9067
}
9068
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
9069
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0);
9070
if (!SWIG_IsOK(res2)) {
9071
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TestResultCollection___eq__" "', argument " "2"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const &""'");
9072
}
9073
if (!argp2) {
9074
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TestResultCollection___eq__" "', argument " "2"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const &""'");
9075
}
9076
arg2 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp2);
9077
{
9078
try {
9079
result = (OpenTURNS::Bool)((OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *)arg1)->__eq__((OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const &)*arg2);
9080
}
9081
catch (OT::Base::Common::InvalidArgumentException & ex) {
9082
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9083
}
9084
catch (OT::Base::Common::OutOfBoundException & ex) {
9085
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9086
}
9087
catch (OT::Base::Common::Exception & ex) {
9088
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9089
}
9090
catch (std::out_of_range & ex) {
9091
SWIG_exception(SWIG_IndexError,ex.what());
9092
}
9093
catch (std::exception & ex) {
9094
SWIG_exception(SWIG_RuntimeError,ex.what());
9095
}
9096
}
9097
resultobj = SWIG_From_bool(static_cast< bool >(result));
9098
return resultobj;
9099
fail:
9100
return NULL;
9101
}
9102
9103
9104
SWIGINTERN PyObject *_wrap_TestResultCollection___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9105
PyObject *resultobj = 0;
9106
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
9107
OpenTURNS::Base::Stat::TestResult arg2 ;
9108
void *argp1 = 0 ;
9109
int res1 = 0 ;
9110
void *argp2 ;
9111
int res2 = 0 ;
9112
PyObject * obj0 = 0 ;
9113
PyObject * obj1 = 0 ;
9114
OpenTURNS::Bool result;
9115
9116
if (!PyArg_ParseTuple(args,(char *)"OO:TestResultCollection___contains__",&obj0,&obj1)) SWIG_fail;
9117
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0 );
9118
if (!SWIG_IsOK(res1)) {
9119
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResultCollection___contains__" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *""'");
9120
}
9121
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
9122
{
9123
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0);
9124
if (!SWIG_IsOK(res2)) {
9125
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TestResultCollection___contains__" "', argument " "2"" of type '" "OpenTURNS::Base::Stat::TestResult""'");
9126
}
9127
if (!argp2) {
9128
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TestResultCollection___contains__" "', argument " "2"" of type '" "OpenTURNS::Base::Stat::TestResult""'");
9129
} else {
9130
OpenTURNS::Base::Stat::TestResult * temp = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp2);
9131
arg2 = *temp;
9132
if (SWIG_IsNewObj(res2)) delete temp;
9133
}
9134
}
9135
{
9136
try {
9137
result = (OpenTURNS::Bool)((OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *)arg1)->__contains__(arg2);
9138
}
9139
catch (OT::Base::Common::InvalidArgumentException & ex) {
9140
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9141
}
9142
catch (OT::Base::Common::OutOfBoundException & ex) {
9143
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9144
}
9145
catch (OT::Base::Common::Exception & ex) {
9146
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9147
}
9148
catch (std::out_of_range & ex) {
9149
SWIG_exception(SWIG_IndexError,ex.what());
9150
}
9151
catch (std::exception & ex) {
9152
SWIG_exception(SWIG_RuntimeError,ex.what());
9153
}
9154
}
9155
resultobj = SWIG_From_bool(static_cast< bool >(result));
9156
return resultobj;
9157
fail:
9158
return NULL;
9159
}
9160
9161
9162
SWIGINTERN PyObject *_wrap_TestResultCollection___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9163
PyObject *resultobj = 0;
9164
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
9165
OpenTURNS::UnsignedLong arg2 ;
9166
void *argp1 = 0 ;
9167
int res1 = 0 ;
9168
unsigned long val2 ;
9169
int ecode2 = 0 ;
9170
PyObject * obj0 = 0 ;
9171
PyObject * obj1 = 0 ;
9172
OpenTURNS::Base::Stat::TestResult result;
9173
9174
if (!PyArg_ParseTuple(args,(char *)"OO:TestResultCollection___getitem__",&obj0,&obj1)) SWIG_fail;
9175
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0 );
9176
if (!SWIG_IsOK(res1)) {
9177
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResultCollection___getitem__" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *""'");
9178
}
9179
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
9180
ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
9181
if (!SWIG_IsOK(ecode2)) {
9182
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TestResultCollection___getitem__" "', argument " "2"" of type '" "OpenTURNS::UnsignedLong""'");
9183
}
9184
arg2 = static_cast< OpenTURNS::UnsignedLong >(val2);
9185
{
9186
try {
9187
result = ((OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *)arg1)->__getitem__(arg2);
9188
}
9189
catch (OT::Base::Common::InvalidArgumentException & ex) {
9190
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9191
}
9192
catch (OT::Base::Common::OutOfBoundException & ex) {
9193
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9194
}
9195
catch (OT::Base::Common::Exception & ex) {
9196
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9197
}
9198
catch (std::out_of_range & ex) {
9199
SWIG_exception(SWIG_IndexError,ex.what());
9200
}
9201
catch (std::exception & ex) {
9202
SWIG_exception(SWIG_RuntimeError,ex.what());
9203
}
9204
}
9205
resultobj = SWIG_NewPointerObj((new OpenTURNS::Base::Stat::TestResult(static_cast< const OpenTURNS::Base::Stat::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
9206
return resultobj;
9207
fail:
9208
return NULL;
9209
}
9210
9211
9212
SWIGINTERN PyObject *_wrap_TestResultCollection___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9213
PyObject *resultobj = 0;
9214
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
9215
OpenTURNS::UnsignedLong arg2 ;
9216
OpenTURNS::Base::Stat::TestResult *arg3 = 0 ;
9217
void *argp1 = 0 ;
9218
int res1 = 0 ;
9219
unsigned long val2 ;
9220
int ecode2 = 0 ;
9221
void *argp3 = 0 ;
9222
int res3 = 0 ;
9223
PyObject * obj0 = 0 ;
9224
PyObject * obj1 = 0 ;
9225
PyObject * obj2 = 0 ;
9226
9227
if (!PyArg_ParseTuple(args,(char *)"OOO:TestResultCollection___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
9228
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0 );
9229
if (!SWIG_IsOK(res1)) {
9230
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResultCollection___setitem__" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *""'");
9231
}
9232
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
9233
ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
9234
if (!SWIG_IsOK(ecode2)) {
9235
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TestResultCollection___setitem__" "', argument " "2"" of type '" "OpenTURNS::UnsignedLong""'");
9236
}
9237
arg2 = static_cast< OpenTURNS::UnsignedLong >(val2);
9238
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0);
9239
if (!SWIG_IsOK(res3)) {
9240
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TestResultCollection___setitem__" "', argument " "3"" of type '" "OpenTURNS::Base::Stat::TestResult const &""'");
9241
}
9242
if (!argp3) {
9243
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TestResultCollection___setitem__" "', argument " "3"" of type '" "OpenTURNS::Base::Stat::TestResult const &""'");
9244
}
9245
arg3 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp3);
9246
{
9247
try {
9248
(arg1)->__setitem__(arg2,(OpenTURNS::Base::Stat::TestResult const &)*arg3);
9249
}
9250
catch (OT::Base::Common::InvalidArgumentException & ex) {
9251
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9252
}
9253
catch (OT::Base::Common::OutOfBoundException & ex) {
9254
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9255
}
9256
catch (OT::Base::Common::Exception & ex) {
9257
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9258
}
9259
catch (std::out_of_range & ex) {
9260
SWIG_exception(SWIG_IndexError,ex.what());
9261
}
9262
catch (std::exception & ex) {
9263
SWIG_exception(SWIG_RuntimeError,ex.what());
9264
}
9265
}
9266
resultobj = SWIG_Py_Void();
9267
return resultobj;
9268
fail:
9269
return NULL;
9270
}
9271
9272
9273
SWIGINTERN PyObject *_wrap_TestResultCollection___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9274
PyObject *resultobj = 0;
9275
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
9276
OpenTURNS::UnsignedLong arg2 ;
9277
OpenTURNS::Base::Stat::TestResult arg3 ;
9278
void *argp1 = 0 ;
9279
int res1 = 0 ;
9280
unsigned long val2 ;
9281
int ecode2 = 0 ;
9282
void *argp3 ;
9283
int res3 = 0 ;
9284
PyObject * obj0 = 0 ;
9285
PyObject * obj1 = 0 ;
9286
PyObject * obj2 = 0 ;
9287
9288
if (!PyArg_ParseTuple(args,(char *)"OOO:TestResultCollection___delitem__",&obj0,&obj1,&obj2)) SWIG_fail;
9289
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0 );
9290
if (!SWIG_IsOK(res1)) {
9291
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResultCollection___delitem__" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *""'");
9292
}
9293
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
9294
ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
9295
if (!SWIG_IsOK(ecode2)) {
9296
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TestResultCollection___delitem__" "', argument " "2"" of type '" "OpenTURNS::UnsignedLong""'");
9297
}
9298
arg2 = static_cast< OpenTURNS::UnsignedLong >(val2);
9299
{
9300
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0);
9301
if (!SWIG_IsOK(res3)) {
9302
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TestResultCollection___delitem__" "', argument " "3"" of type '" "OpenTURNS::Base::Stat::TestResult const""'");
9303
}
9304
if (!argp3) {
9305
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TestResultCollection___delitem__" "', argument " "3"" of type '" "OpenTURNS::Base::Stat::TestResult const""'");
9306
} else {
9307
OpenTURNS::Base::Stat::TestResult * temp = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp3);
9308
arg3 = *temp;
9309
if (SWIG_IsNewObj(res3)) delete temp;
9310
}
9311
}
9312
{
9313
try {
9314
(arg1)->__delitem__(arg2,arg3);
9315
}
9316
catch (OT::Base::Common::InvalidArgumentException & ex) {
9317
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9318
}
9319
catch (OT::Base::Common::OutOfBoundException & ex) {
9320
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9321
}
9322
catch (OT::Base::Common::Exception & ex) {
9323
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9324
}
9325
catch (std::out_of_range & ex) {
9326
SWIG_exception(SWIG_IndexError,ex.what());
9327
}
9328
catch (std::exception & ex) {
9329
SWIG_exception(SWIG_RuntimeError,ex.what());
9330
}
9331
}
9332
resultobj = SWIG_Py_Void();
9333
return resultobj;
9334
fail:
9335
return NULL;
9336
}
9337
9338
9339
SWIGINTERN PyObject *_wrap_TestResultCollection_at__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9340
PyObject *resultobj = 0;
9341
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
9342
OpenTURNS::UnsignedLong arg2 ;
9343
void *argp1 = 0 ;
9344
int res1 = 0 ;
9345
unsigned long val2 ;
9346
int ecode2 = 0 ;
9347
PyObject * obj0 = 0 ;
9348
PyObject * obj1 = 0 ;
9349
OpenTURNS::Base::Stat::TestResult *result = 0 ;
9350
9351
if (!PyArg_ParseTuple(args,(char *)"OO:TestResultCollection_at",&obj0,&obj1)) SWIG_fail;
9352
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0 );
9353
if (!SWIG_IsOK(res1)) {
9354
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResultCollection_at" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *""'");
9355
}
9356
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
9357
ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
9358
if (!SWIG_IsOK(ecode2)) {
9359
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TestResultCollection_at" "', argument " "2"" of type '" "OpenTURNS::UnsignedLong""'");
9360
}
9361
arg2 = static_cast< OpenTURNS::UnsignedLong >(val2);
9362
{
9363
try {
9364
{
9365
OpenTURNS::Base::Stat::TestResult &_result_ref = (arg1)->at(arg2);
9366
result = (OpenTURNS::Base::Stat::TestResult *) &_result_ref;
9367
}
9368
}
9369
catch (OT::Base::Common::InvalidArgumentException & ex) {
9370
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9371
}
9372
catch (OT::Base::Common::OutOfBoundException & ex) {
9373
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9374
}
9375
catch (OT::Base::Common::Exception & ex) {
9376
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9377
}
9378
catch (std::out_of_range & ex) {
9379
SWIG_exception(SWIG_IndexError,ex.what());
9380
}
9381
catch (std::exception & ex) {
9382
SWIG_exception(SWIG_RuntimeError,ex.what());
9383
}
9384
}
9385
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0 );
9386
return resultobj;
9387
fail:
9388
return NULL;
9389
}
9390
9391
9392
SWIGINTERN PyObject *_wrap_TestResultCollection_at__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9393
PyObject *resultobj = 0;
9394
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
9395
OpenTURNS::UnsignedLong arg2 ;
9396
void *argp1 = 0 ;
9397
int res1 = 0 ;
9398
unsigned long val2 ;
9399
int ecode2 = 0 ;
9400
PyObject * obj0 = 0 ;
9401
PyObject * obj1 = 0 ;
9402
OpenTURNS::Base::Stat::TestResult *result = 0 ;
9403
9404
if (!PyArg_ParseTuple(args,(char *)"OO:TestResultCollection_at",&obj0,&obj1)) SWIG_fail;
9405
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0 );
9406
if (!SWIG_IsOK(res1)) {
9407
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResultCollection_at" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *""'");
9408
}
9409
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
9410
ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
9411
if (!SWIG_IsOK(ecode2)) {
9412
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TestResultCollection_at" "', argument " "2"" of type '" "OpenTURNS::UnsignedLong""'");
9413
}
9414
arg2 = static_cast< OpenTURNS::UnsignedLong >(val2);
9415
{
9416
try {
9417
{
9418
OpenTURNS::Base::Stat::TestResult const &_result_ref = ((OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *)arg1)->at(arg2);
9419
result = (OpenTURNS::Base::Stat::TestResult *) &_result_ref;
9420
}
9421
}
9422
catch (OT::Base::Common::InvalidArgumentException & ex) {
9423
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9424
}
9425
catch (OT::Base::Common::OutOfBoundException & ex) {
9426
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9427
}
9428
catch (OT::Base::Common::Exception & ex) {
9429
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9430
}
9431
catch (std::out_of_range & ex) {
9432
SWIG_exception(SWIG_IndexError,ex.what());
9433
}
9434
catch (std::exception & ex) {
9435
SWIG_exception(SWIG_RuntimeError,ex.what());
9436
}
9437
}
9438
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0 );
9439
return resultobj;
9440
fail:
9441
return NULL;
9442
}
9443
9444
9445
SWIGINTERN PyObject *_wrap_TestResultCollection_at(PyObject *self, PyObject *args) {
9446
int argc;
9447
PyObject *argv[3];
9448
int ii;
9449
9450
if (!PyTuple_Check(args)) SWIG_fail;
9451
argc = (int)PyObject_Length(args);
9452
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
9453
argv[ii] = PyTuple_GET_ITEM(args,ii);
9454
}
9455
if (argc == 2) {
9456
int _v;
9457
void *vptr = 0;
9458
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0);
9459
_v = SWIG_CheckState(res);
9460
if (_v) {
9461
{
9462
int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
9463
_v = SWIG_CheckState(res);
9464
}
9465
if (_v) {
9466
return _wrap_TestResultCollection_at__SWIG_0(self, args);
9467
}
9468
}
9469
}
9470
if (argc == 2) {
9471
int _v;
9472
void *vptr = 0;
9473
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0);
9474
_v = SWIG_CheckState(res);
9475
if (_v) {
9476
{
9477
int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
9478
_v = SWIG_CheckState(res);
9479
}
9480
if (_v) {
9481
return _wrap_TestResultCollection_at__SWIG_1(self, args);
9482
}
9483
}
9484
}
9485
9486
fail:
9487
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'TestResultCollection_at'.\n"
9488
" Possible C/C++ prototypes are:\n"
9489
" at(OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *,OpenTURNS::UnsignedLong const)\n"
9490
" at(OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *,OpenTURNS::UnsignedLong const)\n");
9491
return NULL;
9492
}
9493
9494
9495
SWIGINTERN PyObject *_wrap_TestResultCollection_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9496
PyObject *resultobj = 0;
9497
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
9498
OpenTURNS::Base::Stat::TestResult *arg2 = 0 ;
9499
void *argp1 = 0 ;
9500
int res1 = 0 ;
9501
void *argp2 = 0 ;
9502
int res2 = 0 ;
9503
PyObject * obj0 = 0 ;
9504
PyObject * obj1 = 0 ;
9505
9506
if (!PyArg_ParseTuple(args,(char *)"OO:TestResultCollection_add",&obj0,&obj1)) SWIG_fail;
9507
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0 );
9508
if (!SWIG_IsOK(res1)) {
9509
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResultCollection_add" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *""'");
9510
}
9511
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
9512
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0 | 0);
9513
if (!SWIG_IsOK(res2)) {
9514
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TestResultCollection_add" "', argument " "2"" of type '" "OpenTURNS::Base::Stat::TestResult const &""'");
9515
}
9516
if (!argp2) {
9517
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TestResultCollection_add" "', argument " "2"" of type '" "OpenTURNS::Base::Stat::TestResult const &""'");
9518
}
9519
arg2 = reinterpret_cast< OpenTURNS::Base::Stat::TestResult * >(argp2);
9520
{
9521
try {
9522
(arg1)->add((OpenTURNS::Base::Stat::TestResult const &)*arg2);
9523
}
9524
catch (OT::Base::Common::InvalidArgumentException & ex) {
9525
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9526
}
9527
catch (OT::Base::Common::OutOfBoundException & ex) {
9528
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9529
}
9530
catch (OT::Base::Common::Exception & ex) {
9531
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9532
}
9533
catch (std::out_of_range & ex) {
9534
SWIG_exception(SWIG_IndexError,ex.what());
9535
}
9536
catch (std::exception & ex) {
9537
SWIG_exception(SWIG_RuntimeError,ex.what());
9538
}
9539
}
9540
resultobj = SWIG_Py_Void();
9541
return resultobj;
9542
fail:
9543
return NULL;
9544
}
9545
9546
9547
SWIGINTERN PyObject *_wrap_TestResultCollection_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9548
PyObject *resultobj = 0;
9549
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
9550
void *argp1 = 0 ;
9551
int res1 = 0 ;
9552
PyObject * obj0 = 0 ;
9553
OpenTURNS::UnsignedLong result;
9554
9555
if (!PyArg_ParseTuple(args,(char *)"O:TestResultCollection_getSize",&obj0)) SWIG_fail;
9556
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0 );
9557
if (!SWIG_IsOK(res1)) {
9558
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResultCollection_getSize" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *""'");
9559
}
9560
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
9561
{
9562
try {
9563
result = (OpenTURNS::UnsignedLong)((OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *)arg1)->getSize();
9564
}
9565
catch (OT::Base::Common::InvalidArgumentException & ex) {
9566
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9567
}
9568
catch (OT::Base::Common::OutOfBoundException & ex) {
9569
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9570
}
9571
catch (OT::Base::Common::Exception & ex) {
9572
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9573
}
9574
catch (std::out_of_range & ex) {
9575
SWIG_exception(SWIG_IndexError,ex.what());
9576
}
9577
catch (std::exception & ex) {
9578
SWIG_exception(SWIG_RuntimeError,ex.what());
9579
}
9580
}
9581
resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
9582
return resultobj;
9583
fail:
9584
return NULL;
9585
}
9586
9587
9588
SWIGINTERN PyObject *_wrap_TestResultCollection_resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9589
PyObject *resultobj = 0;
9590
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
9591
OpenTURNS::UnsignedLong arg2 ;
9592
void *argp1 = 0 ;
9593
int res1 = 0 ;
9594
unsigned long val2 ;
9595
int ecode2 = 0 ;
9596
PyObject * obj0 = 0 ;
9597
PyObject * obj1 = 0 ;
9598
9599
if (!PyArg_ParseTuple(args,(char *)"OO:TestResultCollection_resize",&obj0,&obj1)) SWIG_fail;
9600
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0 );
9601
if (!SWIG_IsOK(res1)) {
9602
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResultCollection_resize" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *""'");
9603
}
9604
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
9605
ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
9606
if (!SWIG_IsOK(ecode2)) {
9607
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TestResultCollection_resize" "', argument " "2"" of type '" "OpenTURNS::UnsignedLong""'");
9608
}
9609
arg2 = static_cast< OpenTURNS::UnsignedLong >(val2);
9610
{
9611
try {
9612
(arg1)->resize(arg2);
9613
}
9614
catch (OT::Base::Common::InvalidArgumentException & ex) {
9615
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9616
}
9617
catch (OT::Base::Common::OutOfBoundException & ex) {
9618
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9619
}
9620
catch (OT::Base::Common::Exception & ex) {
9621
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9622
}
9623
catch (std::out_of_range & ex) {
9624
SWIG_exception(SWIG_IndexError,ex.what());
9625
}
9626
catch (std::exception & ex) {
9627
SWIG_exception(SWIG_RuntimeError,ex.what());
9628
}
9629
}
9630
resultobj = SWIG_Py_Void();
9631
return resultobj;
9632
fail:
9633
return NULL;
9634
}
9635
9636
9637
SWIGINTERN PyObject *_wrap_TestResultCollection_isEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9638
PyObject *resultobj = 0;
9639
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
9640
void *argp1 = 0 ;
9641
int res1 = 0 ;
9642
PyObject * obj0 = 0 ;
9643
OpenTURNS::Bool result;
9644
9645
if (!PyArg_ParseTuple(args,(char *)"O:TestResultCollection_isEmpty",&obj0)) SWIG_fail;
9646
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0 );
9647
if (!SWIG_IsOK(res1)) {
9648
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResultCollection_isEmpty" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *""'");
9649
}
9650
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
9651
{
9652
try {
9653
result = (OpenTURNS::Bool)((OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *)arg1)->isEmpty();
9654
}
9655
catch (OT::Base::Common::InvalidArgumentException & ex) {
9656
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9657
}
9658
catch (OT::Base::Common::OutOfBoundException & ex) {
9659
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9660
}
9661
catch (OT::Base::Common::Exception & ex) {
9662
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9663
}
9664
catch (std::out_of_range & ex) {
9665
SWIG_exception(SWIG_IndexError,ex.what());
9666
}
9667
catch (std::exception & ex) {
9668
SWIG_exception(SWIG_RuntimeError,ex.what());
9669
}
9670
}
9671
resultobj = SWIG_From_bool(static_cast< bool >(result));
9672
return resultobj;
9673
fail:
9674
return NULL;
9675
}
9676
9677
9678
SWIGINTERN PyObject *_wrap_TestResultCollection___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9679
PyObject *resultobj = 0;
9680
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
9681
void *argp1 = 0 ;
9682
int res1 = 0 ;
9683
PyObject * obj0 = 0 ;
9684
OpenTURNS::String result;
9685
9686
if (!PyArg_ParseTuple(args,(char *)"O:TestResultCollection___repr__",&obj0)) SWIG_fail;
9687
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0 );
9688
if (!SWIG_IsOK(res1)) {
9689
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResultCollection___repr__" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *""'");
9690
}
9691
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
9692
{
9693
try {
9694
result = ((OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *)arg1)->__repr__();
9695
}
9696
catch (OT::Base::Common::InvalidArgumentException & ex) {
9697
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9698
}
9699
catch (OT::Base::Common::OutOfBoundException & ex) {
9700
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9701
}
9702
catch (OT::Base::Common::Exception & ex) {
9703
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9704
}
9705
catch (std::out_of_range & ex) {
9706
SWIG_exception(SWIG_IndexError,ex.what());
9707
}
9708
catch (std::exception & ex) {
9709
SWIG_exception(SWIG_RuntimeError,ex.what());
9710
}
9711
}
9712
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
9713
return resultobj;
9714
fail:
9715
return NULL;
9716
}
9717
9718
9719
SWIGINTERN PyObject *_wrap_TestResultCollection___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9720
PyObject *resultobj = 0;
9721
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
9722
void *argp1 = 0 ;
9723
int res1 = 0 ;
9724
PyObject * obj0 = 0 ;
9725
OpenTURNS::String result;
9726
9727
if (!PyArg_ParseTuple(args,(char *)"O:TestResultCollection___str__",&obj0)) SWIG_fail;
9728
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0 | 0 );
9729
if (!SWIG_IsOK(res1)) {
9730
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestResultCollection___str__" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *""'");
9731
}
9732
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
9733
{
9734
try {
9735
result = ((OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > const *)arg1)->__str__();
9736
}
9737
catch (OT::Base::Common::InvalidArgumentException & ex) {
9738
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9739
}
9740
catch (OT::Base::Common::OutOfBoundException & ex) {
9741
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9742
}
9743
catch (OT::Base::Common::Exception & ex) {
9744
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9745
}
9746
catch (std::out_of_range & ex) {
9747
SWIG_exception(SWIG_IndexError,ex.what());
9748
}
9749
catch (std::exception & ex) {
9750
SWIG_exception(SWIG_RuntimeError,ex.what());
9751
}
9752
}
9753
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
9754
return resultobj;
9755
fail:
9756
return NULL;
9757
}
9758
9759
9760
SWIGINTERN PyObject *_wrap_new_TestResultCollection__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9761
PyObject *resultobj = 0;
9762
PyObject *arg1 = (PyObject *) 0 ;
9763
PyObject * obj0 = 0 ;
9764
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *result = 0 ;
9765
9766
if (!PyArg_ParseTuple(args,(char *)"O:new_TestResultCollection",&obj0)) SWIG_fail;
9767
arg1 = obj0;
9768
{
9769
try {
9770
result = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *)new_OpenTURNS_Base_Type_Collection_Sl_OpenTURNS_Base_Stat_TestResult_Sg___SWIG_3(arg1);
9771
}
9772
catch (OT::Base::Common::InvalidArgumentException & ex) {
9773
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9774
}
9775
catch (OT::Base::Common::OutOfBoundException & ex) {
9776
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9777
}
9778
catch (OT::Base::Common::Exception & ex) {
9779
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9780
}
9781
catch (std::out_of_range & ex) {
9782
SWIG_exception(SWIG_IndexError,ex.what());
9783
}
9784
catch (std::exception & ex) {
9785
SWIG_exception(SWIG_RuntimeError,ex.what());
9786
}
9787
}
9788
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_NEW | 0 );
9789
return resultobj;
9790
fail:
9791
return NULL;
9792
}
9793
9794
9795
SWIGINTERN PyObject *_wrap_new_TestResultCollection(PyObject *self, PyObject *args) {
9796
int argc;
9797
PyObject *argv[3];
9798
int ii;
9799
9800
if (!PyTuple_Check(args)) SWIG_fail;
9801
argc = (int)PyObject_Length(args);
9802
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
9803
argv[ii] = PyTuple_GET_ITEM(args,ii);
9804
}
9805
if (argc == 0) {
9806
return _wrap_new_TestResultCollection__SWIG_0(self, args);
9807
}
9808
if (argc == 1) {
9809
int _v;
9810
{
9811
int res = SWIG_AsVal_unsigned_SS_long(argv[0], NULL);
9812
_v = SWIG_CheckState(res);
9813
}
9814
if (_v) {
9815
return _wrap_new_TestResultCollection__SWIG_1(self, args);
9816
}
9817
}
9818
if (argc == 1) {
9819
int _v;
9820
_v = (argv[0] != 0);
9821
if (_v) {
9822
return _wrap_new_TestResultCollection__SWIG_3(self, args);
9823
}
9824
}
9825
if (argc == 2) {
9826
int _v;
9827
{
9828
int res = SWIG_AsVal_unsigned_SS_long(argv[0], NULL);
9829
_v = SWIG_CheckState(res);
9830
}
9831
if (_v) {
9832
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, 0);
9833
_v = SWIG_CheckState(res);
9834
if (_v) {
9835
return _wrap_new_TestResultCollection__SWIG_2(self, args);
9836
}
9837
}
9838
}
9839
9840
fail:
9841
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TestResultCollection'.\n"
9842
" Possible C/C++ prototypes are:\n"
9843
" OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult >()\n"
9844
" OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult >(OpenTURNS::UnsignedLong const)\n"
9845
" OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult >(OpenTURNS::UnsignedLong const,OpenTURNS::Base::Stat::TestResult const &)\n"
9846
" OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult >(PyObject *)\n");
9847
return NULL;
9848
}
9849
9850
9851
SWIGINTERN PyObject *_wrap_delete_TestResultCollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9852
PyObject *resultobj = 0;
9853
OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *arg1 = (OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *) 0 ;
9854
void *argp1 = 0 ;
9855
int res1 = 0 ;
9856
PyObject * obj0 = 0 ;
9857
9858
if (!PyArg_ParseTuple(args,(char *)"O:delete_TestResultCollection",&obj0)) SWIG_fail;
9859
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_DISOWN | 0 );
9860
if (!SWIG_IsOK(res1)) {
9861
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TestResultCollection" "', argument " "1"" of type '" "OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *""'");
9862
}
9863
arg1 = reinterpret_cast< OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > * >(argp1);
9864
{
9865
try {
9866
delete arg1;
9867
}
9868
catch (OT::Base::Common::InvalidArgumentException & ex) {
9869
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9870
}
9871
catch (OT::Base::Common::OutOfBoundException & ex) {
9872
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9873
}
9874
catch (OT::Base::Common::Exception & ex) {
9875
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9876
}
9877
catch (std::out_of_range & ex) {
9878
SWIG_exception(SWIG_IndexError,ex.what());
9879
}
9880
catch (std::exception & ex) {
9881
SWIG_exception(SWIG_RuntimeError,ex.what());
9882
}
9883
}
9884
resultobj = SWIG_Py_Void();
9885
return resultobj;
9886
fail:
9887
return NULL;
9888
}
9889
9890
9891
SWIGINTERN PyObject *TestResultCollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9892
PyObject *obj;
9893
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
9894
SWIG_TypeNewClientData(SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_NewClientData(obj));
9895
return SWIG_Py_Void();
9896
}
9897
9898
SWIGINTERN PyObject *_wrap_new_HypothesisTest__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9899
PyObject *resultobj = 0;
9900
OpenTURNS::Uncertainty::StatTest::HypothesisTest *result = 0 ;
9901
9902
if (!PyArg_ParseTuple(args,(char *)":new_HypothesisTest")) SWIG_fail;
9903
{
9904
try {
9905
result = (OpenTURNS::Uncertainty::StatTest::HypothesisTest *)new OpenTURNS::Uncertainty::StatTest::HypothesisTest();
9906
}
9907
catch (OT::Base::Common::InvalidArgumentException & ex) {
9908
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9909
}
9910
catch (OT::Base::Common::OutOfBoundException & ex) {
9911
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9912
}
9913
catch (OT::Base::Common::Exception & ex) {
9914
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9915
}
9916
catch (std::out_of_range & ex) {
9917
SWIG_exception(SWIG_IndexError,ex.what());
9918
}
9919
catch (std::exception & ex) {
9920
SWIG_exception(SWIG_RuntimeError,ex.what());
9921
}
9922
}
9923
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__HypothesisTest, SWIG_POINTER_NEW | 0 );
9924
return resultobj;
9925
fail:
9926
return NULL;
9927
}
9928
9929
9930
SWIGINTERN PyObject *_wrap_HypothesisTest_ChiSquared__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9931
PyObject *resultobj = 0;
9932
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
9933
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
9934
OpenTURNS::NumericalScalar arg3 ;
9935
void *argp1 = 0 ;
9936
int res1 = 0 ;
9937
void *argp2 = 0 ;
9938
int res2 = 0 ;
9939
double val3 ;
9940
int ecode3 = 0 ;
9941
PyObject * obj0 = 0 ;
9942
PyObject * obj1 = 0 ;
9943
PyObject * obj2 = 0 ;
9944
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult result;
9945
9946
if (!PyArg_ParseTuple(args,(char *)"OOO:HypothesisTest_ChiSquared",&obj0,&obj1,&obj2)) SWIG_fail;
9947
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
9948
if (!SWIG_IsOK(res1)) {
9949
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_ChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
9950
}
9951
if (!argp1) {
9952
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_ChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
9953
}
9954
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
9955
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
9956
if (!SWIG_IsOK(res2)) {
9957
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_ChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
9958
}
9959
if (!argp2) {
9960
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_ChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
9961
}
9962
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
9963
ecode3 = SWIG_AsVal_double(obj2, &val3);
9964
if (!SWIG_IsOK(ecode3)) {
9965
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HypothesisTest_ChiSquared" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
9966
}
9967
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
9968
{
9969
try {
9970
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::ChiSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,arg3);
9971
}
9972
catch (OT::Base::Common::InvalidArgumentException & ex) {
9973
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
9974
}
9975
catch (OT::Base::Common::OutOfBoundException & ex) {
9976
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
9977
}
9978
catch (OT::Base::Common::Exception & ex) {
9979
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
9980
}
9981
catch (std::out_of_range & ex) {
9982
SWIG_exception(SWIG_IndexError,ex.what());
9983
}
9984
catch (std::exception & ex) {
9985
SWIG_exception(SWIG_RuntimeError,ex.what());
9986
}
9987
}
9988
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
9989
return resultobj;
9990
fail:
9991
return NULL;
9992
}
9993
9994
9995
SWIGINTERN PyObject *_wrap_HypothesisTest_ChiSquared__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9996
PyObject *resultobj = 0;
9997
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
9998
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
9999
void *argp1 = 0 ;
10000
int res1 = 0 ;
10001
void *argp2 = 0 ;
10002
int res2 = 0 ;
10003
PyObject * obj0 = 0 ;
10004
PyObject * obj1 = 0 ;
10005
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult result;
10006
10007
if (!PyArg_ParseTuple(args,(char *)"OO:HypothesisTest_ChiSquared",&obj0,&obj1)) SWIG_fail;
10008
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10009
if (!SWIG_IsOK(res1)) {
10010
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_ChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10011
}
10012
if (!argp1) {
10013
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_ChiSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10014
}
10015
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
10016
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10017
if (!SWIG_IsOK(res2)) {
10018
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_ChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10019
}
10020
if (!argp2) {
10021
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_ChiSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10022
}
10023
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
10024
{
10025
try {
10026
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::ChiSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2);
10027
}
10028
catch (OT::Base::Common::InvalidArgumentException & ex) {
10029
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
10030
}
10031
catch (OT::Base::Common::OutOfBoundException & ex) {
10032
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
10033
}
10034
catch (OT::Base::Common::Exception & ex) {
10035
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
10036
}
10037
catch (std::out_of_range & ex) {
10038
SWIG_exception(SWIG_IndexError,ex.what());
10039
}
10040
catch (std::exception & ex) {
10041
SWIG_exception(SWIG_RuntimeError,ex.what());
10042
}
10043
}
10044
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
10045
return resultobj;
10046
fail:
10047
return NULL;
10048
}
10049
10050
10051
SWIGINTERN PyObject *_wrap_HypothesisTest_ChiSquared(PyObject *self, PyObject *args) {
10052
int argc;
10053
PyObject *argv[4];
10054
int ii;
10055
10056
if (!PyTuple_Check(args)) SWIG_fail;
10057
argc = (int)PyObject_Length(args);
10058
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
10059
argv[ii] = PyTuple_GET_ITEM(args,ii);
10060
}
10061
if (argc == 2) {
10062
int _v;
10063
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10064
_v = SWIG_CheckState(res);
10065
if (_v) {
10066
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10067
_v = SWIG_CheckState(res);
10068
if (_v) {
10069
return _wrap_HypothesisTest_ChiSquared__SWIG_1(self, args);
10070
}
10071
}
10072
}
10073
if (argc == 3) {
10074
int _v;
10075
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10076
_v = SWIG_CheckState(res);
10077
if (_v) {
10078
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10079
_v = SWIG_CheckState(res);
10080
if (_v) {
10081
{
10082
int res = SWIG_AsVal_double(argv[2], NULL);
10083
_v = SWIG_CheckState(res);
10084
}
10085
if (_v) {
10086
return _wrap_HypothesisTest_ChiSquared__SWIG_0(self, args);
10087
}
10088
}
10089
}
10090
}
10091
10092
fail:
10093
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'HypothesisTest_ChiSquared'.\n"
10094
" Possible C/C++ prototypes are:\n"
10095
" ChiSquared(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::NumericalScalar const)\n"
10096
" OpenTURNS::Uncertainty::StatTest::HypothesisTest::ChiSquared(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &)\n");
10097
return NULL;
10098
}
10099
10100
10101
SWIGINTERN PyObject *_wrap_HypothesisTest_Pearson__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10102
PyObject *resultobj = 0;
10103
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
10104
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
10105
OpenTURNS::NumericalScalar arg3 ;
10106
void *argp1 = 0 ;
10107
int res1 = 0 ;
10108
void *argp2 = 0 ;
10109
int res2 = 0 ;
10110
double val3 ;
10111
int ecode3 = 0 ;
10112
PyObject * obj0 = 0 ;
10113
PyObject * obj1 = 0 ;
10114
PyObject * obj2 = 0 ;
10115
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult result;
10116
10117
if (!PyArg_ParseTuple(args,(char *)"OOO:HypothesisTest_Pearson",&obj0,&obj1,&obj2)) SWIG_fail;
10118
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10119
if (!SWIG_IsOK(res1)) {
10120
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_Pearson" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10121
}
10122
if (!argp1) {
10123
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_Pearson" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10124
}
10125
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
10126
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10127
if (!SWIG_IsOK(res2)) {
10128
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_Pearson" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10129
}
10130
if (!argp2) {
10131
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_Pearson" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10132
}
10133
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
10134
ecode3 = SWIG_AsVal_double(obj2, &val3);
10135
if (!SWIG_IsOK(ecode3)) {
10136
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HypothesisTest_Pearson" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
10137
}
10138
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
10139
{
10140
try {
10141
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::Pearson((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,arg3);
10142
}
10143
catch (OT::Base::Common::InvalidArgumentException & ex) {
10144
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
10145
}
10146
catch (OT::Base::Common::OutOfBoundException & ex) {
10147
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
10148
}
10149
catch (OT::Base::Common::Exception & ex) {
10150
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
10151
}
10152
catch (std::out_of_range & ex) {
10153
SWIG_exception(SWIG_IndexError,ex.what());
10154
}
10155
catch (std::exception & ex) {
10156
SWIG_exception(SWIG_RuntimeError,ex.what());
10157
}
10158
}
10159
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
10160
return resultobj;
10161
fail:
10162
return NULL;
10163
}
10164
10165
10166
SWIGINTERN PyObject *_wrap_HypothesisTest_Pearson__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10167
PyObject *resultobj = 0;
10168
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
10169
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
10170
void *argp1 = 0 ;
10171
int res1 = 0 ;
10172
void *argp2 = 0 ;
10173
int res2 = 0 ;
10174
PyObject * obj0 = 0 ;
10175
PyObject * obj1 = 0 ;
10176
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult result;
10177
10178
if (!PyArg_ParseTuple(args,(char *)"OO:HypothesisTest_Pearson",&obj0,&obj1)) SWIG_fail;
10179
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10180
if (!SWIG_IsOK(res1)) {
10181
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_Pearson" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10182
}
10183
if (!argp1) {
10184
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_Pearson" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10185
}
10186
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
10187
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10188
if (!SWIG_IsOK(res2)) {
10189
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_Pearson" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10190
}
10191
if (!argp2) {
10192
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_Pearson" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10193
}
10194
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
10195
{
10196
try {
10197
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::Pearson((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2);
10198
}
10199
catch (OT::Base::Common::InvalidArgumentException & ex) {
10200
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
10201
}
10202
catch (OT::Base::Common::OutOfBoundException & ex) {
10203
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
10204
}
10205
catch (OT::Base::Common::Exception & ex) {
10206
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
10207
}
10208
catch (std::out_of_range & ex) {
10209
SWIG_exception(SWIG_IndexError,ex.what());
10210
}
10211
catch (std::exception & ex) {
10212
SWIG_exception(SWIG_RuntimeError,ex.what());
10213
}
10214
}
10215
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
10216
return resultobj;
10217
fail:
10218
return NULL;
10219
}
10220
10221
10222
SWIGINTERN PyObject *_wrap_HypothesisTest_Pearson(PyObject *self, PyObject *args) {
10223
int argc;
10224
PyObject *argv[4];
10225
int ii;
10226
10227
if (!PyTuple_Check(args)) SWIG_fail;
10228
argc = (int)PyObject_Length(args);
10229
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
10230
argv[ii] = PyTuple_GET_ITEM(args,ii);
10231
}
10232
if (argc == 2) {
10233
int _v;
10234
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10235
_v = SWIG_CheckState(res);
10236
if (_v) {
10237
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10238
_v = SWIG_CheckState(res);
10239
if (_v) {
10240
return _wrap_HypothesisTest_Pearson__SWIG_1(self, args);
10241
}
10242
}
10243
}
10244
if (argc == 3) {
10245
int _v;
10246
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10247
_v = SWIG_CheckState(res);
10248
if (_v) {
10249
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10250
_v = SWIG_CheckState(res);
10251
if (_v) {
10252
{
10253
int res = SWIG_AsVal_double(argv[2], NULL);
10254
_v = SWIG_CheckState(res);
10255
}
10256
if (_v) {
10257
return _wrap_HypothesisTest_Pearson__SWIG_0(self, args);
10258
}
10259
}
10260
}
10261
}
10262
10263
fail:
10264
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'HypothesisTest_Pearson'.\n"
10265
" Possible C/C++ prototypes are:\n"
10266
" Pearson(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::NumericalScalar const)\n"
10267
" OpenTURNS::Uncertainty::StatTest::HypothesisTest::Pearson(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &)\n");
10268
return NULL;
10269
}
10270
10271
10272
SWIGINTERN PyObject *_wrap_HypothesisTest_Smirnov__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10273
PyObject *resultobj = 0;
10274
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
10275
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
10276
OpenTURNS::NumericalScalar arg3 ;
10277
void *argp1 = 0 ;
10278
int res1 = 0 ;
10279
void *argp2 = 0 ;
10280
int res2 = 0 ;
10281
double val3 ;
10282
int ecode3 = 0 ;
10283
PyObject * obj0 = 0 ;
10284
PyObject * obj1 = 0 ;
10285
PyObject * obj2 = 0 ;
10286
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult result;
10287
10288
if (!PyArg_ParseTuple(args,(char *)"OOO:HypothesisTest_Smirnov",&obj0,&obj1,&obj2)) SWIG_fail;
10289
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10290
if (!SWIG_IsOK(res1)) {
10291
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_Smirnov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10292
}
10293
if (!argp1) {
10294
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_Smirnov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10295
}
10296
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
10297
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10298
if (!SWIG_IsOK(res2)) {
10299
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_Smirnov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10300
}
10301
if (!argp2) {
10302
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_Smirnov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10303
}
10304
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
10305
ecode3 = SWIG_AsVal_double(obj2, &val3);
10306
if (!SWIG_IsOK(ecode3)) {
10307
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HypothesisTest_Smirnov" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
10308
}
10309
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
10310
{
10311
try {
10312
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::Smirnov((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,arg3);
10313
}
10314
catch (OT::Base::Common::InvalidArgumentException & ex) {
10315
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
10316
}
10317
catch (OT::Base::Common::OutOfBoundException & ex) {
10318
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
10319
}
10320
catch (OT::Base::Common::Exception & ex) {
10321
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
10322
}
10323
catch (std::out_of_range & ex) {
10324
SWIG_exception(SWIG_IndexError,ex.what());
10325
}
10326
catch (std::exception & ex) {
10327
SWIG_exception(SWIG_RuntimeError,ex.what());
10328
}
10329
}
10330
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
10331
return resultobj;
10332
fail:
10333
return NULL;
10334
}
10335
10336
10337
SWIGINTERN PyObject *_wrap_HypothesisTest_Smirnov__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10338
PyObject *resultobj = 0;
10339
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
10340
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
10341
void *argp1 = 0 ;
10342
int res1 = 0 ;
10343
void *argp2 = 0 ;
10344
int res2 = 0 ;
10345
PyObject * obj0 = 0 ;
10346
PyObject * obj1 = 0 ;
10347
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult result;
10348
10349
if (!PyArg_ParseTuple(args,(char *)"OO:HypothesisTest_Smirnov",&obj0,&obj1)) SWIG_fail;
10350
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10351
if (!SWIG_IsOK(res1)) {
10352
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_Smirnov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10353
}
10354
if (!argp1) {
10355
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_Smirnov" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10356
}
10357
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
10358
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10359
if (!SWIG_IsOK(res2)) {
10360
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_Smirnov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10361
}
10362
if (!argp2) {
10363
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_Smirnov" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10364
}
10365
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
10366
{
10367
try {
10368
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::Smirnov((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2);
10369
}
10370
catch (OT::Base::Common::InvalidArgumentException & ex) {
10371
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
10372
}
10373
catch (OT::Base::Common::OutOfBoundException & ex) {
10374
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
10375
}
10376
catch (OT::Base::Common::Exception & ex) {
10377
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
10378
}
10379
catch (std::out_of_range & ex) {
10380
SWIG_exception(SWIG_IndexError,ex.what());
10381
}
10382
catch (std::exception & ex) {
10383
SWIG_exception(SWIG_RuntimeError,ex.what());
10384
}
10385
}
10386
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
10387
return resultobj;
10388
fail:
10389
return NULL;
10390
}
10391
10392
10393
SWIGINTERN PyObject *_wrap_HypothesisTest_Smirnov(PyObject *self, PyObject *args) {
10394
int argc;
10395
PyObject *argv[4];
10396
int ii;
10397
10398
if (!PyTuple_Check(args)) SWIG_fail;
10399
argc = (int)PyObject_Length(args);
10400
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
10401
argv[ii] = PyTuple_GET_ITEM(args,ii);
10402
}
10403
if (argc == 2) {
10404
int _v;
10405
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10406
_v = SWIG_CheckState(res);
10407
if (_v) {
10408
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10409
_v = SWIG_CheckState(res);
10410
if (_v) {
10411
return _wrap_HypothesisTest_Smirnov__SWIG_1(self, args);
10412
}
10413
}
10414
}
10415
if (argc == 3) {
10416
int _v;
10417
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10418
_v = SWIG_CheckState(res);
10419
if (_v) {
10420
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10421
_v = SWIG_CheckState(res);
10422
if (_v) {
10423
{
10424
int res = SWIG_AsVal_double(argv[2], NULL);
10425
_v = SWIG_CheckState(res);
10426
}
10427
if (_v) {
10428
return _wrap_HypothesisTest_Smirnov__SWIG_0(self, args);
10429
}
10430
}
10431
}
10432
}
10433
10434
fail:
10435
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'HypothesisTest_Smirnov'.\n"
10436
" Possible C/C++ prototypes are:\n"
10437
" Smirnov(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::NumericalScalar const)\n"
10438
" OpenTURNS::Uncertainty::StatTest::HypothesisTest::Smirnov(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &)\n");
10439
return NULL;
10440
}
10441
10442
10443
SWIGINTERN PyObject *_wrap_HypothesisTest_Spearman__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10444
PyObject *resultobj = 0;
10445
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
10446
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
10447
OpenTURNS::NumericalScalar arg3 ;
10448
void *argp1 = 0 ;
10449
int res1 = 0 ;
10450
void *argp2 = 0 ;
10451
int res2 = 0 ;
10452
double val3 ;
10453
int ecode3 = 0 ;
10454
PyObject * obj0 = 0 ;
10455
PyObject * obj1 = 0 ;
10456
PyObject * obj2 = 0 ;
10457
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult result;
10458
10459
if (!PyArg_ParseTuple(args,(char *)"OOO:HypothesisTest_Spearman",&obj0,&obj1,&obj2)) SWIG_fail;
10460
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10461
if (!SWIG_IsOK(res1)) {
10462
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_Spearman" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10463
}
10464
if (!argp1) {
10465
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_Spearman" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10466
}
10467
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
10468
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10469
if (!SWIG_IsOK(res2)) {
10470
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_Spearman" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10471
}
10472
if (!argp2) {
10473
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_Spearman" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10474
}
10475
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
10476
ecode3 = SWIG_AsVal_double(obj2, &val3);
10477
if (!SWIG_IsOK(ecode3)) {
10478
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HypothesisTest_Spearman" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
10479
}
10480
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
10481
{
10482
try {
10483
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::Spearman((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,arg3);
10484
}
10485
catch (OT::Base::Common::InvalidArgumentException & ex) {
10486
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
10487
}
10488
catch (OT::Base::Common::OutOfBoundException & ex) {
10489
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
10490
}
10491
catch (OT::Base::Common::Exception & ex) {
10492
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
10493
}
10494
catch (std::out_of_range & ex) {
10495
SWIG_exception(SWIG_IndexError,ex.what());
10496
}
10497
catch (std::exception & ex) {
10498
SWIG_exception(SWIG_RuntimeError,ex.what());
10499
}
10500
}
10501
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
10502
return resultobj;
10503
fail:
10504
return NULL;
10505
}
10506
10507
10508
SWIGINTERN PyObject *_wrap_HypothesisTest_Spearman__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10509
PyObject *resultobj = 0;
10510
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
10511
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
10512
void *argp1 = 0 ;
10513
int res1 = 0 ;
10514
void *argp2 = 0 ;
10515
int res2 = 0 ;
10516
PyObject * obj0 = 0 ;
10517
PyObject * obj1 = 0 ;
10518
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult result;
10519
10520
if (!PyArg_ParseTuple(args,(char *)"OO:HypothesisTest_Spearman",&obj0,&obj1)) SWIG_fail;
10521
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10522
if (!SWIG_IsOK(res1)) {
10523
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_Spearman" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10524
}
10525
if (!argp1) {
10526
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_Spearman" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10527
}
10528
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
10529
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10530
if (!SWIG_IsOK(res2)) {
10531
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_Spearman" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10532
}
10533
if (!argp2) {
10534
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_Spearman" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10535
}
10536
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
10537
{
10538
try {
10539
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::Spearman((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2);
10540
}
10541
catch (OT::Base::Common::InvalidArgumentException & ex) {
10542
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
10543
}
10544
catch (OT::Base::Common::OutOfBoundException & ex) {
10545
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
10546
}
10547
catch (OT::Base::Common::Exception & ex) {
10548
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
10549
}
10550
catch (std::out_of_range & ex) {
10551
SWIG_exception(SWIG_IndexError,ex.what());
10552
}
10553
catch (std::exception & ex) {
10554
SWIG_exception(SWIG_RuntimeError,ex.what());
10555
}
10556
}
10557
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
10558
return resultobj;
10559
fail:
10560
return NULL;
10561
}
10562
10563
10564
SWIGINTERN PyObject *_wrap_HypothesisTest_Spearman(PyObject *self, PyObject *args) {
10565
int argc;
10566
PyObject *argv[4];
10567
int ii;
10568
10569
if (!PyTuple_Check(args)) SWIG_fail;
10570
argc = (int)PyObject_Length(args);
10571
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
10572
argv[ii] = PyTuple_GET_ITEM(args,ii);
10573
}
10574
if (argc == 2) {
10575
int _v;
10576
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10577
_v = SWIG_CheckState(res);
10578
if (_v) {
10579
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10580
_v = SWIG_CheckState(res);
10581
if (_v) {
10582
return _wrap_HypothesisTest_Spearman__SWIG_1(self, args);
10583
}
10584
}
10585
}
10586
if (argc == 3) {
10587
int _v;
10588
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10589
_v = SWIG_CheckState(res);
10590
if (_v) {
10591
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10592
_v = SWIG_CheckState(res);
10593
if (_v) {
10594
{
10595
int res = SWIG_AsVal_double(argv[2], NULL);
10596
_v = SWIG_CheckState(res);
10597
}
10598
if (_v) {
10599
return _wrap_HypothesisTest_Spearman__SWIG_0(self, args);
10600
}
10601
}
10602
}
10603
}
10604
10605
fail:
10606
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'HypothesisTest_Spearman'.\n"
10607
" Possible C/C++ prototypes are:\n"
10608
" Spearman(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::NumericalScalar const)\n"
10609
" OpenTURNS::Uncertainty::StatTest::HypothesisTest::Spearman(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &)\n");
10610
return NULL;
10611
}
10612
10613
10614
SWIGINTERN PyObject *_wrap_HypothesisTest_PartialPearson__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10615
PyObject *resultobj = 0;
10616
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
10617
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
10618
OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices *arg3 = 0 ;
10619
OpenTURNS::NumericalScalar arg4 ;
10620
void *argp1 = 0 ;
10621
int res1 = 0 ;
10622
void *argp2 = 0 ;
10623
int res2 = 0 ;
10624
void *argp3 = 0 ;
10625
int res3 = 0 ;
10626
double val4 ;
10627
int ecode4 = 0 ;
10628
PyObject * obj0 = 0 ;
10629
PyObject * obj1 = 0 ;
10630
PyObject * obj2 = 0 ;
10631
PyObject * obj3 = 0 ;
10632
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection result;
10633
10634
if (!PyArg_ParseTuple(args,(char *)"OOOO:HypothesisTest_PartialPearson",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10635
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10636
if (!SWIG_IsOK(res1)) {
10637
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_PartialPearson" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10638
}
10639
if (!argp1) {
10640
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialPearson" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10641
}
10642
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
10643
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10644
if (!SWIG_IsOK(res2)) {
10645
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_PartialPearson" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10646
}
10647
if (!argp2) {
10648
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialPearson" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10649
}
10650
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
10651
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Type__Indices, 0 | 0);
10652
if (!SWIG_IsOK(res3)) {
10653
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypothesisTest_PartialPearson" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &""'");
10654
}
10655
if (!argp3) {
10656
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialPearson" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &""'");
10657
}
10658
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices * >(argp3);
10659
ecode4 = SWIG_AsVal_double(obj3, &val4);
10660
if (!SWIG_IsOK(ecode4)) {
10661
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypothesisTest_PartialPearson" "', argument " "4"" of type '" "OpenTURNS::NumericalScalar""'");
10662
}
10663
arg4 = static_cast< OpenTURNS::NumericalScalar >(val4);
10664
{
10665
try {
10666
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::PartialPearson((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Type::Indices const &)*arg3,arg4);
10667
}
10668
catch (OT::Base::Common::InvalidArgumentException & ex) {
10669
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
10670
}
10671
catch (OT::Base::Common::OutOfBoundException & ex) {
10672
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
10673
}
10674
catch (OT::Base::Common::Exception & ex) {
10675
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
10676
}
10677
catch (std::out_of_range & ex) {
10678
SWIG_exception(SWIG_IndexError,ex.what());
10679
}
10680
catch (std::exception & ex) {
10681
SWIG_exception(SWIG_RuntimeError,ex.what());
10682
}
10683
}
10684
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_OWN | 0 );
10685
return resultobj;
10686
fail:
10687
return NULL;
10688
}
10689
10690
10691
SWIGINTERN PyObject *_wrap_HypothesisTest_PartialPearson__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10692
PyObject *resultobj = 0;
10693
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
10694
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
10695
OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices *arg3 = 0 ;
10696
void *argp1 = 0 ;
10697
int res1 = 0 ;
10698
void *argp2 = 0 ;
10699
int res2 = 0 ;
10700
void *argp3 = 0 ;
10701
int res3 = 0 ;
10702
PyObject * obj0 = 0 ;
10703
PyObject * obj1 = 0 ;
10704
PyObject * obj2 = 0 ;
10705
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection result;
10706
10707
if (!PyArg_ParseTuple(args,(char *)"OOO:HypothesisTest_PartialPearson",&obj0,&obj1,&obj2)) SWIG_fail;
10708
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10709
if (!SWIG_IsOK(res1)) {
10710
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_PartialPearson" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10711
}
10712
if (!argp1) {
10713
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialPearson" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10714
}
10715
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
10716
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10717
if (!SWIG_IsOK(res2)) {
10718
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_PartialPearson" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10719
}
10720
if (!argp2) {
10721
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialPearson" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10722
}
10723
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
10724
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Type__Indices, 0 | 0);
10725
if (!SWIG_IsOK(res3)) {
10726
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypothesisTest_PartialPearson" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &""'");
10727
}
10728
if (!argp3) {
10729
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialPearson" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &""'");
10730
}
10731
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices * >(argp3);
10732
{
10733
try {
10734
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::PartialPearson((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Type::Indices const &)*arg3);
10735
}
10736
catch (OT::Base::Common::InvalidArgumentException & ex) {
10737
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
10738
}
10739
catch (OT::Base::Common::OutOfBoundException & ex) {
10740
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
10741
}
10742
catch (OT::Base::Common::Exception & ex) {
10743
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
10744
}
10745
catch (std::out_of_range & ex) {
10746
SWIG_exception(SWIG_IndexError,ex.what());
10747
}
10748
catch (std::exception & ex) {
10749
SWIG_exception(SWIG_RuntimeError,ex.what());
10750
}
10751
}
10752
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_OWN | 0 );
10753
return resultobj;
10754
fail:
10755
return NULL;
10756
}
10757
10758
10759
SWIGINTERN PyObject *_wrap_HypothesisTest_PartialPearson(PyObject *self, PyObject *args) {
10760
int argc;
10761
PyObject *argv[5];
10762
int ii;
10763
10764
if (!PyTuple_Check(args)) SWIG_fail;
10765
argc = (int)PyObject_Length(args);
10766
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
10767
argv[ii] = PyTuple_GET_ITEM(args,ii);
10768
}
10769
if (argc == 3) {
10770
int _v;
10771
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10772
_v = SWIG_CheckState(res);
10773
if (_v) {
10774
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10775
_v = SWIG_CheckState(res);
10776
if (_v) {
10777
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_OpenTURNS__Base__Type__Indices, 0);
10778
_v = SWIG_CheckState(res);
10779
if (_v) {
10780
return _wrap_HypothesisTest_PartialPearson__SWIG_1(self, args);
10781
}
10782
}
10783
}
10784
}
10785
if (argc == 4) {
10786
int _v;
10787
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10788
_v = SWIG_CheckState(res);
10789
if (_v) {
10790
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10791
_v = SWIG_CheckState(res);
10792
if (_v) {
10793
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_OpenTURNS__Base__Type__Indices, 0);
10794
_v = SWIG_CheckState(res);
10795
if (_v) {
10796
{
10797
int res = SWIG_AsVal_double(argv[3], NULL);
10798
_v = SWIG_CheckState(res);
10799
}
10800
if (_v) {
10801
return _wrap_HypothesisTest_PartialPearson__SWIG_0(self, args);
10802
}
10803
}
10804
}
10805
}
10806
}
10807
10808
fail:
10809
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'HypothesisTest_PartialPearson'.\n"
10810
" Possible C/C++ prototypes are:\n"
10811
" PartialPearson(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &,OpenTURNS::NumericalScalar const)\n"
10812
" OpenTURNS::Uncertainty::StatTest::HypothesisTest::PartialPearson(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &)\n");
10813
return NULL;
10814
}
10815
10816
10817
SWIGINTERN PyObject *_wrap_HypothesisTest_PartialRegression__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10818
PyObject *resultobj = 0;
10819
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
10820
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
10821
OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices *arg3 = 0 ;
10822
OpenTURNS::NumericalScalar arg4 ;
10823
void *argp1 = 0 ;
10824
int res1 = 0 ;
10825
void *argp2 = 0 ;
10826
int res2 = 0 ;
10827
void *argp3 = 0 ;
10828
int res3 = 0 ;
10829
double val4 ;
10830
int ecode4 = 0 ;
10831
PyObject * obj0 = 0 ;
10832
PyObject * obj1 = 0 ;
10833
PyObject * obj2 = 0 ;
10834
PyObject * obj3 = 0 ;
10835
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection result;
10836
10837
if (!PyArg_ParseTuple(args,(char *)"OOOO:HypothesisTest_PartialRegression",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10838
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10839
if (!SWIG_IsOK(res1)) {
10840
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_PartialRegression" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10841
}
10842
if (!argp1) {
10843
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialRegression" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10844
}
10845
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
10846
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10847
if (!SWIG_IsOK(res2)) {
10848
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_PartialRegression" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10849
}
10850
if (!argp2) {
10851
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialRegression" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10852
}
10853
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
10854
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Type__Indices, 0 | 0);
10855
if (!SWIG_IsOK(res3)) {
10856
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypothesisTest_PartialRegression" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &""'");
10857
}
10858
if (!argp3) {
10859
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialRegression" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &""'");
10860
}
10861
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices * >(argp3);
10862
ecode4 = SWIG_AsVal_double(obj3, &val4);
10863
if (!SWIG_IsOK(ecode4)) {
10864
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypothesisTest_PartialRegression" "', argument " "4"" of type '" "OpenTURNS::NumericalScalar""'");
10865
}
10866
arg4 = static_cast< OpenTURNS::NumericalScalar >(val4);
10867
{
10868
try {
10869
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::PartialRegression((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Type::Indices const &)*arg3,arg4);
10870
}
10871
catch (OT::Base::Common::InvalidArgumentException & ex) {
10872
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
10873
}
10874
catch (OT::Base::Common::OutOfBoundException & ex) {
10875
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
10876
}
10877
catch (OT::Base::Common::Exception & ex) {
10878
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
10879
}
10880
catch (std::out_of_range & ex) {
10881
SWIG_exception(SWIG_IndexError,ex.what());
10882
}
10883
catch (std::exception & ex) {
10884
SWIG_exception(SWIG_RuntimeError,ex.what());
10885
}
10886
}
10887
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_OWN | 0 );
10888
return resultobj;
10889
fail:
10890
return NULL;
10891
}
10892
10893
10894
SWIGINTERN PyObject *_wrap_HypothesisTest_PartialRegression__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10895
PyObject *resultobj = 0;
10896
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
10897
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
10898
OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices *arg3 = 0 ;
10899
void *argp1 = 0 ;
10900
int res1 = 0 ;
10901
void *argp2 = 0 ;
10902
int res2 = 0 ;
10903
void *argp3 = 0 ;
10904
int res3 = 0 ;
10905
PyObject * obj0 = 0 ;
10906
PyObject * obj1 = 0 ;
10907
PyObject * obj2 = 0 ;
10908
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection result;
10909
10910
if (!PyArg_ParseTuple(args,(char *)"OOO:HypothesisTest_PartialRegression",&obj0,&obj1,&obj2)) SWIG_fail;
10911
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10912
if (!SWIG_IsOK(res1)) {
10913
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_PartialRegression" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10914
}
10915
if (!argp1) {
10916
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialRegression" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10917
}
10918
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
10919
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
10920
if (!SWIG_IsOK(res2)) {
10921
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_PartialRegression" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10922
}
10923
if (!argp2) {
10924
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialRegression" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
10925
}
10926
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
10927
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Type__Indices, 0 | 0);
10928
if (!SWIG_IsOK(res3)) {
10929
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypothesisTest_PartialRegression" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &""'");
10930
}
10931
if (!argp3) {
10932
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialRegression" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &""'");
10933
}
10934
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices * >(argp3);
10935
{
10936
try {
10937
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::PartialRegression((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Type::Indices const &)*arg3);
10938
}
10939
catch (OT::Base::Common::InvalidArgumentException & ex) {
10940
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
10941
}
10942
catch (OT::Base::Common::OutOfBoundException & ex) {
10943
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
10944
}
10945
catch (OT::Base::Common::Exception & ex) {
10946
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
10947
}
10948
catch (std::out_of_range & ex) {
10949
SWIG_exception(SWIG_IndexError,ex.what());
10950
}
10951
catch (std::exception & ex) {
10952
SWIG_exception(SWIG_RuntimeError,ex.what());
10953
}
10954
}
10955
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_OWN | 0 );
10956
return resultobj;
10957
fail:
10958
return NULL;
10959
}
10960
10961
10962
SWIGINTERN PyObject *_wrap_HypothesisTest_PartialRegression(PyObject *self, PyObject *args) {
10963
int argc;
10964
PyObject *argv[5];
10965
int ii;
10966
10967
if (!PyTuple_Check(args)) SWIG_fail;
10968
argc = (int)PyObject_Length(args);
10969
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
10970
argv[ii] = PyTuple_GET_ITEM(args,ii);
10971
}
10972
if (argc == 3) {
10973
int _v;
10974
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10975
_v = SWIG_CheckState(res);
10976
if (_v) {
10977
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10978
_v = SWIG_CheckState(res);
10979
if (_v) {
10980
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_OpenTURNS__Base__Type__Indices, 0);
10981
_v = SWIG_CheckState(res);
10982
if (_v) {
10983
return _wrap_HypothesisTest_PartialRegression__SWIG_1(self, args);
10984
}
10985
}
10986
}
10987
}
10988
if (argc == 4) {
10989
int _v;
10990
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10991
_v = SWIG_CheckState(res);
10992
if (_v) {
10993
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
10994
_v = SWIG_CheckState(res);
10995
if (_v) {
10996
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_OpenTURNS__Base__Type__Indices, 0);
10997
_v = SWIG_CheckState(res);
10998
if (_v) {
10999
{
11000
int res = SWIG_AsVal_double(argv[3], NULL);
11001
_v = SWIG_CheckState(res);
11002
}
11003
if (_v) {
11004
return _wrap_HypothesisTest_PartialRegression__SWIG_0(self, args);
11005
}
11006
}
11007
}
11008
}
11009
}
11010
11011
fail:
11012
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'HypothesisTest_PartialRegression'.\n"
11013
" Possible C/C++ prototypes are:\n"
11014
" PartialRegression(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &,OpenTURNS::NumericalScalar const)\n"
11015
" OpenTURNS::Uncertainty::StatTest::HypothesisTest::PartialRegression(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &)\n");
11016
return NULL;
11017
}
11018
11019
11020
SWIGINTERN PyObject *_wrap_HypothesisTest_PartialSpearman__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11021
PyObject *resultobj = 0;
11022
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
11023
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
11024
OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices *arg3 = 0 ;
11025
OpenTURNS::NumericalScalar arg4 ;
11026
void *argp1 = 0 ;
11027
int res1 = 0 ;
11028
void *argp2 = 0 ;
11029
int res2 = 0 ;
11030
void *argp3 = 0 ;
11031
int res3 = 0 ;
11032
double val4 ;
11033
int ecode4 = 0 ;
11034
PyObject * obj0 = 0 ;
11035
PyObject * obj1 = 0 ;
11036
PyObject * obj2 = 0 ;
11037
PyObject * obj3 = 0 ;
11038
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection result;
11039
11040
if (!PyArg_ParseTuple(args,(char *)"OOOO:HypothesisTest_PartialSpearman",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11041
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11042
if (!SWIG_IsOK(res1)) {
11043
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_PartialSpearman" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11044
}
11045
if (!argp1) {
11046
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialSpearman" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11047
}
11048
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
11049
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11050
if (!SWIG_IsOK(res2)) {
11051
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_PartialSpearman" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11052
}
11053
if (!argp2) {
11054
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialSpearman" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11055
}
11056
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
11057
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Type__Indices, 0 | 0);
11058
if (!SWIG_IsOK(res3)) {
11059
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypothesisTest_PartialSpearman" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &""'");
11060
}
11061
if (!argp3) {
11062
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialSpearman" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &""'");
11063
}
11064
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices * >(argp3);
11065
ecode4 = SWIG_AsVal_double(obj3, &val4);
11066
if (!SWIG_IsOK(ecode4)) {
11067
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypothesisTest_PartialSpearman" "', argument " "4"" of type '" "OpenTURNS::NumericalScalar""'");
11068
}
11069
arg4 = static_cast< OpenTURNS::NumericalScalar >(val4);
11070
{
11071
try {
11072
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::PartialSpearman((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Type::Indices const &)*arg3,arg4);
11073
}
11074
catch (OT::Base::Common::InvalidArgumentException & ex) {
11075
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
11076
}
11077
catch (OT::Base::Common::OutOfBoundException & ex) {
11078
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
11079
}
11080
catch (OT::Base::Common::Exception & ex) {
11081
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
11082
}
11083
catch (std::out_of_range & ex) {
11084
SWIG_exception(SWIG_IndexError,ex.what());
11085
}
11086
catch (std::exception & ex) {
11087
SWIG_exception(SWIG_RuntimeError,ex.what());
11088
}
11089
}
11090
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_OWN | 0 );
11091
return resultobj;
11092
fail:
11093
return NULL;
11094
}
11095
11096
11097
SWIGINTERN PyObject *_wrap_HypothesisTest_PartialSpearman__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11098
PyObject *resultobj = 0;
11099
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
11100
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
11101
OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices *arg3 = 0 ;
11102
void *argp1 = 0 ;
11103
int res1 = 0 ;
11104
void *argp2 = 0 ;
11105
int res2 = 0 ;
11106
void *argp3 = 0 ;
11107
int res3 = 0 ;
11108
PyObject * obj0 = 0 ;
11109
PyObject * obj1 = 0 ;
11110
PyObject * obj2 = 0 ;
11111
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection result;
11112
11113
if (!PyArg_ParseTuple(args,(char *)"OOO:HypothesisTest_PartialSpearman",&obj0,&obj1,&obj2)) SWIG_fail;
11114
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11115
if (!SWIG_IsOK(res1)) {
11116
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_PartialSpearman" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11117
}
11118
if (!argp1) {
11119
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialSpearman" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11120
}
11121
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
11122
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11123
if (!SWIG_IsOK(res2)) {
11124
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_PartialSpearman" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11125
}
11126
if (!argp2) {
11127
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialSpearman" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11128
}
11129
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
11130
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Type__Indices, 0 | 0);
11131
if (!SWIG_IsOK(res3)) {
11132
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypothesisTest_PartialSpearman" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &""'");
11133
}
11134
if (!argp3) {
11135
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_PartialSpearman" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &""'");
11136
}
11137
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices * >(argp3);
11138
{
11139
try {
11140
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::PartialSpearman((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Type::Indices const &)*arg3);
11141
}
11142
catch (OT::Base::Common::InvalidArgumentException & ex) {
11143
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
11144
}
11145
catch (OT::Base::Common::OutOfBoundException & ex) {
11146
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
11147
}
11148
catch (OT::Base::Common::Exception & ex) {
11149
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
11150
}
11151
catch (std::out_of_range & ex) {
11152
SWIG_exception(SWIG_IndexError,ex.what());
11153
}
11154
catch (std::exception & ex) {
11155
SWIG_exception(SWIG_RuntimeError,ex.what());
11156
}
11157
}
11158
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_OWN | 0 );
11159
return resultobj;
11160
fail:
11161
return NULL;
11162
}
11163
11164
11165
SWIGINTERN PyObject *_wrap_HypothesisTest_PartialSpearman(PyObject *self, PyObject *args) {
11166
int argc;
11167
PyObject *argv[5];
11168
int ii;
11169
11170
if (!PyTuple_Check(args)) SWIG_fail;
11171
argc = (int)PyObject_Length(args);
11172
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
11173
argv[ii] = PyTuple_GET_ITEM(args,ii);
11174
}
11175
if (argc == 3) {
11176
int _v;
11177
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11178
_v = SWIG_CheckState(res);
11179
if (_v) {
11180
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11181
_v = SWIG_CheckState(res);
11182
if (_v) {
11183
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_OpenTURNS__Base__Type__Indices, 0);
11184
_v = SWIG_CheckState(res);
11185
if (_v) {
11186
return _wrap_HypothesisTest_PartialSpearman__SWIG_1(self, args);
11187
}
11188
}
11189
}
11190
}
11191
if (argc == 4) {
11192
int _v;
11193
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11194
_v = SWIG_CheckState(res);
11195
if (_v) {
11196
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11197
_v = SWIG_CheckState(res);
11198
if (_v) {
11199
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_OpenTURNS__Base__Type__Indices, 0);
11200
_v = SWIG_CheckState(res);
11201
if (_v) {
11202
{
11203
int res = SWIG_AsVal_double(argv[3], NULL);
11204
_v = SWIG_CheckState(res);
11205
}
11206
if (_v) {
11207
return _wrap_HypothesisTest_PartialSpearman__SWIG_0(self, args);
11208
}
11209
}
11210
}
11211
}
11212
}
11213
11214
fail:
11215
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'HypothesisTest_PartialSpearman'.\n"
11216
" Possible C/C++ prototypes are:\n"
11217
" PartialSpearman(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &,OpenTURNS::NumericalScalar const)\n"
11218
" OpenTURNS::Uncertainty::StatTest::HypothesisTest::PartialSpearman(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices const &)\n");
11219
return NULL;
11220
}
11221
11222
11223
SWIGINTERN PyObject *_wrap_HypothesisTest_FullPearson__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11224
PyObject *resultobj = 0;
11225
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
11226
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
11227
OpenTURNS::NumericalScalar arg3 ;
11228
void *argp1 = 0 ;
11229
int res1 = 0 ;
11230
void *argp2 = 0 ;
11231
int res2 = 0 ;
11232
double val3 ;
11233
int ecode3 = 0 ;
11234
PyObject * obj0 = 0 ;
11235
PyObject * obj1 = 0 ;
11236
PyObject * obj2 = 0 ;
11237
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection result;
11238
11239
if (!PyArg_ParseTuple(args,(char *)"OOO:HypothesisTest_FullPearson",&obj0,&obj1,&obj2)) SWIG_fail;
11240
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11241
if (!SWIG_IsOK(res1)) {
11242
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_FullPearson" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11243
}
11244
if (!argp1) {
11245
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_FullPearson" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11246
}
11247
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
11248
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11249
if (!SWIG_IsOK(res2)) {
11250
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_FullPearson" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11251
}
11252
if (!argp2) {
11253
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_FullPearson" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11254
}
11255
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
11256
ecode3 = SWIG_AsVal_double(obj2, &val3);
11257
if (!SWIG_IsOK(ecode3)) {
11258
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HypothesisTest_FullPearson" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
11259
}
11260
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
11261
{
11262
try {
11263
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::FullPearson((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,arg3);
11264
}
11265
catch (OT::Base::Common::InvalidArgumentException & ex) {
11266
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
11267
}
11268
catch (OT::Base::Common::OutOfBoundException & ex) {
11269
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
11270
}
11271
catch (OT::Base::Common::Exception & ex) {
11272
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
11273
}
11274
catch (std::out_of_range & ex) {
11275
SWIG_exception(SWIG_IndexError,ex.what());
11276
}
11277
catch (std::exception & ex) {
11278
SWIG_exception(SWIG_RuntimeError,ex.what());
11279
}
11280
}
11281
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_OWN | 0 );
11282
return resultobj;
11283
fail:
11284
return NULL;
11285
}
11286
11287
11288
SWIGINTERN PyObject *_wrap_HypothesisTest_FullPearson__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11289
PyObject *resultobj = 0;
11290
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
11291
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
11292
void *argp1 = 0 ;
11293
int res1 = 0 ;
11294
void *argp2 = 0 ;
11295
int res2 = 0 ;
11296
PyObject * obj0 = 0 ;
11297
PyObject * obj1 = 0 ;
11298
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection result;
11299
11300
if (!PyArg_ParseTuple(args,(char *)"OO:HypothesisTest_FullPearson",&obj0,&obj1)) SWIG_fail;
11301
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11302
if (!SWIG_IsOK(res1)) {
11303
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_FullPearson" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11304
}
11305
if (!argp1) {
11306
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_FullPearson" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11307
}
11308
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
11309
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11310
if (!SWIG_IsOK(res2)) {
11311
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_FullPearson" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11312
}
11313
if (!argp2) {
11314
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_FullPearson" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11315
}
11316
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
11317
{
11318
try {
11319
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::FullPearson((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2);
11320
}
11321
catch (OT::Base::Common::InvalidArgumentException & ex) {
11322
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
11323
}
11324
catch (OT::Base::Common::OutOfBoundException & ex) {
11325
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
11326
}
11327
catch (OT::Base::Common::Exception & ex) {
11328
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
11329
}
11330
catch (std::out_of_range & ex) {
11331
SWIG_exception(SWIG_IndexError,ex.what());
11332
}
11333
catch (std::exception & ex) {
11334
SWIG_exception(SWIG_RuntimeError,ex.what());
11335
}
11336
}
11337
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_OWN | 0 );
11338
return resultobj;
11339
fail:
11340
return NULL;
11341
}
11342
11343
11344
SWIGINTERN PyObject *_wrap_HypothesisTest_FullPearson(PyObject *self, PyObject *args) {
11345
int argc;
11346
PyObject *argv[4];
11347
int ii;
11348
11349
if (!PyTuple_Check(args)) SWIG_fail;
11350
argc = (int)PyObject_Length(args);
11351
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11352
argv[ii] = PyTuple_GET_ITEM(args,ii);
11353
}
11354
if (argc == 2) {
11355
int _v;
11356
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11357
_v = SWIG_CheckState(res);
11358
if (_v) {
11359
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11360
_v = SWIG_CheckState(res);
11361
if (_v) {
11362
return _wrap_HypothesisTest_FullPearson__SWIG_1(self, args);
11363
}
11364
}
11365
}
11366
if (argc == 3) {
11367
int _v;
11368
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11369
_v = SWIG_CheckState(res);
11370
if (_v) {
11371
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11372
_v = SWIG_CheckState(res);
11373
if (_v) {
11374
{
11375
int res = SWIG_AsVal_double(argv[2], NULL);
11376
_v = SWIG_CheckState(res);
11377
}
11378
if (_v) {
11379
return _wrap_HypothesisTest_FullPearson__SWIG_0(self, args);
11380
}
11381
}
11382
}
11383
}
11384
11385
fail:
11386
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'HypothesisTest_FullPearson'.\n"
11387
" Possible C/C++ prototypes are:\n"
11388
" FullPearson(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::NumericalScalar const)\n"
11389
" OpenTURNS::Uncertainty::StatTest::HypothesisTest::FullPearson(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &)\n");
11390
return NULL;
11391
}
11392
11393
11394
SWIGINTERN PyObject *_wrap_HypothesisTest_FullRegression__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11395
PyObject *resultobj = 0;
11396
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
11397
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
11398
OpenTURNS::NumericalScalar arg3 ;
11399
void *argp1 = 0 ;
11400
int res1 = 0 ;
11401
void *argp2 = 0 ;
11402
int res2 = 0 ;
11403
double val3 ;
11404
int ecode3 = 0 ;
11405
PyObject * obj0 = 0 ;
11406
PyObject * obj1 = 0 ;
11407
PyObject * obj2 = 0 ;
11408
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection result;
11409
11410
if (!PyArg_ParseTuple(args,(char *)"OOO:HypothesisTest_FullRegression",&obj0,&obj1,&obj2)) SWIG_fail;
11411
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11412
if (!SWIG_IsOK(res1)) {
11413
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_FullRegression" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11414
}
11415
if (!argp1) {
11416
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_FullRegression" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11417
}
11418
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
11419
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11420
if (!SWIG_IsOK(res2)) {
11421
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_FullRegression" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11422
}
11423
if (!argp2) {
11424
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_FullRegression" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11425
}
11426
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
11427
ecode3 = SWIG_AsVal_double(obj2, &val3);
11428
if (!SWIG_IsOK(ecode3)) {
11429
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HypothesisTest_FullRegression" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
11430
}
11431
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
11432
{
11433
try {
11434
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::FullRegression((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,arg3);
11435
}
11436
catch (OT::Base::Common::InvalidArgumentException & ex) {
11437
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
11438
}
11439
catch (OT::Base::Common::OutOfBoundException & ex) {
11440
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
11441
}
11442
catch (OT::Base::Common::Exception & ex) {
11443
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
11444
}
11445
catch (std::out_of_range & ex) {
11446
SWIG_exception(SWIG_IndexError,ex.what());
11447
}
11448
catch (std::exception & ex) {
11449
SWIG_exception(SWIG_RuntimeError,ex.what());
11450
}
11451
}
11452
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_OWN | 0 );
11453
return resultobj;
11454
fail:
11455
return NULL;
11456
}
11457
11458
11459
SWIGINTERN PyObject *_wrap_HypothesisTest_FullRegression__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11460
PyObject *resultobj = 0;
11461
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
11462
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
11463
void *argp1 = 0 ;
11464
int res1 = 0 ;
11465
void *argp2 = 0 ;
11466
int res2 = 0 ;
11467
PyObject * obj0 = 0 ;
11468
PyObject * obj1 = 0 ;
11469
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection result;
11470
11471
if (!PyArg_ParseTuple(args,(char *)"OO:HypothesisTest_FullRegression",&obj0,&obj1)) SWIG_fail;
11472
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11473
if (!SWIG_IsOK(res1)) {
11474
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_FullRegression" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11475
}
11476
if (!argp1) {
11477
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_FullRegression" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11478
}
11479
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
11480
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11481
if (!SWIG_IsOK(res2)) {
11482
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_FullRegression" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11483
}
11484
if (!argp2) {
11485
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_FullRegression" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11486
}
11487
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
11488
{
11489
try {
11490
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::FullRegression((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2);
11491
}
11492
catch (OT::Base::Common::InvalidArgumentException & ex) {
11493
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
11494
}
11495
catch (OT::Base::Common::OutOfBoundException & ex) {
11496
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
11497
}
11498
catch (OT::Base::Common::Exception & ex) {
11499
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
11500
}
11501
catch (std::out_of_range & ex) {
11502
SWIG_exception(SWIG_IndexError,ex.what());
11503
}
11504
catch (std::exception & ex) {
11505
SWIG_exception(SWIG_RuntimeError,ex.what());
11506
}
11507
}
11508
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_OWN | 0 );
11509
return resultobj;
11510
fail:
11511
return NULL;
11512
}
11513
11514
11515
SWIGINTERN PyObject *_wrap_HypothesisTest_FullRegression(PyObject *self, PyObject *args) {
11516
int argc;
11517
PyObject *argv[4];
11518
int ii;
11519
11520
if (!PyTuple_Check(args)) SWIG_fail;
11521
argc = (int)PyObject_Length(args);
11522
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11523
argv[ii] = PyTuple_GET_ITEM(args,ii);
11524
}
11525
if (argc == 2) {
11526
int _v;
11527
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11528
_v = SWIG_CheckState(res);
11529
if (_v) {
11530
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11531
_v = SWIG_CheckState(res);
11532
if (_v) {
11533
return _wrap_HypothesisTest_FullRegression__SWIG_1(self, args);
11534
}
11535
}
11536
}
11537
if (argc == 3) {
11538
int _v;
11539
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11540
_v = SWIG_CheckState(res);
11541
if (_v) {
11542
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11543
_v = SWIG_CheckState(res);
11544
if (_v) {
11545
{
11546
int res = SWIG_AsVal_double(argv[2], NULL);
11547
_v = SWIG_CheckState(res);
11548
}
11549
if (_v) {
11550
return _wrap_HypothesisTest_FullRegression__SWIG_0(self, args);
11551
}
11552
}
11553
}
11554
}
11555
11556
fail:
11557
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'HypothesisTest_FullRegression'.\n"
11558
" Possible C/C++ prototypes are:\n"
11559
" FullRegression(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::NumericalScalar const)\n"
11560
" OpenTURNS::Uncertainty::StatTest::HypothesisTest::FullRegression(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &)\n");
11561
return NULL;
11562
}
11563
11564
11565
SWIGINTERN PyObject *_wrap_HypothesisTest_FullSpearman__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11566
PyObject *resultobj = 0;
11567
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
11568
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
11569
OpenTURNS::NumericalScalar arg3 ;
11570
void *argp1 = 0 ;
11571
int res1 = 0 ;
11572
void *argp2 = 0 ;
11573
int res2 = 0 ;
11574
double val3 ;
11575
int ecode3 = 0 ;
11576
PyObject * obj0 = 0 ;
11577
PyObject * obj1 = 0 ;
11578
PyObject * obj2 = 0 ;
11579
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection result;
11580
11581
if (!PyArg_ParseTuple(args,(char *)"OOO:HypothesisTest_FullSpearman",&obj0,&obj1,&obj2)) SWIG_fail;
11582
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11583
if (!SWIG_IsOK(res1)) {
11584
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_FullSpearman" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11585
}
11586
if (!argp1) {
11587
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_FullSpearman" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11588
}
11589
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
11590
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11591
if (!SWIG_IsOK(res2)) {
11592
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_FullSpearman" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11593
}
11594
if (!argp2) {
11595
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_FullSpearman" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11596
}
11597
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
11598
ecode3 = SWIG_AsVal_double(obj2, &val3);
11599
if (!SWIG_IsOK(ecode3)) {
11600
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HypothesisTest_FullSpearman" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
11601
}
11602
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
11603
{
11604
try {
11605
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::FullSpearman((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,arg3);
11606
}
11607
catch (OT::Base::Common::InvalidArgumentException & ex) {
11608
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
11609
}
11610
catch (OT::Base::Common::OutOfBoundException & ex) {
11611
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
11612
}
11613
catch (OT::Base::Common::Exception & ex) {
11614
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
11615
}
11616
catch (std::out_of_range & ex) {
11617
SWIG_exception(SWIG_IndexError,ex.what());
11618
}
11619
catch (std::exception & ex) {
11620
SWIG_exception(SWIG_RuntimeError,ex.what());
11621
}
11622
}
11623
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_OWN | 0 );
11624
return resultobj;
11625
fail:
11626
return NULL;
11627
}
11628
11629
11630
SWIGINTERN PyObject *_wrap_HypothesisTest_FullSpearman__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11631
PyObject *resultobj = 0;
11632
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg1 = 0 ;
11633
OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *arg2 = 0 ;
11634
void *argp1 = 0 ;
11635
int res1 = 0 ;
11636
void *argp2 = 0 ;
11637
int res2 = 0 ;
11638
PyObject * obj0 = 0 ;
11639
PyObject * obj1 = 0 ;
11640
OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection result;
11641
11642
if (!PyArg_ParseTuple(args,(char *)"OO:HypothesisTest_FullSpearman",&obj0,&obj1)) SWIG_fail;
11643
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11644
if (!SWIG_IsOK(res1)) {
11645
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypothesisTest_FullSpearman" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11646
}
11647
if (!argp1) {
11648
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_FullSpearman" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11649
}
11650
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp1);
11651
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11652
if (!SWIG_IsOK(res2)) {
11653
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypothesisTest_FullSpearman" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11654
}
11655
if (!argp2) {
11656
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypothesisTest_FullSpearman" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &""'");
11657
}
11658
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample * >(argp2);
11659
{
11660
try {
11661
result = OpenTURNS::Uncertainty::StatTest::HypothesisTest::FullSpearman((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2);
11662
}
11663
catch (OT::Base::Common::InvalidArgumentException & ex) {
11664
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
11665
}
11666
catch (OT::Base::Common::OutOfBoundException & ex) {
11667
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
11668
}
11669
catch (OT::Base::Common::Exception & ex) {
11670
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
11671
}
11672
catch (std::out_of_range & ex) {
11673
SWIG_exception(SWIG_IndexError,ex.what());
11674
}
11675
catch (std::exception & ex) {
11676
SWIG_exception(SWIG_RuntimeError,ex.what());
11677
}
11678
}
11679
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection(static_cast< const OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, SWIG_POINTER_OWN | 0 );
11680
return resultobj;
11681
fail:
11682
return NULL;
11683
}
11684
11685
11686
SWIGINTERN PyObject *_wrap_HypothesisTest_FullSpearman(PyObject *self, PyObject *args) {
11687
int argc;
11688
PyObject *argv[4];
11689
int ii;
11690
11691
if (!PyTuple_Check(args)) SWIG_fail;
11692
argc = (int)PyObject_Length(args);
11693
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11694
argv[ii] = PyTuple_GET_ITEM(args,ii);
11695
}
11696
if (argc == 2) {
11697
int _v;
11698
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11699
_v = SWIG_CheckState(res);
11700
if (_v) {
11701
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11702
_v = SWIG_CheckState(res);
11703
if (_v) {
11704
return _wrap_HypothesisTest_FullSpearman__SWIG_1(self, args);
11705
}
11706
}
11707
}
11708
if (argc == 3) {
11709
int _v;
11710
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11711
_v = SWIG_CheckState(res);
11712
if (_v) {
11713
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
11714
_v = SWIG_CheckState(res);
11715
if (_v) {
11716
{
11717
int res = SWIG_AsVal_double(argv[2], NULL);
11718
_v = SWIG_CheckState(res);
11719
}
11720
if (_v) {
11721
return _wrap_HypothesisTest_FullSpearman__SWIG_0(self, args);
11722
}
11723
}
11724
}
11725
}
11726
11727
fail:
11728
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'HypothesisTest_FullSpearman'.\n"
11729
" Possible C/C++ prototypes are:\n"
11730
" FullSpearman(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::NumericalScalar const)\n"
11731
" OpenTURNS::Uncertainty::StatTest::HypothesisTest::FullSpearman(OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample const &)\n");
11732
return NULL;
11733
}
11734
11735
11736
SWIGINTERN PyObject *_wrap_new_HypothesisTest__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11737
PyObject *resultobj = 0;
11738
OpenTURNS::Uncertainty::StatTest::HypothesisTest *arg1 = 0 ;
11739
void *argp1 = 0 ;
11740
int res1 = 0 ;
11741
PyObject * obj0 = 0 ;
11742
OpenTURNS::Uncertainty::StatTest::HypothesisTest *result = 0 ;
11743
11744
if (!PyArg_ParseTuple(args,(char *)"O:new_HypothesisTest",&obj0)) SWIG_fail;
11745
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__HypothesisTest, 0 | 0);
11746
if (!SWIG_IsOK(res1)) {
11747
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypothesisTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest const &""'");
11748
}
11749
if (!argp1) {
11750
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HypothesisTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest const &""'");
11751
}
11752
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest * >(argp1);
11753
{
11754
try {
11755
result = (OpenTURNS::Uncertainty::StatTest::HypothesisTest *)new_OpenTURNS_Uncertainty_StatTest_HypothesisTest__SWIG_1((OpenTURNS::Uncertainty::StatTest::HypothesisTest const &)*arg1);
11756
}
11757
catch (OT::Base::Common::InvalidArgumentException & ex) {
11758
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
11759
}
11760
catch (OT::Base::Common::OutOfBoundException & ex) {
11761
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
11762
}
11763
catch (OT::Base::Common::Exception & ex) {
11764
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
11765
}
11766
catch (std::out_of_range & ex) {
11767
SWIG_exception(SWIG_IndexError,ex.what());
11768
}
11769
catch (std::exception & ex) {
11770
SWIG_exception(SWIG_RuntimeError,ex.what());
11771
}
11772
}
11773
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__HypothesisTest, SWIG_POINTER_NEW | 0 );
11774
return resultobj;
11775
fail:
11776
return NULL;
11777
}
11778
11779
11780
SWIGINTERN PyObject *_wrap_new_HypothesisTest(PyObject *self, PyObject *args) {
11781
int argc;
11782
PyObject *argv[2];
11783
int ii;
11784
11785
if (!PyTuple_Check(args)) SWIG_fail;
11786
argc = (int)PyObject_Length(args);
11787
for (ii = 0; (ii < argc) && (ii < 1); ii++) {
11788
argv[ii] = PyTuple_GET_ITEM(args,ii);
11789
}
11790
if (argc == 0) {
11791
return _wrap_new_HypothesisTest__SWIG_0(self, args);
11792
}
11793
if (argc == 1) {
11794
int _v;
11795
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__HypothesisTest, 0);
11796
_v = SWIG_CheckState(res);
11797
if (_v) {
11798
return _wrap_new_HypothesisTest__SWIG_1(self, args);
11799
}
11800
}
11801
11802
fail:
11803
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_HypothesisTest'.\n"
11804
" Possible C/C++ prototypes are:\n"
11805
" OpenTURNS::Uncertainty::StatTest::HypothesisTest()\n"
11806
" OpenTURNS::Uncertainty::StatTest::HypothesisTest(OpenTURNS::Uncertainty::StatTest::HypothesisTest const &)\n");
11807
return NULL;
11808
}
11809
11810
11811
SWIGINTERN PyObject *_wrap_delete_HypothesisTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11812
PyObject *resultobj = 0;
11813
OpenTURNS::Uncertainty::StatTest::HypothesisTest *arg1 = (OpenTURNS::Uncertainty::StatTest::HypothesisTest *) 0 ;
11814
void *argp1 = 0 ;
11815
int res1 = 0 ;
11816
PyObject * obj0 = 0 ;
11817
11818
if (!PyArg_ParseTuple(args,(char *)"O:delete_HypothesisTest",&obj0)) SWIG_fail;
11819
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__HypothesisTest, SWIG_POINTER_DISOWN | 0 );
11820
if (!SWIG_IsOK(res1)) {
11821
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HypothesisTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::HypothesisTest *""'");
11822
}
11823
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::HypothesisTest * >(argp1);
11824
{
11825
try {
11826
delete arg1;
11827
}
11828
catch (OT::Base::Common::InvalidArgumentException & ex) {
11829
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
11830
}
11831
catch (OT::Base::Common::OutOfBoundException & ex) {
11832
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
11833
}
11834
catch (OT::Base::Common::Exception & ex) {
11835
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
11836
}
11837
catch (std::out_of_range & ex) {
11838
SWIG_exception(SWIG_IndexError,ex.what());
11839
}
11840
catch (std::exception & ex) {
11841
SWIG_exception(SWIG_RuntimeError,ex.what());
11842
}
11843
}
11844
resultobj = SWIG_Py_Void();
11845
return resultobj;
11846
fail:
11847
return NULL;
11848
}
11849
11850
11851
SWIGINTERN PyObject *HypothesisTest_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11852
PyObject *obj;
11853
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
11854
SWIG_TypeNewClientData(SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__HypothesisTest, SWIG_NewClientData(obj));
11855
return SWIG_Py_Void();
11856
}
11857
11858
SWIGINTERN PyObject *_wrap_new_LinearModelTest__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11859
PyObject *resultobj = 0;
11860
OpenTURNS::Uncertainty::StatTest::LinearModelTest *result = 0 ;
11861
11862
if (!PyArg_ParseTuple(args,(char *)":new_LinearModelTest")) SWIG_fail;
11863
{
11864
try {
11865
result = (OpenTURNS::Uncertainty::StatTest::LinearModelTest *)new OpenTURNS::Uncertainty::StatTest::LinearModelTest();
11866
}
11867
catch (OT::Base::Common::InvalidArgumentException & ex) {
11868
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
11869
}
11870
catch (OT::Base::Common::OutOfBoundException & ex) {
11871
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
11872
}
11873
catch (OT::Base::Common::Exception & ex) {
11874
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
11875
}
11876
catch (std::out_of_range & ex) {
11877
SWIG_exception(SWIG_IndexError,ex.what());
11878
}
11879
catch (std::exception & ex) {
11880
SWIG_exception(SWIG_RuntimeError,ex.what());
11881
}
11882
}
11883
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__LinearModelTest, SWIG_POINTER_NEW | 0 );
11884
return resultobj;
11885
fail:
11886
return NULL;
11887
}
11888
11889
11890
SWIGINTERN PyObject *_wrap_LinearModelTest_LMAdjustedRSquared__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11891
PyObject *resultobj = 0;
11892
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
11893
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
11894
OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel *arg3 = 0 ;
11895
OpenTURNS::NumericalScalar arg4 ;
11896
void *argp1 = 0 ;
11897
int res1 = 0 ;
11898
void *argp2 = 0 ;
11899
int res2 = 0 ;
11900
void *argp3 = 0 ;
11901
int res3 = 0 ;
11902
double val4 ;
11903
int ecode4 = 0 ;
11904
PyObject * obj0 = 0 ;
11905
PyObject * obj1 = 0 ;
11906
PyObject * obj2 = 0 ;
11907
PyObject * obj3 = 0 ;
11908
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
11909
11910
if (!PyArg_ParseTuple(args,(char *)"OOOO:LinearModelTest_LMAdjustedRSquared",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11911
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11912
if (!SWIG_IsOK(res1)) {
11913
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
11914
}
11915
if (!argp1) {
11916
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
11917
}
11918
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
11919
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11920
if (!SWIG_IsOK(res2)) {
11921
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
11922
}
11923
if (!argp2) {
11924
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
11925
}
11926
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
11927
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0 | 0);
11928
if (!SWIG_IsOK(res3)) {
11929
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
11930
}
11931
if (!argp3) {
11932
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
11933
}
11934
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel * >(argp3);
11935
ecode4 = SWIG_AsVal_double(obj3, &val4);
11936
if (!SWIG_IsOK(ecode4)) {
11937
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "4"" of type '" "OpenTURNS::NumericalScalar""'");
11938
}
11939
arg4 = static_cast< OpenTURNS::NumericalScalar >(val4);
11940
{
11941
try {
11942
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMAdjustedRSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Stat::LinearModel const &)*arg3,arg4);
11943
}
11944
catch (OT::Base::Common::InvalidArgumentException & ex) {
11945
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
11946
}
11947
catch (OT::Base::Common::OutOfBoundException & ex) {
11948
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
11949
}
11950
catch (OT::Base::Common::Exception & ex) {
11951
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
11952
}
11953
catch (std::out_of_range & ex) {
11954
SWIG_exception(SWIG_IndexError,ex.what());
11955
}
11956
catch (std::exception & ex) {
11957
SWIG_exception(SWIG_RuntimeError,ex.what());
11958
}
11959
}
11960
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
11961
return resultobj;
11962
fail:
11963
return NULL;
11964
}
11965
11966
11967
SWIGINTERN PyObject *_wrap_LinearModelTest_LMAdjustedRSquared__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11968
PyObject *resultobj = 0;
11969
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
11970
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
11971
OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel *arg3 = 0 ;
11972
void *argp1 = 0 ;
11973
int res1 = 0 ;
11974
void *argp2 = 0 ;
11975
int res2 = 0 ;
11976
void *argp3 = 0 ;
11977
int res3 = 0 ;
11978
PyObject * obj0 = 0 ;
11979
PyObject * obj1 = 0 ;
11980
PyObject * obj2 = 0 ;
11981
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
11982
11983
if (!PyArg_ParseTuple(args,(char *)"OOO:LinearModelTest_LMAdjustedRSquared",&obj0,&obj1,&obj2)) SWIG_fail;
11984
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11985
if (!SWIG_IsOK(res1)) {
11986
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
11987
}
11988
if (!argp1) {
11989
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
11990
}
11991
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
11992
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
11993
if (!SWIG_IsOK(res2)) {
11994
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
11995
}
11996
if (!argp2) {
11997
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
11998
}
11999
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
12000
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0 | 0);
12001
if (!SWIG_IsOK(res3)) {
12002
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
12003
}
12004
if (!argp3) {
12005
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
12006
}
12007
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel * >(argp3);
12008
{
12009
try {
12010
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMAdjustedRSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Stat::LinearModel const &)*arg3);
12011
}
12012
catch (OT::Base::Common::InvalidArgumentException & ex) {
12013
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
12014
}
12015
catch (OT::Base::Common::OutOfBoundException & ex) {
12016
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
12017
}
12018
catch (OT::Base::Common::Exception & ex) {
12019
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
12020
}
12021
catch (std::out_of_range & ex) {
12022
SWIG_exception(SWIG_IndexError,ex.what());
12023
}
12024
catch (std::exception & ex) {
12025
SWIG_exception(SWIG_RuntimeError,ex.what());
12026
}
12027
}
12028
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
12029
return resultobj;
12030
fail:
12031
return NULL;
12032
}
12033
12034
12035
SWIGINTERN PyObject *_wrap_LinearModelTest_LMAdjustedRSquared__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12036
PyObject *resultobj = 0;
12037
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
12038
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
12039
OpenTURNS::NumericalScalar arg3 ;
12040
void *argp1 = 0 ;
12041
int res1 = 0 ;
12042
void *argp2 = 0 ;
12043
int res2 = 0 ;
12044
double val3 ;
12045
int ecode3 = 0 ;
12046
PyObject * obj0 = 0 ;
12047
PyObject * obj1 = 0 ;
12048
PyObject * obj2 = 0 ;
12049
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
12050
12051
if (!PyArg_ParseTuple(args,(char *)"OOO:LinearModelTest_LMAdjustedRSquared",&obj0,&obj1,&obj2)) SWIG_fail;
12052
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12053
if (!SWIG_IsOK(res1)) {
12054
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12055
}
12056
if (!argp1) {
12057
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12058
}
12059
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
12060
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12061
if (!SWIG_IsOK(res2)) {
12062
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12063
}
12064
if (!argp2) {
12065
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12066
}
12067
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
12068
ecode3 = SWIG_AsVal_double(obj2, &val3);
12069
if (!SWIG_IsOK(ecode3)) {
12070
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
12071
}
12072
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
12073
{
12074
try {
12075
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMAdjustedRSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,arg3);
12076
}
12077
catch (OT::Base::Common::InvalidArgumentException & ex) {
12078
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
12079
}
12080
catch (OT::Base::Common::OutOfBoundException & ex) {
12081
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
12082
}
12083
catch (OT::Base::Common::Exception & ex) {
12084
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
12085
}
12086
catch (std::out_of_range & ex) {
12087
SWIG_exception(SWIG_IndexError,ex.what());
12088
}
12089
catch (std::exception & ex) {
12090
SWIG_exception(SWIG_RuntimeError,ex.what());
12091
}
12092
}
12093
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
12094
return resultobj;
12095
fail:
12096
return NULL;
12097
}
12098
12099
12100
SWIGINTERN PyObject *_wrap_LinearModelTest_LMAdjustedRSquared__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12101
PyObject *resultobj = 0;
12102
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
12103
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
12104
void *argp1 = 0 ;
12105
int res1 = 0 ;
12106
void *argp2 = 0 ;
12107
int res2 = 0 ;
12108
PyObject * obj0 = 0 ;
12109
PyObject * obj1 = 0 ;
12110
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
12111
12112
if (!PyArg_ParseTuple(args,(char *)"OO:LinearModelTest_LMAdjustedRSquared",&obj0,&obj1)) SWIG_fail;
12113
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12114
if (!SWIG_IsOK(res1)) {
12115
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12116
}
12117
if (!argp1) {
12118
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12119
}
12120
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
12121
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12122
if (!SWIG_IsOK(res2)) {
12123
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12124
}
12125
if (!argp2) {
12126
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMAdjustedRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12127
}
12128
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
12129
{
12130
try {
12131
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMAdjustedRSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2);
12132
}
12133
catch (OT::Base::Common::InvalidArgumentException & ex) {
12134
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
12135
}
12136
catch (OT::Base::Common::OutOfBoundException & ex) {
12137
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
12138
}
12139
catch (OT::Base::Common::Exception & ex) {
12140
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
12141
}
12142
catch (std::out_of_range & ex) {
12143
SWIG_exception(SWIG_IndexError,ex.what());
12144
}
12145
catch (std::exception & ex) {
12146
SWIG_exception(SWIG_RuntimeError,ex.what());
12147
}
12148
}
12149
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
12150
return resultobj;
12151
fail:
12152
return NULL;
12153
}
12154
12155
12156
SWIGINTERN PyObject *_wrap_LinearModelTest_LMAdjustedRSquared(PyObject *self, PyObject *args) {
12157
int argc;
12158
PyObject *argv[5];
12159
int ii;
12160
12161
if (!PyTuple_Check(args)) SWIG_fail;
12162
argc = (int)PyObject_Length(args);
12163
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
12164
argv[ii] = PyTuple_GET_ITEM(args,ii);
12165
}
12166
if (argc == 2) {
12167
int _v;
12168
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12169
_v = SWIG_CheckState(res);
12170
if (_v) {
12171
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12172
_v = SWIG_CheckState(res);
12173
if (_v) {
12174
return _wrap_LinearModelTest_LMAdjustedRSquared__SWIG_3(self, args);
12175
}
12176
}
12177
}
12178
if (argc == 3) {
12179
int _v;
12180
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12181
_v = SWIG_CheckState(res);
12182
if (_v) {
12183
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12184
_v = SWIG_CheckState(res);
12185
if (_v) {
12186
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0);
12187
_v = SWIG_CheckState(res);
12188
if (_v) {
12189
return _wrap_LinearModelTest_LMAdjustedRSquared__SWIG_1(self, args);
12190
}
12191
}
12192
}
12193
}
12194
if (argc == 3) {
12195
int _v;
12196
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12197
_v = SWIG_CheckState(res);
12198
if (_v) {
12199
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12200
_v = SWIG_CheckState(res);
12201
if (_v) {
12202
{
12203
int res = SWIG_AsVal_double(argv[2], NULL);
12204
_v = SWIG_CheckState(res);
12205
}
12206
if (_v) {
12207
return _wrap_LinearModelTest_LMAdjustedRSquared__SWIG_2(self, args);
12208
}
12209
}
12210
}
12211
}
12212
if (argc == 4) {
12213
int _v;
12214
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12215
_v = SWIG_CheckState(res);
12216
if (_v) {
12217
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12218
_v = SWIG_CheckState(res);
12219
if (_v) {
12220
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0);
12221
_v = SWIG_CheckState(res);
12222
if (_v) {
12223
{
12224
int res = SWIG_AsVal_double(argv[3], NULL);
12225
_v = SWIG_CheckState(res);
12226
}
12227
if (_v) {
12228
return _wrap_LinearModelTest_LMAdjustedRSquared__SWIG_0(self, args);
12229
}
12230
}
12231
}
12232
}
12233
}
12234
12235
fail:
12236
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'LinearModelTest_LMAdjustedRSquared'.\n"
12237
" Possible C/C++ prototypes are:\n"
12238
" LMAdjustedRSquared(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &,OpenTURNS::NumericalScalar const)\n"
12239
" LMAdjustedRSquared(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &)\n"
12240
" LMAdjustedRSquared(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::NumericalScalar const)\n"
12241
" OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMAdjustedRSquared(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &)\n");
12242
return NULL;
12243
}
12244
12245
12246
SWIGINTERN PyObject *_wrap_LinearModelTest_LMFisher__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12247
PyObject *resultobj = 0;
12248
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
12249
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
12250
OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel *arg3 = 0 ;
12251
OpenTURNS::NumericalScalar arg4 ;
12252
void *argp1 = 0 ;
12253
int res1 = 0 ;
12254
void *argp2 = 0 ;
12255
int res2 = 0 ;
12256
void *argp3 = 0 ;
12257
int res3 = 0 ;
12258
double val4 ;
12259
int ecode4 = 0 ;
12260
PyObject * obj0 = 0 ;
12261
PyObject * obj1 = 0 ;
12262
PyObject * obj2 = 0 ;
12263
PyObject * obj3 = 0 ;
12264
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
12265
12266
if (!PyArg_ParseTuple(args,(char *)"OOOO:LinearModelTest_LMFisher",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12267
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12268
if (!SWIG_IsOK(res1)) {
12269
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMFisher" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12270
}
12271
if (!argp1) {
12272
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMFisher" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12273
}
12274
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
12275
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12276
if (!SWIG_IsOK(res2)) {
12277
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMFisher" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12278
}
12279
if (!argp2) {
12280
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMFisher" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12281
}
12282
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
12283
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0 | 0);
12284
if (!SWIG_IsOK(res3)) {
12285
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinearModelTest_LMFisher" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
12286
}
12287
if (!argp3) {
12288
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMFisher" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
12289
}
12290
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel * >(argp3);
12291
ecode4 = SWIG_AsVal_double(obj3, &val4);
12292
if (!SWIG_IsOK(ecode4)) {
12293
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LinearModelTest_LMFisher" "', argument " "4"" of type '" "OpenTURNS::NumericalScalar""'");
12294
}
12295
arg4 = static_cast< OpenTURNS::NumericalScalar >(val4);
12296
{
12297
try {
12298
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMFisher((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Stat::LinearModel const &)*arg3,arg4);
12299
}
12300
catch (OT::Base::Common::InvalidArgumentException & ex) {
12301
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
12302
}
12303
catch (OT::Base::Common::OutOfBoundException & ex) {
12304
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
12305
}
12306
catch (OT::Base::Common::Exception & ex) {
12307
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
12308
}
12309
catch (std::out_of_range & ex) {
12310
SWIG_exception(SWIG_IndexError,ex.what());
12311
}
12312
catch (std::exception & ex) {
12313
SWIG_exception(SWIG_RuntimeError,ex.what());
12314
}
12315
}
12316
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
12317
return resultobj;
12318
fail:
12319
return NULL;
12320
}
12321
12322
12323
SWIGINTERN PyObject *_wrap_LinearModelTest_LMFisher__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12324
PyObject *resultobj = 0;
12325
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
12326
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
12327
OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel *arg3 = 0 ;
12328
void *argp1 = 0 ;
12329
int res1 = 0 ;
12330
void *argp2 = 0 ;
12331
int res2 = 0 ;
12332
void *argp3 = 0 ;
12333
int res3 = 0 ;
12334
PyObject * obj0 = 0 ;
12335
PyObject * obj1 = 0 ;
12336
PyObject * obj2 = 0 ;
12337
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
12338
12339
if (!PyArg_ParseTuple(args,(char *)"OOO:LinearModelTest_LMFisher",&obj0,&obj1,&obj2)) SWIG_fail;
12340
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12341
if (!SWIG_IsOK(res1)) {
12342
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMFisher" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12343
}
12344
if (!argp1) {
12345
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMFisher" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12346
}
12347
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
12348
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12349
if (!SWIG_IsOK(res2)) {
12350
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMFisher" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12351
}
12352
if (!argp2) {
12353
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMFisher" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12354
}
12355
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
12356
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0 | 0);
12357
if (!SWIG_IsOK(res3)) {
12358
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinearModelTest_LMFisher" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
12359
}
12360
if (!argp3) {
12361
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMFisher" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
12362
}
12363
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel * >(argp3);
12364
{
12365
try {
12366
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMFisher((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Stat::LinearModel const &)*arg3);
12367
}
12368
catch (OT::Base::Common::InvalidArgumentException & ex) {
12369
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
12370
}
12371
catch (OT::Base::Common::OutOfBoundException & ex) {
12372
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
12373
}
12374
catch (OT::Base::Common::Exception & ex) {
12375
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
12376
}
12377
catch (std::out_of_range & ex) {
12378
SWIG_exception(SWIG_IndexError,ex.what());
12379
}
12380
catch (std::exception & ex) {
12381
SWIG_exception(SWIG_RuntimeError,ex.what());
12382
}
12383
}
12384
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
12385
return resultobj;
12386
fail:
12387
return NULL;
12388
}
12389
12390
12391
SWIGINTERN PyObject *_wrap_LinearModelTest_LMFisher__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12392
PyObject *resultobj = 0;
12393
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
12394
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
12395
OpenTURNS::NumericalScalar arg3 ;
12396
void *argp1 = 0 ;
12397
int res1 = 0 ;
12398
void *argp2 = 0 ;
12399
int res2 = 0 ;
12400
double val3 ;
12401
int ecode3 = 0 ;
12402
PyObject * obj0 = 0 ;
12403
PyObject * obj1 = 0 ;
12404
PyObject * obj2 = 0 ;
12405
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
12406
12407
if (!PyArg_ParseTuple(args,(char *)"OOO:LinearModelTest_LMFisher",&obj0,&obj1,&obj2)) SWIG_fail;
12408
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12409
if (!SWIG_IsOK(res1)) {
12410
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMFisher" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12411
}
12412
if (!argp1) {
12413
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMFisher" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12414
}
12415
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
12416
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12417
if (!SWIG_IsOK(res2)) {
12418
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMFisher" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12419
}
12420
if (!argp2) {
12421
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMFisher" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12422
}
12423
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
12424
ecode3 = SWIG_AsVal_double(obj2, &val3);
12425
if (!SWIG_IsOK(ecode3)) {
12426
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinearModelTest_LMFisher" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
12427
}
12428
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
12429
{
12430
try {
12431
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMFisher((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,arg3);
12432
}
12433
catch (OT::Base::Common::InvalidArgumentException & ex) {
12434
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
12435
}
12436
catch (OT::Base::Common::OutOfBoundException & ex) {
12437
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
12438
}
12439
catch (OT::Base::Common::Exception & ex) {
12440
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
12441
}
12442
catch (std::out_of_range & ex) {
12443
SWIG_exception(SWIG_IndexError,ex.what());
12444
}
12445
catch (std::exception & ex) {
12446
SWIG_exception(SWIG_RuntimeError,ex.what());
12447
}
12448
}
12449
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
12450
return resultobj;
12451
fail:
12452
return NULL;
12453
}
12454
12455
12456
SWIGINTERN PyObject *_wrap_LinearModelTest_LMFisher__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12457
PyObject *resultobj = 0;
12458
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
12459
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
12460
void *argp1 = 0 ;
12461
int res1 = 0 ;
12462
void *argp2 = 0 ;
12463
int res2 = 0 ;
12464
PyObject * obj0 = 0 ;
12465
PyObject * obj1 = 0 ;
12466
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
12467
12468
if (!PyArg_ParseTuple(args,(char *)"OO:LinearModelTest_LMFisher",&obj0,&obj1)) SWIG_fail;
12469
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12470
if (!SWIG_IsOK(res1)) {
12471
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMFisher" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12472
}
12473
if (!argp1) {
12474
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMFisher" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12475
}
12476
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
12477
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12478
if (!SWIG_IsOK(res2)) {
12479
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMFisher" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12480
}
12481
if (!argp2) {
12482
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMFisher" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12483
}
12484
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
12485
{
12486
try {
12487
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMFisher((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2);
12488
}
12489
catch (OT::Base::Common::InvalidArgumentException & ex) {
12490
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
12491
}
12492
catch (OT::Base::Common::OutOfBoundException & ex) {
12493
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
12494
}
12495
catch (OT::Base::Common::Exception & ex) {
12496
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
12497
}
12498
catch (std::out_of_range & ex) {
12499
SWIG_exception(SWIG_IndexError,ex.what());
12500
}
12501
catch (std::exception & ex) {
12502
SWIG_exception(SWIG_RuntimeError,ex.what());
12503
}
12504
}
12505
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
12506
return resultobj;
12507
fail:
12508
return NULL;
12509
}
12510
12511
12512
SWIGINTERN PyObject *_wrap_LinearModelTest_LMFisher(PyObject *self, PyObject *args) {
12513
int argc;
12514
PyObject *argv[5];
12515
int ii;
12516
12517
if (!PyTuple_Check(args)) SWIG_fail;
12518
argc = (int)PyObject_Length(args);
12519
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
12520
argv[ii] = PyTuple_GET_ITEM(args,ii);
12521
}
12522
if (argc == 2) {
12523
int _v;
12524
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12525
_v = SWIG_CheckState(res);
12526
if (_v) {
12527
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12528
_v = SWIG_CheckState(res);
12529
if (_v) {
12530
return _wrap_LinearModelTest_LMFisher__SWIG_3(self, args);
12531
}
12532
}
12533
}
12534
if (argc == 3) {
12535
int _v;
12536
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12537
_v = SWIG_CheckState(res);
12538
if (_v) {
12539
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12540
_v = SWIG_CheckState(res);
12541
if (_v) {
12542
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0);
12543
_v = SWIG_CheckState(res);
12544
if (_v) {
12545
return _wrap_LinearModelTest_LMFisher__SWIG_1(self, args);
12546
}
12547
}
12548
}
12549
}
12550
if (argc == 3) {
12551
int _v;
12552
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12553
_v = SWIG_CheckState(res);
12554
if (_v) {
12555
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12556
_v = SWIG_CheckState(res);
12557
if (_v) {
12558
{
12559
int res = SWIG_AsVal_double(argv[2], NULL);
12560
_v = SWIG_CheckState(res);
12561
}
12562
if (_v) {
12563
return _wrap_LinearModelTest_LMFisher__SWIG_2(self, args);
12564
}
12565
}
12566
}
12567
}
12568
if (argc == 4) {
12569
int _v;
12570
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12571
_v = SWIG_CheckState(res);
12572
if (_v) {
12573
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12574
_v = SWIG_CheckState(res);
12575
if (_v) {
12576
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0);
12577
_v = SWIG_CheckState(res);
12578
if (_v) {
12579
{
12580
int res = SWIG_AsVal_double(argv[3], NULL);
12581
_v = SWIG_CheckState(res);
12582
}
12583
if (_v) {
12584
return _wrap_LinearModelTest_LMFisher__SWIG_0(self, args);
12585
}
12586
}
12587
}
12588
}
12589
}
12590
12591
fail:
12592
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'LinearModelTest_LMFisher'.\n"
12593
" Possible C/C++ prototypes are:\n"
12594
" LMFisher(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &,OpenTURNS::NumericalScalar const)\n"
12595
" LMFisher(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &)\n"
12596
" LMFisher(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::NumericalScalar const)\n"
12597
" OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMFisher(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &)\n");
12598
return NULL;
12599
}
12600
12601
12602
SWIGINTERN PyObject *_wrap_LinearModelTest_LMResidualMean__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12603
PyObject *resultobj = 0;
12604
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
12605
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
12606
OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel *arg3 = 0 ;
12607
OpenTURNS::NumericalScalar arg4 ;
12608
void *argp1 = 0 ;
12609
int res1 = 0 ;
12610
void *argp2 = 0 ;
12611
int res2 = 0 ;
12612
void *argp3 = 0 ;
12613
int res3 = 0 ;
12614
double val4 ;
12615
int ecode4 = 0 ;
12616
PyObject * obj0 = 0 ;
12617
PyObject * obj1 = 0 ;
12618
PyObject * obj2 = 0 ;
12619
PyObject * obj3 = 0 ;
12620
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
12621
12622
if (!PyArg_ParseTuple(args,(char *)"OOOO:LinearModelTest_LMResidualMean",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12623
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12624
if (!SWIG_IsOK(res1)) {
12625
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMResidualMean" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12626
}
12627
if (!argp1) {
12628
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMResidualMean" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12629
}
12630
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
12631
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12632
if (!SWIG_IsOK(res2)) {
12633
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMResidualMean" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12634
}
12635
if (!argp2) {
12636
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMResidualMean" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12637
}
12638
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
12639
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0 | 0);
12640
if (!SWIG_IsOK(res3)) {
12641
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinearModelTest_LMResidualMean" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
12642
}
12643
if (!argp3) {
12644
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMResidualMean" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
12645
}
12646
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel * >(argp3);
12647
ecode4 = SWIG_AsVal_double(obj3, &val4);
12648
if (!SWIG_IsOK(ecode4)) {
12649
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LinearModelTest_LMResidualMean" "', argument " "4"" of type '" "OpenTURNS::NumericalScalar""'");
12650
}
12651
arg4 = static_cast< OpenTURNS::NumericalScalar >(val4);
12652
{
12653
try {
12654
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMResidualMean((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Stat::LinearModel const &)*arg3,arg4);
12655
}
12656
catch (OT::Base::Common::InvalidArgumentException & ex) {
12657
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
12658
}
12659
catch (OT::Base::Common::OutOfBoundException & ex) {
12660
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
12661
}
12662
catch (OT::Base::Common::Exception & ex) {
12663
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
12664
}
12665
catch (std::out_of_range & ex) {
12666
SWIG_exception(SWIG_IndexError,ex.what());
12667
}
12668
catch (std::exception & ex) {
12669
SWIG_exception(SWIG_RuntimeError,ex.what());
12670
}
12671
}
12672
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
12673
return resultobj;
12674
fail:
12675
return NULL;
12676
}
12677
12678
12679
SWIGINTERN PyObject *_wrap_LinearModelTest_LMResidualMean__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12680
PyObject *resultobj = 0;
12681
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
12682
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
12683
OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel *arg3 = 0 ;
12684
void *argp1 = 0 ;
12685
int res1 = 0 ;
12686
void *argp2 = 0 ;
12687
int res2 = 0 ;
12688
void *argp3 = 0 ;
12689
int res3 = 0 ;
12690
PyObject * obj0 = 0 ;
12691
PyObject * obj1 = 0 ;
12692
PyObject * obj2 = 0 ;
12693
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
12694
12695
if (!PyArg_ParseTuple(args,(char *)"OOO:LinearModelTest_LMResidualMean",&obj0,&obj1,&obj2)) SWIG_fail;
12696
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12697
if (!SWIG_IsOK(res1)) {
12698
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMResidualMean" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12699
}
12700
if (!argp1) {
12701
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMResidualMean" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12702
}
12703
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
12704
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12705
if (!SWIG_IsOK(res2)) {
12706
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMResidualMean" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12707
}
12708
if (!argp2) {
12709
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMResidualMean" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12710
}
12711
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
12712
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0 | 0);
12713
if (!SWIG_IsOK(res3)) {
12714
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinearModelTest_LMResidualMean" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
12715
}
12716
if (!argp3) {
12717
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMResidualMean" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
12718
}
12719
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel * >(argp3);
12720
{
12721
try {
12722
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMResidualMean((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Stat::LinearModel const &)*arg3);
12723
}
12724
catch (OT::Base::Common::InvalidArgumentException & ex) {
12725
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
12726
}
12727
catch (OT::Base::Common::OutOfBoundException & ex) {
12728
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
12729
}
12730
catch (OT::Base::Common::Exception & ex) {
12731
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
12732
}
12733
catch (std::out_of_range & ex) {
12734
SWIG_exception(SWIG_IndexError,ex.what());
12735
}
12736
catch (std::exception & ex) {
12737
SWIG_exception(SWIG_RuntimeError,ex.what());
12738
}
12739
}
12740
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
12741
return resultobj;
12742
fail:
12743
return NULL;
12744
}
12745
12746
12747
SWIGINTERN PyObject *_wrap_LinearModelTest_LMResidualMean__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12748
PyObject *resultobj = 0;
12749
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
12750
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
12751
OpenTURNS::NumericalScalar arg3 ;
12752
void *argp1 = 0 ;
12753
int res1 = 0 ;
12754
void *argp2 = 0 ;
12755
int res2 = 0 ;
12756
double val3 ;
12757
int ecode3 = 0 ;
12758
PyObject * obj0 = 0 ;
12759
PyObject * obj1 = 0 ;
12760
PyObject * obj2 = 0 ;
12761
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
12762
12763
if (!PyArg_ParseTuple(args,(char *)"OOO:LinearModelTest_LMResidualMean",&obj0,&obj1,&obj2)) SWIG_fail;
12764
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12765
if (!SWIG_IsOK(res1)) {
12766
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMResidualMean" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12767
}
12768
if (!argp1) {
12769
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMResidualMean" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12770
}
12771
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
12772
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12773
if (!SWIG_IsOK(res2)) {
12774
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMResidualMean" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12775
}
12776
if (!argp2) {
12777
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMResidualMean" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12778
}
12779
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
12780
ecode3 = SWIG_AsVal_double(obj2, &val3);
12781
if (!SWIG_IsOK(ecode3)) {
12782
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinearModelTest_LMResidualMean" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
12783
}
12784
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
12785
{
12786
try {
12787
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMResidualMean((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,arg3);
12788
}
12789
catch (OT::Base::Common::InvalidArgumentException & ex) {
12790
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
12791
}
12792
catch (OT::Base::Common::OutOfBoundException & ex) {
12793
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
12794
}
12795
catch (OT::Base::Common::Exception & ex) {
12796
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
12797
}
12798
catch (std::out_of_range & ex) {
12799
SWIG_exception(SWIG_IndexError,ex.what());
12800
}
12801
catch (std::exception & ex) {
12802
SWIG_exception(SWIG_RuntimeError,ex.what());
12803
}
12804
}
12805
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
12806
return resultobj;
12807
fail:
12808
return NULL;
12809
}
12810
12811
12812
SWIGINTERN PyObject *_wrap_LinearModelTest_LMResidualMean__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12813
PyObject *resultobj = 0;
12814
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
12815
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
12816
void *argp1 = 0 ;
12817
int res1 = 0 ;
12818
void *argp2 = 0 ;
12819
int res2 = 0 ;
12820
PyObject * obj0 = 0 ;
12821
PyObject * obj1 = 0 ;
12822
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
12823
12824
if (!PyArg_ParseTuple(args,(char *)"OO:LinearModelTest_LMResidualMean",&obj0,&obj1)) SWIG_fail;
12825
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12826
if (!SWIG_IsOK(res1)) {
12827
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMResidualMean" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12828
}
12829
if (!argp1) {
12830
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMResidualMean" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12831
}
12832
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
12833
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12834
if (!SWIG_IsOK(res2)) {
12835
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMResidualMean" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12836
}
12837
if (!argp2) {
12838
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMResidualMean" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12839
}
12840
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
12841
{
12842
try {
12843
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMResidualMean((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2);
12844
}
12845
catch (OT::Base::Common::InvalidArgumentException & ex) {
12846
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
12847
}
12848
catch (OT::Base::Common::OutOfBoundException & ex) {
12849
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
12850
}
12851
catch (OT::Base::Common::Exception & ex) {
12852
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
12853
}
12854
catch (std::out_of_range & ex) {
12855
SWIG_exception(SWIG_IndexError,ex.what());
12856
}
12857
catch (std::exception & ex) {
12858
SWIG_exception(SWIG_RuntimeError,ex.what());
12859
}
12860
}
12861
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
12862
return resultobj;
12863
fail:
12864
return NULL;
12865
}
12866
12867
12868
SWIGINTERN PyObject *_wrap_LinearModelTest_LMResidualMean(PyObject *self, PyObject *args) {
12869
int argc;
12870
PyObject *argv[5];
12871
int ii;
12872
12873
if (!PyTuple_Check(args)) SWIG_fail;
12874
argc = (int)PyObject_Length(args);
12875
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
12876
argv[ii] = PyTuple_GET_ITEM(args,ii);
12877
}
12878
if (argc == 2) {
12879
int _v;
12880
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12881
_v = SWIG_CheckState(res);
12882
if (_v) {
12883
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12884
_v = SWIG_CheckState(res);
12885
if (_v) {
12886
return _wrap_LinearModelTest_LMResidualMean__SWIG_3(self, args);
12887
}
12888
}
12889
}
12890
if (argc == 3) {
12891
int _v;
12892
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12893
_v = SWIG_CheckState(res);
12894
if (_v) {
12895
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12896
_v = SWIG_CheckState(res);
12897
if (_v) {
12898
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0);
12899
_v = SWIG_CheckState(res);
12900
if (_v) {
12901
return _wrap_LinearModelTest_LMResidualMean__SWIG_1(self, args);
12902
}
12903
}
12904
}
12905
}
12906
if (argc == 3) {
12907
int _v;
12908
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12909
_v = SWIG_CheckState(res);
12910
if (_v) {
12911
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12912
_v = SWIG_CheckState(res);
12913
if (_v) {
12914
{
12915
int res = SWIG_AsVal_double(argv[2], NULL);
12916
_v = SWIG_CheckState(res);
12917
}
12918
if (_v) {
12919
return _wrap_LinearModelTest_LMResidualMean__SWIG_2(self, args);
12920
}
12921
}
12922
}
12923
}
12924
if (argc == 4) {
12925
int _v;
12926
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12927
_v = SWIG_CheckState(res);
12928
if (_v) {
12929
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
12930
_v = SWIG_CheckState(res);
12931
if (_v) {
12932
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0);
12933
_v = SWIG_CheckState(res);
12934
if (_v) {
12935
{
12936
int res = SWIG_AsVal_double(argv[3], NULL);
12937
_v = SWIG_CheckState(res);
12938
}
12939
if (_v) {
12940
return _wrap_LinearModelTest_LMResidualMean__SWIG_0(self, args);
12941
}
12942
}
12943
}
12944
}
12945
}
12946
12947
fail:
12948
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'LinearModelTest_LMResidualMean'.\n"
12949
" Possible C/C++ prototypes are:\n"
12950
" LMResidualMean(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &,OpenTURNS::NumericalScalar const)\n"
12951
" LMResidualMean(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &)\n"
12952
" LMResidualMean(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::NumericalScalar const)\n"
12953
" OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMResidualMean(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &)\n");
12954
return NULL;
12955
}
12956
12957
12958
SWIGINTERN PyObject *_wrap_LinearModelTest_LMRSquared__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12959
PyObject *resultobj = 0;
12960
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
12961
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
12962
OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel *arg3 = 0 ;
12963
OpenTURNS::NumericalScalar arg4 ;
12964
void *argp1 = 0 ;
12965
int res1 = 0 ;
12966
void *argp2 = 0 ;
12967
int res2 = 0 ;
12968
void *argp3 = 0 ;
12969
int res3 = 0 ;
12970
double val4 ;
12971
int ecode4 = 0 ;
12972
PyObject * obj0 = 0 ;
12973
PyObject * obj1 = 0 ;
12974
PyObject * obj2 = 0 ;
12975
PyObject * obj3 = 0 ;
12976
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
12977
12978
if (!PyArg_ParseTuple(args,(char *)"OOOO:LinearModelTest_LMRSquared",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12979
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12980
if (!SWIG_IsOK(res1)) {
12981
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12982
}
12983
if (!argp1) {
12984
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12985
}
12986
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
12987
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
12988
if (!SWIG_IsOK(res2)) {
12989
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12990
}
12991
if (!argp2) {
12992
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
12993
}
12994
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
12995
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0 | 0);
12996
if (!SWIG_IsOK(res3)) {
12997
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinearModelTest_LMRSquared" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
12998
}
12999
if (!argp3) {
13000
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMRSquared" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
13001
}
13002
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel * >(argp3);
13003
ecode4 = SWIG_AsVal_double(obj3, &val4);
13004
if (!SWIG_IsOK(ecode4)) {
13005
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LinearModelTest_LMRSquared" "', argument " "4"" of type '" "OpenTURNS::NumericalScalar""'");
13006
}
13007
arg4 = static_cast< OpenTURNS::NumericalScalar >(val4);
13008
{
13009
try {
13010
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMRSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Stat::LinearModel const &)*arg3,arg4);
13011
}
13012
catch (OT::Base::Common::InvalidArgumentException & ex) {
13013
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
13014
}
13015
catch (OT::Base::Common::OutOfBoundException & ex) {
13016
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
13017
}
13018
catch (OT::Base::Common::Exception & ex) {
13019
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
13020
}
13021
catch (std::out_of_range & ex) {
13022
SWIG_exception(SWIG_IndexError,ex.what());
13023
}
13024
catch (std::exception & ex) {
13025
SWIG_exception(SWIG_RuntimeError,ex.what());
13026
}
13027
}
13028
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
13029
return resultobj;
13030
fail:
13031
return NULL;
13032
}
13033
13034
13035
SWIGINTERN PyObject *_wrap_LinearModelTest_LMRSquared__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13036
PyObject *resultobj = 0;
13037
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
13038
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
13039
OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel *arg3 = 0 ;
13040
void *argp1 = 0 ;
13041
int res1 = 0 ;
13042
void *argp2 = 0 ;
13043
int res2 = 0 ;
13044
void *argp3 = 0 ;
13045
int res3 = 0 ;
13046
PyObject * obj0 = 0 ;
13047
PyObject * obj1 = 0 ;
13048
PyObject * obj2 = 0 ;
13049
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
13050
13051
if (!PyArg_ParseTuple(args,(char *)"OOO:LinearModelTest_LMRSquared",&obj0,&obj1,&obj2)) SWIG_fail;
13052
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
13053
if (!SWIG_IsOK(res1)) {
13054
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
13055
}
13056
if (!argp1) {
13057
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
13058
}
13059
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
13060
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
13061
if (!SWIG_IsOK(res2)) {
13062
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
13063
}
13064
if (!argp2) {
13065
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
13066
}
13067
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
13068
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0 | 0);
13069
if (!SWIG_IsOK(res3)) {
13070
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinearModelTest_LMRSquared" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
13071
}
13072
if (!argp3) {
13073
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMRSquared" "', argument " "3"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &""'");
13074
}
13075
arg3 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel * >(argp3);
13076
{
13077
try {
13078
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMRSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,(OpenTURNS::Base::Stat::LinearModel const &)*arg3);
13079
}
13080
catch (OT::Base::Common::InvalidArgumentException & ex) {
13081
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
13082
}
13083
catch (OT::Base::Common::OutOfBoundException & ex) {
13084
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
13085
}
13086
catch (OT::Base::Common::Exception & ex) {
13087
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
13088
}
13089
catch (std::out_of_range & ex) {
13090
SWIG_exception(SWIG_IndexError,ex.what());
13091
}
13092
catch (std::exception & ex) {
13093
SWIG_exception(SWIG_RuntimeError,ex.what());
13094
}
13095
}
13096
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
13097
return resultobj;
13098
fail:
13099
return NULL;
13100
}
13101
13102
13103
SWIGINTERN PyObject *_wrap_LinearModelTest_LMRSquared__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13104
PyObject *resultobj = 0;
13105
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
13106
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
13107
OpenTURNS::NumericalScalar arg3 ;
13108
void *argp1 = 0 ;
13109
int res1 = 0 ;
13110
void *argp2 = 0 ;
13111
int res2 = 0 ;
13112
double val3 ;
13113
int ecode3 = 0 ;
13114
PyObject * obj0 = 0 ;
13115
PyObject * obj1 = 0 ;
13116
PyObject * obj2 = 0 ;
13117
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
13118
13119
if (!PyArg_ParseTuple(args,(char *)"OOO:LinearModelTest_LMRSquared",&obj0,&obj1,&obj2)) SWIG_fail;
13120
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
13121
if (!SWIG_IsOK(res1)) {
13122
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
13123
}
13124
if (!argp1) {
13125
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
13126
}
13127
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
13128
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
13129
if (!SWIG_IsOK(res2)) {
13130
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
13131
}
13132
if (!argp2) {
13133
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
13134
}
13135
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
13136
ecode3 = SWIG_AsVal_double(obj2, &val3);
13137
if (!SWIG_IsOK(ecode3)) {
13138
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinearModelTest_LMRSquared" "', argument " "3"" of type '" "OpenTURNS::NumericalScalar""'");
13139
}
13140
arg3 = static_cast< OpenTURNS::NumericalScalar >(val3);
13141
{
13142
try {
13143
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMRSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2,arg3);
13144
}
13145
catch (OT::Base::Common::InvalidArgumentException & ex) {
13146
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
13147
}
13148
catch (OT::Base::Common::OutOfBoundException & ex) {
13149
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
13150
}
13151
catch (OT::Base::Common::Exception & ex) {
13152
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
13153
}
13154
catch (std::out_of_range & ex) {
13155
SWIG_exception(SWIG_IndexError,ex.what());
13156
}
13157
catch (std::exception & ex) {
13158
SWIG_exception(SWIG_RuntimeError,ex.what());
13159
}
13160
}
13161
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
13162
return resultobj;
13163
fail:
13164
return NULL;
13165
}
13166
13167
13168
SWIGINTERN PyObject *_wrap_LinearModelTest_LMRSquared__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13169
PyObject *resultobj = 0;
13170
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg1 = 0 ;
13171
OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *arg2 = 0 ;
13172
void *argp1 = 0 ;
13173
int res1 = 0 ;
13174
void *argp2 = 0 ;
13175
int res2 = 0 ;
13176
PyObject * obj0 = 0 ;
13177
PyObject * obj1 = 0 ;
13178
OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult result;
13179
13180
if (!PyArg_ParseTuple(args,(char *)"OO:LinearModelTest_LMRSquared",&obj0,&obj1)) SWIG_fail;
13181
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
13182
if (!SWIG_IsOK(res1)) {
13183
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearModelTest_LMRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
13184
}
13185
if (!argp1) {
13186
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMRSquared" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
13187
}
13188
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp1);
13189
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
13190
if (!SWIG_IsOK(res2)) {
13191
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearModelTest_LMRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
13192
}
13193
if (!argp2) {
13194
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearModelTest_LMRSquared" "', argument " "2"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &""'");
13195
}
13196
arg2 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample * >(argp2);
13197
{
13198
try {
13199
result = OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMRSquared((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,(OpenTURNS::Base::Stat::NumericalSample const &)*arg2);
13200
}
13201
catch (OT::Base::Common::InvalidArgumentException & ex) {
13202
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
13203
}
13204
catch (OT::Base::Common::OutOfBoundException & ex) {
13205
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
13206
}
13207
catch (OT::Base::Common::Exception & ex) {
13208
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
13209
}
13210
catch (std::out_of_range & ex) {
13211
SWIG_exception(SWIG_IndexError,ex.what());
13212
}
13213
catch (std::exception & ex) {
13214
SWIG_exception(SWIG_RuntimeError,ex.what());
13215
}
13216
}
13217
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
13218
return resultobj;
13219
fail:
13220
return NULL;
13221
}
13222
13223
13224
SWIGINTERN PyObject *_wrap_LinearModelTest_LMRSquared(PyObject *self, PyObject *args) {
13225
int argc;
13226
PyObject *argv[5];
13227
int ii;
13228
13229
if (!PyTuple_Check(args)) SWIG_fail;
13230
argc = (int)PyObject_Length(args);
13231
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
13232
argv[ii] = PyTuple_GET_ITEM(args,ii);
13233
}
13234
if (argc == 2) {
13235
int _v;
13236
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
13237
_v = SWIG_CheckState(res);
13238
if (_v) {
13239
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
13240
_v = SWIG_CheckState(res);
13241
if (_v) {
13242
return _wrap_LinearModelTest_LMRSquared__SWIG_3(self, args);
13243
}
13244
}
13245
}
13246
if (argc == 3) {
13247
int _v;
13248
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
13249
_v = SWIG_CheckState(res);
13250
if (_v) {
13251
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
13252
_v = SWIG_CheckState(res);
13253
if (_v) {
13254
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0);
13255
_v = SWIG_CheckState(res);
13256
if (_v) {
13257
return _wrap_LinearModelTest_LMRSquared__SWIG_1(self, args);
13258
}
13259
}
13260
}
13261
}
13262
if (argc == 3) {
13263
int _v;
13264
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
13265
_v = SWIG_CheckState(res);
13266
if (_v) {
13267
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
13268
_v = SWIG_CheckState(res);
13269
if (_v) {
13270
{
13271
int res = SWIG_AsVal_double(argv[2], NULL);
13272
_v = SWIG_CheckState(res);
13273
}
13274
if (_v) {
13275
return _wrap_LinearModelTest_LMRSquared__SWIG_2(self, args);
13276
}
13277
}
13278
}
13279
}
13280
if (argc == 4) {
13281
int _v;
13282
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
13283
_v = SWIG_CheckState(res);
13284
if (_v) {
13285
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
13286
_v = SWIG_CheckState(res);
13287
if (_v) {
13288
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel, 0);
13289
_v = SWIG_CheckState(res);
13290
if (_v) {
13291
{
13292
int res = SWIG_AsVal_double(argv[3], NULL);
13293
_v = SWIG_CheckState(res);
13294
}
13295
if (_v) {
13296
return _wrap_LinearModelTest_LMRSquared__SWIG_0(self, args);
13297
}
13298
}
13299
}
13300
}
13301
}
13302
13303
fail:
13304
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'LinearModelTest_LMRSquared'.\n"
13305
" Possible C/C++ prototypes are:\n"
13306
" LMRSquared(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &,OpenTURNS::NumericalScalar const)\n"
13307
" LMRSquared(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel const &)\n"
13308
" LMRSquared(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::NumericalScalar const)\n"
13309
" OpenTURNS::Uncertainty::StatTest::LinearModelTest::LMRSquared(OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &,OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample const &)\n");
13310
return NULL;
13311
}
13312
13313
13314
SWIGINTERN PyObject *_wrap_new_LinearModelTest__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13315
PyObject *resultobj = 0;
13316
OpenTURNS::Uncertainty::StatTest::LinearModelTest *arg1 = 0 ;
13317
void *argp1 = 0 ;
13318
int res1 = 0 ;
13319
PyObject * obj0 = 0 ;
13320
OpenTURNS::Uncertainty::StatTest::LinearModelTest *result = 0 ;
13321
13322
if (!PyArg_ParseTuple(args,(char *)"O:new_LinearModelTest",&obj0)) SWIG_fail;
13323
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__LinearModelTest, 0 | 0);
13324
if (!SWIG_IsOK(res1)) {
13325
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearModelTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest const &""'");
13326
}
13327
if (!argp1) {
13328
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearModelTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest const &""'");
13329
}
13330
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest * >(argp1);
13331
{
13332
try {
13333
result = (OpenTURNS::Uncertainty::StatTest::LinearModelTest *)new_OpenTURNS_Uncertainty_StatTest_LinearModelTest__SWIG_1((OpenTURNS::Uncertainty::StatTest::LinearModelTest const &)*arg1);
13334
}
13335
catch (OT::Base::Common::InvalidArgumentException & ex) {
13336
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
13337
}
13338
catch (OT::Base::Common::OutOfBoundException & ex) {
13339
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
13340
}
13341
catch (OT::Base::Common::Exception & ex) {
13342
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
13343
}
13344
catch (std::out_of_range & ex) {
13345
SWIG_exception(SWIG_IndexError,ex.what());
13346
}
13347
catch (std::exception & ex) {
13348
SWIG_exception(SWIG_RuntimeError,ex.what());
13349
}
13350
}
13351
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__LinearModelTest, SWIG_POINTER_NEW | 0 );
13352
return resultobj;
13353
fail:
13354
return NULL;
13355
}
13356
13357
13358
SWIGINTERN PyObject *_wrap_new_LinearModelTest(PyObject *self, PyObject *args) {
13359
int argc;
13360
PyObject *argv[2];
13361
int ii;
13362
13363
if (!PyTuple_Check(args)) SWIG_fail;
13364
argc = (int)PyObject_Length(args);
13365
for (ii = 0; (ii < argc) && (ii < 1); ii++) {
13366
argv[ii] = PyTuple_GET_ITEM(args,ii);
13367
}
13368
if (argc == 0) {
13369
return _wrap_new_LinearModelTest__SWIG_0(self, args);
13370
}
13371
if (argc == 1) {
13372
int _v;
13373
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__LinearModelTest, 0);
13374
_v = SWIG_CheckState(res);
13375
if (_v) {
13376
return _wrap_new_LinearModelTest__SWIG_1(self, args);
13377
}
13378
}
13379
13380
fail:
13381
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LinearModelTest'.\n"
13382
" Possible C/C++ prototypes are:\n"
13383
" OpenTURNS::Uncertainty::StatTest::LinearModelTest()\n"
13384
" OpenTURNS::Uncertainty::StatTest::LinearModelTest(OpenTURNS::Uncertainty::StatTest::LinearModelTest const &)\n");
13385
return NULL;
13386
}
13387
13388
13389
SWIGINTERN PyObject *_wrap_delete_LinearModelTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13390
PyObject *resultobj = 0;
13391
OpenTURNS::Uncertainty::StatTest::LinearModelTest *arg1 = (OpenTURNS::Uncertainty::StatTest::LinearModelTest *) 0 ;
13392
void *argp1 = 0 ;
13393
int res1 = 0 ;
13394
PyObject * obj0 = 0 ;
13395
13396
if (!PyArg_ParseTuple(args,(char *)"O:delete_LinearModelTest",&obj0)) SWIG_fail;
13397
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__LinearModelTest, SWIG_POINTER_DISOWN | 0 );
13398
if (!SWIG_IsOK(res1)) {
13399
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinearModelTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::LinearModelTest *""'");
13400
}
13401
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::LinearModelTest * >(argp1);
13402
{
13403
try {
13404
delete arg1;
13405
}
13406
catch (OT::Base::Common::InvalidArgumentException & ex) {
13407
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
13408
}
13409
catch (OT::Base::Common::OutOfBoundException & ex) {
13410
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
13411
}
13412
catch (OT::Base::Common::Exception & ex) {
13413
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
13414
}
13415
catch (std::out_of_range & ex) {
13416
SWIG_exception(SWIG_IndexError,ex.what());
13417
}
13418
catch (std::exception & ex) {
13419
SWIG_exception(SWIG_RuntimeError,ex.what());
13420
}
13421
}
13422
resultobj = SWIG_Py_Void();
13423
return resultobj;
13424
fail:
13425
return NULL;
13426
}
13427
13428
13429
SWIGINTERN PyObject *LinearModelTest_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13430
PyObject *obj;
13431
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
13432
SWIG_TypeNewClientData(SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__LinearModelTest, SWIG_NewClientData(obj));
13433
return SWIG_Py_Void();
13434
}
13435
13436
SWIGINTERN PyObject *_wrap_new_NormalityTest__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13437
PyObject *resultobj = 0;
13438
OpenTURNS::Uncertainty::StatTest::NormalityTest *result = 0 ;
13439
13440
if (!PyArg_ParseTuple(args,(char *)":new_NormalityTest")) SWIG_fail;
13441
{
13442
try {
13443
result = (OpenTURNS::Uncertainty::StatTest::NormalityTest *)new OpenTURNS::Uncertainty::StatTest::NormalityTest();
13444
}
13445
catch (OT::Base::Common::InvalidArgumentException & ex) {
13446
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
13447
}
13448
catch (OT::Base::Common::OutOfBoundException & ex) {
13449
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
13450
}
13451
catch (OT::Base::Common::Exception & ex) {
13452
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
13453
}
13454
catch (std::out_of_range & ex) {
13455
SWIG_exception(SWIG_IndexError,ex.what());
13456
}
13457
catch (std::exception & ex) {
13458
SWIG_exception(SWIG_RuntimeError,ex.what());
13459
}
13460
}
13461
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__NormalityTest, SWIG_POINTER_NEW | 0 );
13462
return resultobj;
13463
fail:
13464
return NULL;
13465
}
13466
13467
13468
SWIGINTERN PyObject *_wrap_NormalityTest_AndersonDarlingNormal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13469
PyObject *resultobj = 0;
13470
OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample *arg1 = 0 ;
13471
OpenTURNS::NumericalScalar arg2 ;
13472
void *argp1 = 0 ;
13473
int res1 = 0 ;
13474
double val2 ;
13475
int ecode2 = 0 ;
13476
PyObject * obj0 = 0 ;
13477
PyObject * obj1 = 0 ;
13478
OpenTURNS::Uncertainty::StatTest::NormalityTest::TestResult result;
13479
13480
if (!PyArg_ParseTuple(args,(char *)"OO:NormalityTest_AndersonDarlingNormal",&obj0,&obj1)) SWIG_fail;
13481
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
13482
if (!SWIG_IsOK(res1)) {
13483
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalityTest_AndersonDarlingNormal" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample const &""'");
13484
}
13485
if (!argp1) {
13486
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalityTest_AndersonDarlingNormal" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample const &""'");
13487
}
13488
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample * >(argp1);
13489
ecode2 = SWIG_AsVal_double(obj1, &val2);
13490
if (!SWIG_IsOK(ecode2)) {
13491
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NormalityTest_AndersonDarlingNormal" "', argument " "2"" of type '" "OpenTURNS::NumericalScalar""'");
13492
}
13493
arg2 = static_cast< OpenTURNS::NumericalScalar >(val2);
13494
{
13495
try {
13496
result = OpenTURNS::Uncertainty::StatTest::NormalityTest::AndersonDarlingNormal((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,arg2);
13497
}
13498
catch (OT::Base::Common::InvalidArgumentException & ex) {
13499
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
13500
}
13501
catch (OT::Base::Common::OutOfBoundException & ex) {
13502
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
13503
}
13504
catch (OT::Base::Common::Exception & ex) {
13505
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
13506
}
13507
catch (std::out_of_range & ex) {
13508
SWIG_exception(SWIG_IndexError,ex.what());
13509
}
13510
catch (std::exception & ex) {
13511
SWIG_exception(SWIG_RuntimeError,ex.what());
13512
}
13513
}
13514
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::NormalityTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::NormalityTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
13515
return resultobj;
13516
fail:
13517
return NULL;
13518
}
13519
13520
13521
SWIGINTERN PyObject *_wrap_NormalityTest_AndersonDarlingNormal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13522
PyObject *resultobj = 0;
13523
OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample *arg1 = 0 ;
13524
void *argp1 = 0 ;
13525
int res1 = 0 ;
13526
PyObject * obj0 = 0 ;
13527
OpenTURNS::Uncertainty::StatTest::NormalityTest::TestResult result;
13528
13529
if (!PyArg_ParseTuple(args,(char *)"O:NormalityTest_AndersonDarlingNormal",&obj0)) SWIG_fail;
13530
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
13531
if (!SWIG_IsOK(res1)) {
13532
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalityTest_AndersonDarlingNormal" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample const &""'");
13533
}
13534
if (!argp1) {
13535
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalityTest_AndersonDarlingNormal" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample const &""'");
13536
}
13537
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample * >(argp1);
13538
{
13539
try {
13540
result = OpenTURNS::Uncertainty::StatTest::NormalityTest::AndersonDarlingNormal((OpenTURNS::Base::Stat::NumericalSample const &)*arg1);
13541
}
13542
catch (OT::Base::Common::InvalidArgumentException & ex) {
13543
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
13544
}
13545
catch (OT::Base::Common::OutOfBoundException & ex) {
13546
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
13547
}
13548
catch (OT::Base::Common::Exception & ex) {
13549
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
13550
}
13551
catch (std::out_of_range & ex) {
13552
SWIG_exception(SWIG_IndexError,ex.what());
13553
}
13554
catch (std::exception & ex) {
13555
SWIG_exception(SWIG_RuntimeError,ex.what());
13556
}
13557
}
13558
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::NormalityTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::NormalityTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
13559
return resultobj;
13560
fail:
13561
return NULL;
13562
}
13563
13564
13565
SWIGINTERN PyObject *_wrap_NormalityTest_AndersonDarlingNormal(PyObject *self, PyObject *args) {
13566
int argc;
13567
PyObject *argv[3];
13568
int ii;
13569
13570
if (!PyTuple_Check(args)) SWIG_fail;
13571
argc = (int)PyObject_Length(args);
13572
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
13573
argv[ii] = PyTuple_GET_ITEM(args,ii);
13574
}
13575
if (argc == 1) {
13576
int _v;
13577
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
13578
_v = SWIG_CheckState(res);
13579
if (_v) {
13580
return _wrap_NormalityTest_AndersonDarlingNormal__SWIG_1(self, args);
13581
}
13582
}
13583
if (argc == 2) {
13584
int _v;
13585
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
13586
_v = SWIG_CheckState(res);
13587
if (_v) {
13588
{
13589
int res = SWIG_AsVal_double(argv[1], NULL);
13590
_v = SWIG_CheckState(res);
13591
}
13592
if (_v) {
13593
return _wrap_NormalityTest_AndersonDarlingNormal__SWIG_0(self, args);
13594
}
13595
}
13596
}
13597
13598
fail:
13599
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'NormalityTest_AndersonDarlingNormal'.\n"
13600
" Possible C/C++ prototypes are:\n"
13601
" AndersonDarlingNormal(OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample const &,OpenTURNS::NumericalScalar const)\n"
13602
" OpenTURNS::Uncertainty::StatTest::NormalityTest::AndersonDarlingNormal(OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample const &)\n");
13603
return NULL;
13604
}
13605
13606
13607
SWIGINTERN PyObject *_wrap_NormalityTest_CramerVonMisesNormal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13608
PyObject *resultobj = 0;
13609
OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample *arg1 = 0 ;
13610
OpenTURNS::NumericalScalar arg2 ;
13611
void *argp1 = 0 ;
13612
int res1 = 0 ;
13613
double val2 ;
13614
int ecode2 = 0 ;
13615
PyObject * obj0 = 0 ;
13616
PyObject * obj1 = 0 ;
13617
OpenTURNS::Uncertainty::StatTest::NormalityTest::TestResult result;
13618
13619
if (!PyArg_ParseTuple(args,(char *)"OO:NormalityTest_CramerVonMisesNormal",&obj0,&obj1)) SWIG_fail;
13620
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
13621
if (!SWIG_IsOK(res1)) {
13622
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalityTest_CramerVonMisesNormal" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample const &""'");
13623
}
13624
if (!argp1) {
13625
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalityTest_CramerVonMisesNormal" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample const &""'");
13626
}
13627
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample * >(argp1);
13628
ecode2 = SWIG_AsVal_double(obj1, &val2);
13629
if (!SWIG_IsOK(ecode2)) {
13630
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NormalityTest_CramerVonMisesNormal" "', argument " "2"" of type '" "OpenTURNS::NumericalScalar""'");
13631
}
13632
arg2 = static_cast< OpenTURNS::NumericalScalar >(val2);
13633
{
13634
try {
13635
result = OpenTURNS::Uncertainty::StatTest::NormalityTest::CramerVonMisesNormal((OpenTURNS::Base::Stat::NumericalSample const &)*arg1,arg2);
13636
}
13637
catch (OT::Base::Common::InvalidArgumentException & ex) {
13638
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
13639
}
13640
catch (OT::Base::Common::OutOfBoundException & ex) {
13641
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
13642
}
13643
catch (OT::Base::Common::Exception & ex) {
13644
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
13645
}
13646
catch (std::out_of_range & ex) {
13647
SWIG_exception(SWIG_IndexError,ex.what());
13648
}
13649
catch (std::exception & ex) {
13650
SWIG_exception(SWIG_RuntimeError,ex.what());
13651
}
13652
}
13653
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::NormalityTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::NormalityTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
13654
return resultobj;
13655
fail:
13656
return NULL;
13657
}
13658
13659
13660
SWIGINTERN PyObject *_wrap_NormalityTest_CramerVonMisesNormal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13661
PyObject *resultobj = 0;
13662
OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample *arg1 = 0 ;
13663
void *argp1 = 0 ;
13664
int res1 = 0 ;
13665
PyObject * obj0 = 0 ;
13666
OpenTURNS::Uncertainty::StatTest::NormalityTest::TestResult result;
13667
13668
if (!PyArg_ParseTuple(args,(char *)"O:NormalityTest_CramerVonMisesNormal",&obj0)) SWIG_fail;
13669
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0 | 0);
13670
if (!SWIG_IsOK(res1)) {
13671
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalityTest_CramerVonMisesNormal" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample const &""'");
13672
}
13673
if (!argp1) {
13674
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalityTest_CramerVonMisesNormal" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample const &""'");
13675
}
13676
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample * >(argp1);
13677
{
13678
try {
13679
result = OpenTURNS::Uncertainty::StatTest::NormalityTest::CramerVonMisesNormal((OpenTURNS::Base::Stat::NumericalSample const &)*arg1);
13680
}
13681
catch (OT::Base::Common::InvalidArgumentException & ex) {
13682
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
13683
}
13684
catch (OT::Base::Common::OutOfBoundException & ex) {
13685
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
13686
}
13687
catch (OT::Base::Common::Exception & ex) {
13688
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
13689
}
13690
catch (std::out_of_range & ex) {
13691
SWIG_exception(SWIG_IndexError,ex.what());
13692
}
13693
catch (std::exception & ex) {
13694
SWIG_exception(SWIG_RuntimeError,ex.what());
13695
}
13696
}
13697
resultobj = SWIG_NewPointerObj((new OpenTURNS::Uncertainty::StatTest::NormalityTest::TestResult(static_cast< const OpenTURNS::Uncertainty::StatTest::NormalityTest::TestResult& >(result))), SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult, SWIG_POINTER_OWN | 0 );
13698
return resultobj;
13699
fail:
13700
return NULL;
13701
}
13702
13703
13704
SWIGINTERN PyObject *_wrap_NormalityTest_CramerVonMisesNormal(PyObject *self, PyObject *args) {
13705
int argc;
13706
PyObject *argv[3];
13707
int ii;
13708
13709
if (!PyTuple_Check(args)) SWIG_fail;
13710
argc = (int)PyObject_Length(args);
13711
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
13712
argv[ii] = PyTuple_GET_ITEM(args,ii);
13713
}
13714
if (argc == 1) {
13715
int _v;
13716
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
13717
_v = SWIG_CheckState(res);
13718
if (_v) {
13719
return _wrap_NormalityTest_CramerVonMisesNormal__SWIG_1(self, args);
13720
}
13721
}
13722
if (argc == 2) {
13723
int _v;
13724
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample, 0);
13725
_v = SWIG_CheckState(res);
13726
if (_v) {
13727
{
13728
int res = SWIG_AsVal_double(argv[1], NULL);
13729
_v = SWIG_CheckState(res);
13730
}
13731
if (_v) {
13732
return _wrap_NormalityTest_CramerVonMisesNormal__SWIG_0(self, args);
13733
}
13734
}
13735
}
13736
13737
fail:
13738
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'NormalityTest_CramerVonMisesNormal'.\n"
13739
" Possible C/C++ prototypes are:\n"
13740
" CramerVonMisesNormal(OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample const &,OpenTURNS::NumericalScalar const)\n"
13741
" OpenTURNS::Uncertainty::StatTest::NormalityTest::CramerVonMisesNormal(OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample const &)\n");
13742
return NULL;
13743
}
13744
13745
13746
SWIGINTERN PyObject *_wrap_new_NormalityTest__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13747
PyObject *resultobj = 0;
13748
OpenTURNS::Uncertainty::StatTest::NormalityTest *arg1 = 0 ;
13749
void *argp1 = 0 ;
13750
int res1 = 0 ;
13751
PyObject * obj0 = 0 ;
13752
OpenTURNS::Uncertainty::StatTest::NormalityTest *result = 0 ;
13753
13754
if (!PyArg_ParseTuple(args,(char *)"O:new_NormalityTest",&obj0)) SWIG_fail;
13755
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__NormalityTest, 0 | 0);
13756
if (!SWIG_IsOK(res1)) {
13757
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NormalityTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::NormalityTest const &""'");
13758
}
13759
if (!argp1) {
13760
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NormalityTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::NormalityTest const &""'");
13761
}
13762
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::NormalityTest * >(argp1);
13763
{
13764
try {
13765
result = (OpenTURNS::Uncertainty::StatTest::NormalityTest *)new_OpenTURNS_Uncertainty_StatTest_NormalityTest__SWIG_1((OpenTURNS::Uncertainty::StatTest::NormalityTest const &)*arg1);
13766
}
13767
catch (OT::Base::Common::InvalidArgumentException & ex) {
13768
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
13769
}
13770
catch (OT::Base::Common::OutOfBoundException & ex) {
13771
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
13772
}
13773
catch (OT::Base::Common::Exception & ex) {
13774
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
13775
}
13776
catch (std::out_of_range & ex) {
13777
SWIG_exception(SWIG_IndexError,ex.what());
13778
}
13779
catch (std::exception & ex) {
13780
SWIG_exception(SWIG_RuntimeError,ex.what());
13781
}
13782
}
13783
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__NormalityTest, SWIG_POINTER_NEW | 0 );
13784
return resultobj;
13785
fail:
13786
return NULL;
13787
}
13788
13789
13790
SWIGINTERN PyObject *_wrap_new_NormalityTest(PyObject *self, PyObject *args) {
13791
int argc;
13792
PyObject *argv[2];
13793
int ii;
13794
13795
if (!PyTuple_Check(args)) SWIG_fail;
13796
argc = (int)PyObject_Length(args);
13797
for (ii = 0; (ii < argc) && (ii < 1); ii++) {
13798
argv[ii] = PyTuple_GET_ITEM(args,ii);
13799
}
13800
if (argc == 0) {
13801
return _wrap_new_NormalityTest__SWIG_0(self, args);
13802
}
13803
if (argc == 1) {
13804
int _v;
13805
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__NormalityTest, 0);
13806
_v = SWIG_CheckState(res);
13807
if (_v) {
13808
return _wrap_new_NormalityTest__SWIG_1(self, args);
13809
}
13810
}
13811
13812
fail:
13813
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NormalityTest'.\n"
13814
" Possible C/C++ prototypes are:\n"
13815
" OpenTURNS::Uncertainty::StatTest::NormalityTest()\n"
13816
" OpenTURNS::Uncertainty::StatTest::NormalityTest(OpenTURNS::Uncertainty::StatTest::NormalityTest const &)\n");
13817
return NULL;
13818
}
13819
13820
13821
SWIGINTERN PyObject *_wrap_delete_NormalityTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13822
PyObject *resultobj = 0;
13823
OpenTURNS::Uncertainty::StatTest::NormalityTest *arg1 = (OpenTURNS::Uncertainty::StatTest::NormalityTest *) 0 ;
13824
void *argp1 = 0 ;
13825
int res1 = 0 ;
13826
PyObject * obj0 = 0 ;
13827
13828
if (!PyArg_ParseTuple(args,(char *)"O:delete_NormalityTest",&obj0)) SWIG_fail;
13829
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__NormalityTest, SWIG_POINTER_DISOWN | 0 );
13830
if (!SWIG_IsOK(res1)) {
13831
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NormalityTest" "', argument " "1"" of type '" "OpenTURNS::Uncertainty::StatTest::NormalityTest *""'");
13832
}
13833
arg1 = reinterpret_cast< OpenTURNS::Uncertainty::StatTest::NormalityTest * >(argp1);
13834
{
13835
try {
13836
delete arg1;
13837
}
13838
catch (OT::Base::Common::InvalidArgumentException & ex) {
13839
SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
13840
}
13841
catch (OT::Base::Common::OutOfBoundException & ex) {
13842
SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
13843
}
13844
catch (OT::Base::Common::Exception & ex) {
13845
SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
13846
}
13847
catch (std::out_of_range & ex) {
13848
SWIG_exception(SWIG_IndexError,ex.what());
13849
}
13850
catch (std::exception & ex) {
13851
SWIG_exception(SWIG_RuntimeError,ex.what());
13852
}
13853
}
13854
resultobj = SWIG_Py_Void();
13855
return resultobj;
13856
fail:
13857
return NULL;
13858
}
13859
13860
13861
SWIGINTERN PyObject *NormalityTest_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13862
PyObject *obj;
13863
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
13864
SWIG_TypeNewClientData(SWIGTYPE_p_OpenTURNS__Uncertainty__StatTest__NormalityTest, SWIG_NewClientData(obj));
13865
return SWIG_Py_Void();
13866
}
13867
13868
static PyMethodDef SwigMethods[] = {
13869
{ (char *)"delete_PySwigIterator", _wrap_delete_PySwigIterator, METH_VARARGS, (char *)"delete_PySwigIterator(PySwigIterator self)"},
13870
{ (char *)"PySwigIterator_value", _wrap_PySwigIterator_value, METH_VARARGS, (char *)"PySwigIterator_value(PySwigIterator self) -> PyObject"},
13871
{ (char *)"PySwigIterator_incr", _wrap_PySwigIterator_incr, METH_VARARGS, (char *)"\n"
13872
"incr(size_t n=1) -> PySwigIterator\n"
13873
"PySwigIterator_incr(PySwigIterator self) -> PySwigIterator\n"
13874
""},
13875
{ (char *)"PySwigIterator_decr", _wrap_PySwigIterator_decr, METH_VARARGS, (char *)"\n"
13876
"decr(size_t n=1) -> PySwigIterator\n"
13877
"PySwigIterator_decr(PySwigIterator self) -> PySwigIterator\n"
13878
""},
13879
{ (char *)"PySwigIterator_distance", _wrap_PySwigIterator_distance, METH_VARARGS, (char *)"PySwigIterator_distance(PySwigIterator self, PySwigIterator x) -> ptrdiff_t"},
13880
{ (char *)"PySwigIterator_equal", _wrap_PySwigIterator_equal, METH_VARARGS, (char *)"PySwigIterator_equal(PySwigIterator self, PySwigIterator x) -> bool"},
13881
{ (char *)"PySwigIterator_copy", _wrap_PySwigIterator_copy, METH_VARARGS, (char *)"PySwigIterator_copy(PySwigIterator self) -> PySwigIterator"},
13882
{ (char *)"PySwigIterator_next", _wrap_PySwigIterator_next, METH_VARARGS, (char *)"PySwigIterator_next(PySwigIterator self) -> PyObject"},
13883
{ (char *)"PySwigIterator_previous", _wrap_PySwigIterator_previous, METH_VARARGS, (char *)"PySwigIterator_previous(PySwigIterator self) -> PyObject"},
13884
{ (char *)"PySwigIterator_advance", _wrap_PySwigIterator_advance, METH_VARARGS, (char *)"PySwigIterator_advance(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
13885
{ (char *)"PySwigIterator___eq__", _wrap_PySwigIterator___eq__, METH_VARARGS, (char *)"PySwigIterator___eq__(PySwigIterator self, PySwigIterator x) -> bool"},
13886
{ (char *)"PySwigIterator___ne__", _wrap_PySwigIterator___ne__, METH_VARARGS, (char *)"PySwigIterator___ne__(PySwigIterator self, PySwigIterator x) -> bool"},
13887
{ (char *)"PySwigIterator___iadd__", _wrap_PySwigIterator___iadd__, METH_VARARGS, (char *)"PySwigIterator___iadd__(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
13888
{ (char *)"PySwigIterator___isub__", _wrap_PySwigIterator___isub__, METH_VARARGS, (char *)"PySwigIterator___isub__(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
13889
{ (char *)"PySwigIterator___add__", _wrap_PySwigIterator___add__, METH_VARARGS, (char *)"PySwigIterator___add__(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
13890
{ (char *)"PySwigIterator___sub__", _wrap_PySwigIterator___sub__, METH_VARARGS, (char *)"\n"
13891
"__sub__(ptrdiff_t n) -> PySwigIterator\n"
13892
"PySwigIterator___sub__(PySwigIterator self, PySwigIterator x) -> ptrdiff_t\n"
13893
""},
13894
{ (char *)"PySwigIterator_swigregister", PySwigIterator_swigregister, METH_VARARGS, NULL},
13895
{ (char *)"TestResult_GetClassName", _wrap_TestResult_GetClassName, METH_VARARGS, (char *)"TestResult_GetClassName() -> String"},
13896
{ (char *)"TestResult_getClassName", _wrap_TestResult_getClassName, METH_VARARGS, (char *)"TestResult_getClassName(TestResult self) -> String"},
13897
{ (char *)"TestResult_clone", _wrap_TestResult_clone, METH_VARARGS, (char *)"TestResult_clone(TestResult self) -> TestResult"},
13898
{ (char *)"TestResult_setDescription", _wrap_TestResult_setDescription, METH_VARARGS, (char *)"TestResult_setDescription(TestResult self, Description description)"},
13899
{ (char *)"TestResult_getDescription", _wrap_TestResult_getDescription, METH_VARARGS, (char *)"TestResult_getDescription(TestResult self) -> Description"},
13900
{ (char *)"TestResult___repr__", _wrap_TestResult___repr__, METH_VARARGS, (char *)"TestResult___repr__(TestResult self) -> String"},
13901
{ (char *)"TestResult_getBinaryQualityMeasure", _wrap_TestResult_getBinaryQualityMeasure, METH_VARARGS, (char *)"TestResult_getBinaryQualityMeasure(TestResult self) -> Bool"},
13902
{ (char *)"TestResult_getPValue", _wrap_TestResult_getPValue, METH_VARARGS, (char *)"TestResult_getPValue(TestResult self) -> NumericalScalar"},
13903
{ (char *)"TestResult_getThreshold", _wrap_TestResult_getThreshold, METH_VARARGS, (char *)"TestResult_getThreshold(TestResult self) -> NumericalScalar"},
13904
{ (char *)"TestResult_getTestType", _wrap_TestResult_getTestType, METH_VARARGS, (char *)"TestResult_getTestType(TestResult self) -> String"},
13905
{ (char *)"TestResult___eq__", _wrap_TestResult___eq__, METH_VARARGS, (char *)"TestResult___eq__(TestResult self, TestResult rhs) -> Bool"},
13906
{ (char *)"new_TestResult", _wrap_new_TestResult, METH_VARARGS, (char *)"\n"
13907
"TestResult()\n"
13908
"TestResult(String type, Bool binMeasure, NumericalScalar pVal, \n"
13909
" NumericalScalar pThreshold)\n"
13910
"TestResult(TestResult other)\n"
13911
"new_TestResult(PyObject pyObj) -> TestResult\n"
13912
""},
13913
{ (char *)"delete_TestResult", _wrap_delete_TestResult, METH_VARARGS, (char *)"delete_TestResult(TestResult self)"},
13914
{ (char *)"TestResult_swigregister", TestResult_swigregister, METH_VARARGS, NULL},
13915
{ (char *)"VisualTest_DrawEmpiricalCDF", _wrap_VisualTest_DrawEmpiricalCDF, METH_VARARGS, (char *)"VisualTest_DrawEmpiricalCDF(NumericalSample sample, NumericalScalar xMin, NumericalScalar xMax) -> Graph"},
13916
{ (char *)"VisualTest_DrawHistogram", _wrap_VisualTest_DrawHistogram, METH_VARARGS, (char *)"\n"
13917
"DrawHistogram(NumericalSample sample, UnsignedLong BarNumber) -> Graph\n"
13918
"VisualTest_DrawHistogram(NumericalSample sample) -> Graph\n"
13919
""},
13920
{ (char *)"VisualTest_DrawQQplot", _wrap_VisualTest_DrawQQplot, METH_VARARGS, (char *)"\n"
13921
"DrawQQplot(NumericalSample sample1, NumericalSample sample2, UnsignedLong pointNumber=DefaultPointNumber) -> Graph\n"
13922
"DrawQQplot(NumericalSample sample1, NumericalSample sample2) -> Graph\n"
13923
"DrawQQplot(NumericalSample sample, Distribution dist, UnsignedLong pointNumber=DefaultPointNumber) -> Graph\n"
13924
"VisualTest_DrawQQplot(NumericalSample sample, Distribution dist) -> Graph\n"
13925
""},
13926
{ (char *)"VisualTest_DrawHenryLine", _wrap_VisualTest_DrawHenryLine, METH_VARARGS, (char *)"VisualTest_DrawHenryLine(NumericalSample sample) -> Graph"},
13927
{ (char *)"VisualTest_DrawClouds", _wrap_VisualTest_DrawClouds, METH_VARARGS, (char *)"\n"
13928
"DrawClouds(NumericalSample sample1, Distribution dist) -> Graph\n"
13929
"VisualTest_DrawClouds(NumericalSample sample1, NumericalSample sample2) -> Graph\n"
13930
""},
13931
{ (char *)"VisualTest_DrawLMVisualTest", _wrap_VisualTest_DrawLMVisualTest, METH_VARARGS, (char *)"VisualTest_DrawLMVisualTest(NumericalSample sample1, NumericalSample sample2, LinearModel lm) -> Graph"},
13932
{ (char *)"VisualTest_DrawLMResidualTest", _wrap_VisualTest_DrawLMResidualTest, METH_VARARGS, (char *)"VisualTest_DrawLMResidualTest(NumericalSample sample1, NumericalSample sample2, LinearModel lm) -> Graph"},
13933
{ (char *)"new_VisualTest", _wrap_new_VisualTest, METH_VARARGS, (char *)"\n"
13934
"VisualTest()\n"
13935
"new_VisualTest(VisualTest other) -> VisualTest\n"
13936
""},
13937
{ (char *)"delete_VisualTest", _wrap_delete_VisualTest, METH_VARARGS, (char *)"delete_VisualTest(VisualTest self)"},
13938
{ (char *)"VisualTest_swigregister", VisualTest_swigregister, METH_VARARGS, NULL},
13939
{ (char *)"FittingTest_BestModelBIC", _wrap_FittingTest_BestModelBIC, METH_VARARGS, (char *)"\n"
13940
"BestModelBIC(NumericalSample sample, DistributionFactoryCollection factoryCollection) -> Distribution\n"
13941
"FittingTest_BestModelBIC(NumericalSample sample, DistributionCollection distributionCollection) -> Distribution\n"
13942
""},
13943
{ (char *)"FittingTest_BestModelKolmogorov", _wrap_FittingTest_BestModelKolmogorov, METH_VARARGS, (char *)"\n"
13944
"BestModelKolmogorov(NumericalSample sample, DistributionFactoryCollection factoryCollection) -> Distribution\n"
13945
"FittingTest_BestModelKolmogorov(NumericalSample sample, DistributionCollection distributionCollection) -> Distribution\n"
13946
""},
13947
{ (char *)"FittingTest_BestModelChiSquared", _wrap_FittingTest_BestModelChiSquared, METH_VARARGS, (char *)"\n"
13948
"BestModelChiSquared(NumericalSample sample, DistributionFactoryCollection factoryCollection) -> Distribution\n"
13949
"FittingTest_BestModelChiSquared(NumericalSample sample, DistributionCollection distributionCollection) -> Distribution\n"
13950
""},
13951
{ (char *)"FittingTest_BIC", _wrap_FittingTest_BIC, METH_VARARGS, (char *)"\n"
13952
"BIC(NumericalSample sample, Distribution distribution, \n"
13953
" UnsignedLong estimatedParameters=0) -> NumericalScalar\n"
13954
"BIC(NumericalSample sample, Distribution distribution) -> NumericalScalar\n"
13955
"FittingTest_BIC(NumericalSample sample, Factory factory) -> NumericalScalar\n"
13956
""},
13957
{ (char *)"FittingTest_Kolmogorov", _wrap_FittingTest_Kolmogorov, METH_VARARGS, (char *)"\n"
13958
"Kolmogorov(NumericalSample sample, Distribution distribution, \n"
13959
" NumericalScalar level=0.95, UnsignedLong estimatedParameters=0) -> TestResult\n"
13960
"Kolmogorov(NumericalSample sample, Distribution distribution, \n"
13961
" NumericalScalar level=0.95) -> TestResult\n"
13962
"Kolmogorov(NumericalSample sample, Distribution distribution) -> TestResult\n"
13963
"Kolmogorov(NumericalSample sample, Factory factory, NumericalScalar level=0.95) -> TestResult\n"
13964
"FittingTest_Kolmogorov(NumericalSample sample, Factory factory) -> TestResult\n"
13965
""},
13966
{ (char *)"FittingTest_ChiSquared", _wrap_FittingTest_ChiSquared, METH_VARARGS, (char *)"\n"
13967
"ChiSquared(NumericalSample sample, Distribution distribution, \n"
13968
" NumericalScalar level=0.95, UnsignedLong estimatedParameters=0) -> TestResult\n"
13969
"ChiSquared(NumericalSample sample, Distribution distribution, \n"
13970
" NumericalScalar level=0.95) -> TestResult\n"
13971
"ChiSquared(NumericalSample sample, Distribution distribution) -> TestResult\n"
13972
"ChiSquared(NumericalSample sample, Factory factory, NumericalScalar level=0.95) -> TestResult\n"
13973
"FittingTest_ChiSquared(NumericalSample sample, Factory factory) -> TestResult\n"
13974
""},
13975
{ (char *)"FittingTest_GetLastResult", _wrap_FittingTest_GetLastResult, METH_VARARGS, (char *)"FittingTest_GetLastResult() -> TestResult"},
13976
{ (char *)"new_FittingTest", _wrap_new_FittingTest, METH_VARARGS, (char *)"\n"
13977
"FittingTest()\n"
13978
"new_FittingTest(FittingTest other) -> FittingTest\n"
13979
""},
13980
{ (char *)"delete_FittingTest", _wrap_delete_FittingTest, METH_VARARGS, (char *)"delete_FittingTest(FittingTest self)"},
13981
{ (char *)"FittingTest_swigregister", FittingTest_swigregister, METH_VARARGS, NULL},
13982
{ (char *)"TestResultCollection_clear", _wrap_TestResultCollection_clear, METH_VARARGS, (char *)"TestResultCollection_clear(TestResultCollection self)"},
13983
{ (char *)"TestResultCollection___len__", _wrap_TestResultCollection___len__, METH_VARARGS, (char *)"TestResultCollection___len__(TestResultCollection self) -> UnsignedLong"},
13984
{ (char *)"TestResultCollection___eq__", _wrap_TestResultCollection___eq__, METH_VARARGS, (char *)"TestResultCollection___eq__(TestResultCollection self, TestResultCollection rhs) -> Bool"},
13985
{ (char *)"TestResultCollection___contains__", _wrap_TestResultCollection___contains__, METH_VARARGS, (char *)"TestResultCollection___contains__(TestResultCollection self, TestResult val) -> Bool"},
13986
{ (char *)"TestResultCollection___getitem__", _wrap_TestResultCollection___getitem__, METH_VARARGS, (char *)"TestResultCollection___getitem__(TestResultCollection self, UnsignedLong i) -> TestResult"},
13987
{ (char *)"TestResultCollection___setitem__", _wrap_TestResultCollection___setitem__, METH_VARARGS, (char *)"TestResultCollection___setitem__(TestResultCollection self, UnsignedLong i, TestResult val)"},
13988
{ (char *)"TestResultCollection___delitem__", _wrap_TestResultCollection___delitem__, METH_VARARGS, (char *)"TestResultCollection___delitem__(TestResultCollection self, UnsignedLong i, TestResult val)"},
13989
{ (char *)"TestResultCollection_at", _wrap_TestResultCollection_at, METH_VARARGS, (char *)"\n"
13990
"at(UnsignedLong i) -> TestResult\n"
13991
"TestResultCollection_at(TestResultCollection self, UnsignedLong i) -> TestResult\n"
13992
""},
13993
{ (char *)"TestResultCollection_add", _wrap_TestResultCollection_add, METH_VARARGS, (char *)"TestResultCollection_add(TestResultCollection self, TestResult elt)"},
13994
{ (char *)"TestResultCollection_getSize", _wrap_TestResultCollection_getSize, METH_VARARGS, (char *)"TestResultCollection_getSize(TestResultCollection self) -> UnsignedLong"},
13995
{ (char *)"TestResultCollection_resize", _wrap_TestResultCollection_resize, METH_VARARGS, (char *)"TestResultCollection_resize(TestResultCollection self, UnsignedLong newSize)"},
13996
{ (char *)"TestResultCollection_isEmpty", _wrap_TestResultCollection_isEmpty, METH_VARARGS, (char *)"TestResultCollection_isEmpty(TestResultCollection self) -> Bool"},
13997
{ (char *)"TestResultCollection___repr__", _wrap_TestResultCollection___repr__, METH_VARARGS, (char *)"TestResultCollection___repr__(TestResultCollection self) -> String"},
13998
{ (char *)"TestResultCollection___str__", _wrap_TestResultCollection___str__, METH_VARARGS, (char *)"TestResultCollection___str__(TestResultCollection self) -> String"},
13999
{ (char *)"new_TestResultCollection", _wrap_new_TestResultCollection, METH_VARARGS, (char *)"\n"
14000
"TestResultCollection()\n"
14001
"TestResultCollection(UnsignedLong size)\n"
14002
"TestResultCollection(UnsignedLong size, TestResult value)\n"
14003
"new_TestResultCollection(PyObject pyObj) -> TestResultCollection\n"
14004
""},
14005
{ (char *)"delete_TestResultCollection", _wrap_delete_TestResultCollection, METH_VARARGS, (char *)"delete_TestResultCollection(TestResultCollection self)"},
14006
{ (char *)"TestResultCollection_swigregister", TestResultCollection_swigregister, METH_VARARGS, NULL},
14007
{ (char *)"HypothesisTest_ChiSquared", _wrap_HypothesisTest_ChiSquared, METH_VARARGS, (char *)"\n"
14008
"ChiSquared(NumericalSample firstSample, NumericalSample secondSample, \n"
14009
" NumericalScalar level=0.95) -> TestResult\n"
14010
"HypothesisTest_ChiSquared(NumericalSample firstSample, NumericalSample secondSample) -> TestResult\n"
14011
""},
14012
{ (char *)"HypothesisTest_Pearson", _wrap_HypothesisTest_Pearson, METH_VARARGS, (char *)"\n"
14013
"Pearson(NumericalSample firstSample, NumericalSample secondSample, \n"
14014
" NumericalScalar level=0.95) -> TestResult\n"
14015
"HypothesisTest_Pearson(NumericalSample firstSample, NumericalSample secondSample) -> TestResult\n"
14016
""},
14017
{ (char *)"HypothesisTest_Smirnov", _wrap_HypothesisTest_Smirnov, METH_VARARGS, (char *)"\n"
14018
"Smirnov(NumericalSample firstSample, NumericalSample secondSample, \n"
14019
" NumericalScalar level=0.95) -> TestResult\n"
14020
"HypothesisTest_Smirnov(NumericalSample firstSample, NumericalSample secondSample) -> TestResult\n"
14021
""},
14022
{ (char *)"HypothesisTest_Spearman", _wrap_HypothesisTest_Spearman, METH_VARARGS, (char *)"\n"
14023
"Spearman(NumericalSample firstSample, NumericalSample secondSample, \n"
14024
" NumericalScalar level=0.95) -> TestResult\n"
14025
"HypothesisTest_Spearman(NumericalSample firstSample, NumericalSample secondSample) -> TestResult\n"
14026
""},
14027
{ (char *)"HypothesisTest_PartialPearson", _wrap_HypothesisTest_PartialPearson, METH_VARARGS, (char *)"\n"
14028
"PartialPearson(NumericalSample firstSample, NumericalSample secondSample, \n"
14029
" Indices selection, NumericalScalar level=0.95) -> TestResultCollection\n"
14030
"HypothesisTest_PartialPearson(NumericalSample firstSample, NumericalSample secondSample, \n"
14031
" Indices selection) -> TestResultCollection\n"
14032
""},
14033
{ (char *)"HypothesisTest_PartialRegression", _wrap_HypothesisTest_PartialRegression, METH_VARARGS, (char *)"\n"
14034
"PartialRegression(NumericalSample firstSample, NumericalSample secondSample, \n"
14035
" Indices selection, NumericalScalar level=0.95) -> TestResultCollection\n"
14036
"HypothesisTest_PartialRegression(NumericalSample firstSample, NumericalSample secondSample, \n"
14037
" Indices selection) -> TestResultCollection\n"
14038
""},
14039
{ (char *)"HypothesisTest_PartialSpearman", _wrap_HypothesisTest_PartialSpearman, METH_VARARGS, (char *)"\n"
14040
"PartialSpearman(NumericalSample firstSample, NumericalSample secondSample, \n"
14041
" Indices selection, NumericalScalar level=0.95) -> TestResultCollection\n"
14042
"HypothesisTest_PartialSpearman(NumericalSample firstSample, NumericalSample secondSample, \n"
14043
" Indices selection) -> TestResultCollection\n"
14044
""},
14045
{ (char *)"HypothesisTest_FullPearson", _wrap_HypothesisTest_FullPearson, METH_VARARGS, (char *)"\n"
14046
"FullPearson(NumericalSample firstSample, NumericalSample secondSample, \n"
14047
" NumericalScalar level=0.95) -> TestResultCollection\n"
14048
"HypothesisTest_FullPearson(NumericalSample firstSample, NumericalSample secondSample) -> TestResultCollection\n"
14049
""},
14050
{ (char *)"HypothesisTest_FullRegression", _wrap_HypothesisTest_FullRegression, METH_VARARGS, (char *)"\n"
14051
"FullRegression(NumericalSample firstSample, NumericalSample secondSample, \n"
14052
" NumericalScalar level=0.95) -> TestResultCollection\n"
14053
"HypothesisTest_FullRegression(NumericalSample firstSample, NumericalSample secondSample) -> TestResultCollection\n"
14054
""},
14055
{ (char *)"HypothesisTest_FullSpearman", _wrap_HypothesisTest_FullSpearman, METH_VARARGS, (char *)"\n"
14056
"FullSpearman(NumericalSample firstSample, NumericalSample secondSample, \n"
14057
" NumericalScalar level=0.95) -> TestResultCollection\n"
14058
"HypothesisTest_FullSpearman(NumericalSample firstSample, NumericalSample secondSample) -> TestResultCollection\n"
14059
""},
14060
{ (char *)"new_HypothesisTest", _wrap_new_HypothesisTest, METH_VARARGS, (char *)"\n"
14061
"HypothesisTest()\n"
14062
"new_HypothesisTest(HypothesisTest other) -> HypothesisTest\n"
14063
""},
14064
{ (char *)"delete_HypothesisTest", _wrap_delete_HypothesisTest, METH_VARARGS, (char *)"delete_HypothesisTest(HypothesisTest self)"},
14065
{ (char *)"HypothesisTest_swigregister", HypothesisTest_swigregister, METH_VARARGS, NULL},
14066
{ (char *)"LinearModelTest_LMAdjustedRSquared", _wrap_LinearModelTest_LMAdjustedRSquared, METH_VARARGS, (char *)"\n"
14067
"LMAdjustedRSquared(NumericalSample firstSample, NumericalSample secondSample, \n"
14068
" LinearModel linearModel, NumericalScalar level=0.95) -> TestResult\n"
14069
"LMAdjustedRSquared(NumericalSample firstSample, NumericalSample secondSample, \n"
14070
" LinearModel linearModel) -> TestResult\n"
14071
"LMAdjustedRSquared(NumericalSample firstSample, NumericalSample secondSample, \n"
14072
" NumericalScalar level=0.95) -> TestResult\n"
14073
"LinearModelTest_LMAdjustedRSquared(NumericalSample firstSample, NumericalSample secondSample) -> TestResult\n"
14074
""},
14075
{ (char *)"LinearModelTest_LMFisher", _wrap_LinearModelTest_LMFisher, METH_VARARGS, (char *)"\n"
14076
"LMFisher(NumericalSample firstSample, NumericalSample secondSample, \n"
14077
" LinearModel linearModel, NumericalScalar level=0.95) -> TestResult\n"
14078
"LMFisher(NumericalSample firstSample, NumericalSample secondSample, \n"
14079
" LinearModel linearModel) -> TestResult\n"
14080
"LMFisher(NumericalSample firstSample, NumericalSample secondSample, \n"
14081
" NumericalScalar level=0.95) -> TestResult\n"
14082
"LinearModelTest_LMFisher(NumericalSample firstSample, NumericalSample secondSample) -> TestResult\n"
14083
""},
14084
{ (char *)"LinearModelTest_LMResidualMean", _wrap_LinearModelTest_LMResidualMean, METH_VARARGS, (char *)"\n"
14085
"LMResidualMean(NumericalSample firstSample, NumericalSample secondSample, \n"
14086
" LinearModel linearModel, NumericalScalar level=0.95) -> TestResult\n"
14087
"LMResidualMean(NumericalSample firstSample, NumericalSample secondSample, \n"
14088
" LinearModel linearModel) -> TestResult\n"
14089
"LMResidualMean(NumericalSample firstSample, NumericalSample secondSample, \n"
14090
" NumericalScalar level=0.95) -> TestResult\n"
14091
"LinearModelTest_LMResidualMean(NumericalSample firstSample, NumericalSample secondSample) -> TestResult\n"
14092
""},
14093
{ (char *)"LinearModelTest_LMRSquared", _wrap_LinearModelTest_LMRSquared, METH_VARARGS, (char *)"\n"
14094
"LMRSquared(NumericalSample firstSample, NumericalSample secondSample, \n"
14095
" LinearModel linearModel, NumericalScalar level=0.95) -> TestResult\n"
14096
"LMRSquared(NumericalSample firstSample, NumericalSample secondSample, \n"
14097
" LinearModel linearModel) -> TestResult\n"
14098
"LMRSquared(NumericalSample firstSample, NumericalSample secondSample, \n"
14099
" NumericalScalar level=0.95) -> TestResult\n"
14100
"LinearModelTest_LMRSquared(NumericalSample firstSample, NumericalSample secondSample) -> TestResult\n"
14101
""},
14102
{ (char *)"new_LinearModelTest", _wrap_new_LinearModelTest, METH_VARARGS, (char *)"\n"
14103
"LinearModelTest()\n"
14104
"new_LinearModelTest(LinearModelTest other) -> LinearModelTest\n"
14105
""},
14106
{ (char *)"delete_LinearModelTest", _wrap_delete_LinearModelTest, METH_VARARGS, (char *)"delete_LinearModelTest(LinearModelTest self)"},
14107
{ (char *)"LinearModelTest_swigregister", LinearModelTest_swigregister, METH_VARARGS, NULL},
14108
{ (char *)"NormalityTest_AndersonDarlingNormal", _wrap_NormalityTest_AndersonDarlingNormal, METH_VARARGS, (char *)"\n"
14109
"AndersonDarlingNormal(NumericalSample sample, NumericalScalar level=0.95) -> TestResult\n"
14110
"NormalityTest_AndersonDarlingNormal(NumericalSample sample) -> TestResult\n"
14111
""},
14112
{ (char *)"NormalityTest_CramerVonMisesNormal", _wrap_NormalityTest_CramerVonMisesNormal, METH_VARARGS, (char *)"\n"
14113
"CramerVonMisesNormal(NumericalSample sample, NumericalScalar level=0.95) -> TestResult\n"
14114
"NormalityTest_CramerVonMisesNormal(NumericalSample sample) -> TestResult\n"
14115
""},
14116
{ (char *)"new_NormalityTest", _wrap_new_NormalityTest, METH_VARARGS, (char *)"\n"
14117
"NormalityTest()\n"
14118
"new_NormalityTest(NormalityTest other) -> NormalityTest\n"
14119
""},
14120
{ (char *)"delete_NormalityTest", _wrap_delete_NormalityTest, METH_VARARGS, (char *)"delete_NormalityTest(NormalityTest self)"},
14121
{ (char *)"NormalityTest_swigregister", NormalityTest_swigregister, METH_VARARGS, NULL},
14122
{ NULL, NULL, 0, NULL }
14123
};
14124
14125
14126
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
14127
14128
static void *_p_OpenTURNS__Uncertainty__Model__NonEllipticalDistributionTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14129
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *) ((OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) x));
14130
}
14131
static void *_p_OT__Base__Optim__NearestPointChecker__ResultTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14132
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::NearestPointCheckerResult *) x));
14133
}
14134
static void *_p_OpenTURNS__Base__Stat__TestResultTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14135
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::TestResult *) x));
14136
}
14137
static void *_p_OpenTURNS__Uncertainty__Distribution__WeibullTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14138
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Weibull *) x));
14139
}
14140
static void *_p_OpenTURNS__Base__Stat__ConfidenceIntervalTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14141
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::ConfidenceInterval *) x));
14142
}
14143
static void *_p_OpenTURNS__Base__Type__IntervalTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14144
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::Interval *) x));
14145
}
14146
static void *_p_OpenTURNS__Base__Stat__HaltonSequenceTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14147
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation *) ((OpenTURNS::Base::Stat::HaltonSequence *) x));
14148
}
14149
static void *_p_OpenTURNS__Base__Stat__SobolSequenceTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14150
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation *) ((OpenTURNS::Base::Stat::SobolSequence *) x));
14151
}
14152
static void *_p_OpenTURNS__Uncertainty__Distribution__UserDefinedTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14153
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::DiscreteDistribution *) ((OpenTURNS::Uncertainty::Distribution::UserDefined *) x));
14154
}
14155
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_tTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14156
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Type::NumericalPointWithDescription > *) x));
14157
}
14158
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_tTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14159
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Type::NumericalPoint > *) x));
14160
}
14161
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_tTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14162
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Func::UniVariatePolynomial > *) x));
14163
}
14164
static void *_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14165
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) x));
14166
}
14167
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathFunctionTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14168
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathFunctionImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathFunction *) x));
14169
}
14170
static void *_p_OpenTURNS__Base__Stat__NullTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14171
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Null *) x));
14172
}
14173
static void *_p_OpenTURNS__Uncertainty__Distribution__GeometricFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14174
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::GeometricFactory *) x));
14175
}
14176
static void *_p_OpenTURNS__Base__Optim__AbdoRackwitzTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14177
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Optim::NearestPointAlgorithmImplementation *) ((OpenTURNS::Base::Optim::AbdoRackwitz *) x));
14178
}
14179
static void *_p_OpenTURNS__Uncertainty__Distribution__MixtureTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14180
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *) ((OpenTURNS::Uncertainty::Distribution::Mixture *) x));
14181
}
14182
static void *_p_OpenTURNS__Uncertainty__Distribution__ExponentialTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14183
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Exponential *) x));
14184
}
14185
static void *_p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14186
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::QuadraticNumericalMathEvaluationImplementation *) x));
14187
}
14188
static void *_p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14189
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::IndicatorNumericalMathEvaluationImplementation *) x));
14190
}
14191
static void *_p_OpenTURNS__Base__Stat__LinearModelTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14192
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::LinearModel *) x));
14193
}
14194
static void *_p_OpenTURNS__Base__Func__LinearCombinationGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14195
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::LinearCombinationGradientImplementation *) x));
14196
}
14197
static void *_p_OpenTURNS__Base__Func__NumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14198
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::NumericalMathGradientImplementation *) x));
14199
}
14200
static void *_p_OpenTURNS__Base__Func__NumericalMathFunctionImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14201
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::NumericalMathFunctionImplementation *) x));
14202
}
14203
static void *_p_OpenTURNS__Base__Stat__CompactTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14204
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Compact *) x));
14205
}
14206
static void *_p_OpenTURNS__Uncertainty__Model__DistributionImplementationFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14207
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) x));
14208
}
14209
static void *_p_OpenTURNS__Uncertainty__Model__DistributionImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14210
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Uncertainty::Model::DistributionImplementation *) x));
14211
}
14212
static void *_p_OpenTURNS__Base__Common__ComparisonOperatorImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14213
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Common::ComparisonOperatorImplementation *) x));
14214
}
14215
static void *_p_OpenTURNS__Base__Func__NumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14216
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::NumericalMathHessianImplementation *) x));
14217
}
14218
static void *_p_OpenTURNS__Base__Func__UniVariatePolynomialImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14219
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::UniVariatePolynomialImplementation *) x));
14220
}
14221
static void *_p_OpenTURNS__Uncertainty__Model__RandomVectorImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14222
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Uncertainty::Model::RandomVectorImplementation *) x));
14223
}
14224
static void *_p_OpenTURNS__Uncertainty__Distribution__TriangularFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14225
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::TriangularFactory *) x));
14226
}
14227
static void *_p_OpenTURNS__Uncertainty__Distribution__LaplaceFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14228
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::LaplaceFactory *) x));
14229
}
14230
static void *_p_OpenTURNS__Base__Optim__CobylaTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14231
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Optim::NearestPointAlgorithmImplementation *) ((OpenTURNS::Base::Optim::Cobyla *) x));
14232
}
14233
static void *_p_OpenTURNS__Base__Graph__CurveTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14234
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Graph::DrawableImplementation *) ((OpenTURNS::Base::Graph::Curve *) x));
14235
}
14236
static void *_p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14237
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::ClaytonCopulaFactory *) x));
14238
}
14239
static void *_p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14240
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *)(OpenTURNS::Uncertainty::Model::ArchimedeanCopula *) ((OpenTURNS::Uncertainty::Distribution::ClaytonCopula *) x));
14241
}
14242
static void *_p_OpenTURNS__Uncertainty__Distribution__WeibullFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14243
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::WeibullFactory *) x));
14244
}
14245
static void *_p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14246
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::NoNumericalMathHessianImplementation *) x));
14247
}
14248
static void *_p_OpenTURNS__Base__Optim__NearestPointCheckerTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14249
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::NearestPointChecker *) x));
14250
}
14251
static void *_p_OpenTURNS__Uncertainty__Distribution__EpanechnikovTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14252
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Epanechnikov *) x));
14253
}
14254
static void *_p_OpenTURNS__Base__Graph__StaircaseTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14255
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Graph::DrawableImplementation *) ((OpenTURNS::Base::Graph::Staircase *) x));
14256
}
14257
static void *_p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14258
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ConstantNumericalMathGradientImplementation *) x));
14259
}
14260
static void *_p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14261
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ComputedNumericalMathGradientImplementation *) x));
14262
}
14263
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14264
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathGradientImplementation *) x));
14265
}
14266
static void *_p_OpenTURNS__Uncertainty__Distribution__GumbelTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14267
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Gumbel *) x));
14268
}
14269
static void *_p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14270
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::BoundConstrainedAlgorithmImplementation *) x));
14271
}
14272
static void *_p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationResultTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14273
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::BoundConstrainedAlgorithmImplementationResult *) x));
14274
}
14275
static void *_p_OpenTURNS__Uncertainty__Distribution__HistogramTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14276
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Histogram *) x));
14277
}
14278
static void *_p_OpenTURNS__Uncertainty__Distribution__ComposedDistributionTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14279
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *) ((OpenTURNS::Uncertainty::Distribution::ComposedDistribution *) x));
14280
}
14281
static void *_p_OpenTURNS__Uncertainty__Distribution__IndependentCopulaTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14282
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *) ((OpenTURNS::Uncertainty::Distribution::IndependentCopula *) x));
14283
}
14284
static void *_p_OpenTURNS__Uncertainty__Distribution__LaplaceTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14285
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Laplace *) x));
14286
}
14287
static void *_p_OpenTURNS__Base__Solver__SolverImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14288
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Solver::SolverImplementation *) x));
14289
}
14290
static void *_p_OpenTURNS__Base__Graph__DrawableImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14291
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Graph::DrawableImplementation *) x));
14292
}
14293
static void *_p_OpenTURNS__Base__Type__TensorImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14294
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::NumericalScalar > *) ((OpenTURNS::Base::Type::TensorImplementation *) x));
14295
}
14296
static void *_p_OpenTURNS__Base__Type__MatrixImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14297
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::NumericalScalar > *) ((OpenTURNS::Base::Type::MatrixImplementation *) x));
14298
}
14299
static void *_p_OpenTURNS__Base__Type__DescriptionImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14300
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::String > *) ((OpenTURNS::Base::Type::DescriptionImplementation *) x));
14301
}
14302
static void *_p_OpenTURNS__Base__Graph__GraphImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14303
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Graph::GraphImplementation *) x));
14304
}
14305
static void *_p_OpenTURNS__Uncertainty__Model__ConstantRandomVectorTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14306
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::RandomVectorImplementation *) ((OpenTURNS::Uncertainty::Model::ConstantRandomVector *) x));
14307
}
14308
static void *_p_OpenTURNS__Uncertainty__Distribution__GammaTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14309
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Gamma *) x));
14310
}
14311
static void *_p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14312
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::NoNumericalMathGradientImplementation *) x));
14313
}
14314
static void *_p_OpenTURNS__Uncertainty__Distribution__ComposedCopulaTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14315
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *) ((OpenTURNS::Uncertainty::Distribution::ComposedCopula *) x));
14316
}
14317
static void *_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14318
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) x));
14319
}
14320
static void *_p_OpenTURNS__Base__Common__GreaterOrEqualTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14321
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::GreaterOrEqual *) x));
14322
}
14323
static void *_p_OpenTURNS__Base__Common__LessOrEqualTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14324
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::LessOrEqual *) x));
14325
}
14326
static void *_p_OpenTURNS__Uncertainty__Distribution__UniformTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14327
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Uniform *) x));
14328
}
14329
static void *_p_OpenTURNS__Uncertainty__Model__UsualDistributionTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14330
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *) ((OpenTURNS::Uncertainty::Model::UsualDistribution *) x));
14331
}
14332
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14333
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathEvaluationImplementation *) x));
14334
}
14335
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_tTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14336
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< unsigned long > *) x));
14337
}
14338
static void *_p_OpenTURNS__Uncertainty__Distribution__HistogramFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14339
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::HistogramFactory *) x));
14340
}
14341
static void *_p_OpenTURNS__Base__Stat__HistoryStrategyImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14342
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::HistoryStrategyImplementation *) x));
14343
}
14344
static void *_p_OpenTURNS__Base__Stat__NumericalSampleImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14345
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Type::NumericalPoint > *) ((OpenTURNS::Base::Stat::NumericalSampleImplementation *) x));
14346
}
14347
static void *_p_OpenTURNS__Base__Type__NumericalPointWithDescriptionTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14348
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::NumericalScalar > *)(OpenTURNS::Base::Type::NumericalPoint *) ((OpenTURNS::Base::Type::NumericalPointWithDescription *) x));
14349
}
14350
static void *_p_OpenTURNS__Uncertainty__Distribution__LogNormalFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14351
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::LogNormalFactory *) x));
14352
}
14353
static void *_p_OpenTURNS__Uncertainty__Distribution__LogisticTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14354
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Logistic *) x));
14355
}
14356
static void *_p_OpenTURNS__Uncertainty__Distribution__GeometricTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14357
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::DiscreteDistribution *) ((OpenTURNS::Uncertainty::Distribution::Geometric *) x));
14358
}
14359
static void *_p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14360
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::GumbelCopulaFactory *) x));
14361
}
14362
static void *_p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14363
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *)(OpenTURNS::Uncertainty::Model::ArchimedeanCopula *) ((OpenTURNS::Uncertainty::Distribution::GumbelCopula *) x));
14364
}
14365
static void *_p_OpenTURNS__Uncertainty__Distribution__NormalCopulaFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14366
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::NormalCopulaFactory *) x));
14367
}
14368
static void *_p_OpenTURNS__Uncertainty__Distribution__NormalCopulaTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14369
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *) ((OpenTURNS::Uncertainty::Distribution::NormalCopula *) x));
14370
}
14371
static void *_p_OpenTURNS__Uncertainty__Model__SklarCopulaTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14372
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *) ((OpenTURNS::Uncertainty::Model::SklarCopula *) x));
14373
}
14374
static void *_p_OpenTURNS__Uncertainty__Model__ArchimedeanCopulaTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14375
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *) ((OpenTURNS::Uncertainty::Model::ArchimedeanCopula *) x));
14376
}
14377
static void *_p_OpenTURNS__Uncertainty__Distribution__StudentFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14378
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::StudentFactory *) x));
14379
}
14380
static void *_p_OpenTURNS__Uncertainty__Distribution__UserDefinedFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14381
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::UserDefinedFactory *) x));
14382
}
14383
static void *_p_OpenTURNS__Base__Optim__PenalizedLeastSquaresAlgorithmTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14384
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::PenalizedLeastSquaresAlgorithm *) x));
14385
}
14386
static void *_p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14387
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation *) x));
14388
}
14389
static void *_p_OpenTURNS__Base__Optim__TNCTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14390
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Optim::BoundConstrainedAlgorithmImplementation *) ((OpenTURNS::Base::Optim::TNC *) x));
14391
}
14392
static void *_p_OpenTURNS__Uncertainty__Distribution__KernelMixtureTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14393
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::KernelMixture *) x));
14394
}
14395
static void *_p_OpenTURNS__Uncertainty__Distribution__MultiNomialFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14396
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::MultiNomialFactory *) x));
14397
}
14398
static void *_p_OpenTURNS__Uncertainty__Distribution__MultiNomialTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14399
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::DiscreteDistribution *) ((OpenTURNS::Uncertainty::Distribution::MultiNomial *) x));
14400
}
14401
static void *_p_OpenTURNS__Uncertainty__Distribution__UniformFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14402
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::UniformFactory *) x));
14403
}
14404
static void *_p_OpenTURNS__Uncertainty__Model__ConditionalRandomVectorTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14405
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::RandomVectorImplementation *) ((OpenTURNS::Uncertainty::Model::ConditionalRandomVector *) x));
14406
}
14407
static void *_p_OpenTURNS__Uncertainty__Distribution__FrankCopulaTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14408
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *)(OpenTURNS::Uncertainty::Model::ArchimedeanCopula *) ((OpenTURNS::Uncertainty::Distribution::FrankCopula *) x));
14409
}
14410
static void *_p_OpenTURNS__Uncertainty__Model__UsualRandomVectorTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14411
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::RandomVectorImplementation *) ((OpenTURNS::Uncertainty::Model::UsualRandomVector *) x));
14412
}
14413
static void *_p_OpenTURNS__Uncertainty__Model__CompositeRandomVectorTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14414
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::RandomVectorImplementation *) ((OpenTURNS::Uncertainty::Model::CompositeRandomVector *) x));
14415
}
14416
static void *_p_OpenTURNS__Base__Type__IndicesTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14417
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::UnsignedLong > *) ((OpenTURNS::Base::Type::Indices *) x));
14418
}
14419
static void *_p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14420
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ConstantNumericalMathHessianImplementation *) x));
14421
}
14422
static void *_p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14423
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ComputedNumericalMathHessianImplementation *) x));
14424
}
14425
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14426
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathHessianImplementation *) x));
14427
}
14428
static void *_p_OpenTURNS__Uncertainty__Model__CopulaImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14429
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *) ((OpenTURNS::Uncertainty::Model::CopulaImplementation *) x));
14430
}
14431
static void *_p_OT__Base__Optim__SQPSpecificParametersTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14432
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::SQPSpecificParameters *) x));
14433
}
14434
static void *_p_OT__Base__Optim__TNCSpecificParametersTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14435
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::TNCSpecificParameters *) x));
14436
}
14437
static void *_p_OT__Base__Optim__CobylaSpecificParametersTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14438
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::CobylaSpecificParameters *) x));
14439
}
14440
static void *_p_OpenTURNS__Uncertainty__Distribution__RayleighFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14441
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::RayleighFactory *) x));
14442
}
14443
static void *_p_OpenTURNS__Uncertainty__Distribution__FrankCopulaFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14444
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::FrankCopulaFactory *) x));
14445
}
14446
static void *_p_OpenTURNS__Uncertainty__Distribution__RandomMixtureTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14447
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *) ((OpenTURNS::Uncertainty::Distribution::RandomMixture *) x));
14448
}
14449
static void *_p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14450
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::LinearCombinationEvaluationImplementation *) x));
14451
}
14452
static void *_p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14453
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ProductPolynomialEvaluationImplementation *) x));
14454
}
14455
static void *_p_OpenTURNS__Uncertainty__Model__DiscreteDistributionTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14456
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *) ((OpenTURNS::Uncertainty::Model::DiscreteDistribution *) x));
14457
}
14458
static void *_p_OpenTURNS__Base__Solver__SecantTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14459
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Solver::SolverImplementation *) ((OpenTURNS::Base::Solver::Secant *) x));
14460
}
14461
static void *_p_OpenTURNS__Uncertainty__Distribution__TriangularTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14462
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Triangular *) x));
14463
}
14464
static void *_p_OpenTURNS__Uncertainty__Distribution__BetaTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14465
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Beta *) x));
14466
}
14467
static void *_p_OpenTURNS__Uncertainty__Distribution__NormalTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14468
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::EllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Normal *) x));
14469
}
14470
static void *_p_OpenTURNS__Uncertainty__Model__EventRandomVectorImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14471
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::RandomVectorImplementation *)(OpenTURNS::Uncertainty::Model::CompositeRandomVector *) ((OpenTURNS::Uncertainty::Model::EventRandomVectorImplementation *) x));
14472
}
14473
static void *_p_OpenTURNS__Uncertainty__Model__EllipticalDistributionTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14474
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *) ((OpenTURNS::Uncertainty::Model::EllipticalDistribution *) x));
14475
}
14476
static void *_p_OpenTURNS__Uncertainty__Model__ContinuousDistributionTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14477
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *) ((OpenTURNS::Uncertainty::Model::ContinuousDistribution *) x));
14478
}
14479
static void *_p_OpenTURNS__Base__Graph__ContourTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14480
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Graph::DrawableImplementation *) ((OpenTURNS::Base::Graph::Contour *) x));
14481
}
14482
static void *_p_OpenTURNS__Uncertainty__Distribution__LogisticFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14483
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::LogisticFactory *) x));
14484
}
14485
static void *_p_OpenTURNS__Base__Func__WrapperFileTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14486
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::WrapperFile *) x));
14487
}
14488
static void *_p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14489
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::NoNumericalMathEvaluationImplementation *) x));
14490
}
14491
static void *_p_OpenTURNS__Uncertainty__Distribution__NonCentralStudentTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14492
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::NonCentralStudent *) x));
14493
}
14494
static void *_p_OpenTURNS__Uncertainty__Distribution__GammaFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14495
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::GammaFactory *) x));
14496
}
14497
static void *_p_OpenTURNS__Uncertainty__Distribution__BetaFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14498
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::BetaFactory *) x));
14499
}
14500
static void *_p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14501
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::LinearNumericalMathGradientImplementation *) x));
14502
}
14503
static void *_p_OpenTURNS__Base__Common__EqualTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14504
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::Equal *) x));
14505
}
14506
static void *_p_OpenTURNS__Base__Stat__LastTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14507
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Last *) x));
14508
}
14509
static void *_p_OpenTURNS__Base__Common__GreaterTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14510
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::Greater *) x));
14511
}
14512
static void *_p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14513
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) x));
14514
}
14515
static void *_p_OpenTURNS__Base__Stat__FullTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14516
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Full *) x));
14517
}
14518
static void *_p_OpenTURNS__Base__Type__NumericalPointTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14519
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::NumericalScalar > *) ((OpenTURNS::Base::Type::NumericalPoint *) x));
14520
}
14521
static void *_p_OpenTURNS__Uncertainty__Distribution__ChiSquareFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14522
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::ChiSquareFactory *) x));
14523
}
14524
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14525
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathGradientImplementation *) x));
14526
}
14527
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathFunctionTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14528
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathFunctionImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathFunction *) x));
14529
}
14530
static void *_p_OpenTURNS__Uncertainty__Distribution__LogNormalTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14531
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::LogNormal *) x));
14532
}
14533
static void *_p_OpenTURNS__Base__Graph__CloudTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14534
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Graph::DrawableImplementation *) ((OpenTURNS::Base::Graph::Cloud *) x));
14535
}
14536
static void *_p_OpenTURNS__Uncertainty__Distribution__PoissonFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14537
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::PoissonFactory *) x));
14538
}
14539
static void *_p_OpenTURNS__Uncertainty__Distribution__PoissonTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14540
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::DiscreteDistribution *) ((OpenTURNS::Uncertainty::Distribution::Poisson *) x));
14541
}
14542
static void *_p_OT__Base__Optim__AbdoRackwitzSpecificParametersTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14543
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::AbdoRackwitzSpecificParameters *) x));
14544
}
14545
static void *_p_OpenTURNS__Uncertainty__Distribution__ExponentialFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14546
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::ExponentialFactory *) x));
14547
}
14548
static void *_p_OpenTURNS__Uncertainty__Distribution__ChiSquareTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14549
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::ChiSquare *) x));
14550
}
14551
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_tTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14552
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< std::string > *) x));
14553
}
14554
static void *_p_OpenTURNS__Base__Optim__SQPTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14555
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Optim::NearestPointAlgorithmImplementation *) ((OpenTURNS::Base::Optim::SQP *) x));
14556
}
14557
static void *_p_OpenTURNS__Uncertainty__Distribution__RayleighTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14558
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Rayleigh *) x));
14559
}
14560
static void *_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessianTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14561
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) x));
14562
}
14563
static void *_p_OpenTURNS__Base__Solver__BisectionTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14564
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Solver::SolverImplementation *) ((OpenTURNS::Base::Solver::Bisection *) x));
14565
}
14566
static void *_p_OpenTURNS__Base__Common__LessTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14567
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::Less *) x));
14568
}
14569
static void *_p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResultTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14570
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::CorrelationAnalysisSobolIndiceResult *) x));
14571
}
14572
static void *_p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParametersTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14573
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::CorrelationAnalysisSobolIndiceParameters *) x));
14574
}
14575
static void *_p_OpenTURNS__Base__Graph__BarPlotTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14576
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Graph::DrawableImplementation *) ((OpenTURNS::Base::Graph::BarPlot *) x));
14577
}
14578
static void *_p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14579
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ComputedNumericalMathEvaluationImplementation *) x));
14580
}
14581
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14582
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathEvaluationImplementation *) x));
14583
}
14584
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_double_tTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14585
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< double > *) x));
14586
}
14587
static void *_p_OT__Base__Optim__NearestPointAlgorithmImplementation__ResultTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14588
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::NearestPointAlgorithmImplementationResult *) x));
14589
}
14590
static void *_p_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14591
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::NearestPointAlgorithmImplementation *) x));
14592
}
14593
static void *_p_OpenTURNS__Base__Solver__BrentTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14594
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Solver::SolverImplementation *) ((OpenTURNS::Base::Solver::Brent *) x));
14595
}
14596
static void *_p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14597
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::TruncatedNormalFactory *) x));
14598
}
14599
static void *_p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14600
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::TruncatedNormal *) x));
14601
}
14602
static void *_p_OpenTURNS__Uncertainty__Distribution__TruncatedDistributionTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14603
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::TruncatedDistribution *) x));
14604
}
14605
static void *_p_OpenTURNS__Uncertainty__Distribution__StudentTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14606
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::EllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Student *) x));
14607
}
14608
static void *_p_OpenTURNS__Uncertainty__Distribution__NormalFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14609
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::NormalFactory *) x));
14610
}
14611
static void *_p_OpenTURNS__Uncertainty__Distribution__GumbelFactoryTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14612
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::GumbelFactory *) x));
14613
}
14614
static void *_p_OpenTURNS__Uncertainty__Distribution__KernelSmoothingTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14615
return (void *)((OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Uncertainty::Distribution::KernelSmoothing *) x));
14616
}
14617
static void *_p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14618
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::LinearNumericalMathEvaluationImplementation *) x));
14619
}
14620
static void *_p_OpenTURNS__Base__Graph__PieTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14621
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Graph::DrawableImplementation *) ((OpenTURNS::Base::Graph::Pie *) x));
14622
}
14623
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14624
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathHessianImplementation *) x));
14625
}
14626
static void *_p_OpenTURNS__Base__Func__LinearCombinationHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14627
return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::LinearCombinationHessianImplementation *) x));
14628
}
14629
static void *_p_OpenTURNS__Uncertainty__Model__NonEllipticalDistributionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14630
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *) ((OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) x));
14631
}
14632
static void *_p_OT__Base__Optim__NearestPointChecker__ResultTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14633
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::NearestPointCheckerResult *) x));
14634
}
14635
static void *_p_OpenTURNS__Base__Stat__TestResultTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14636
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::TestResult *) x));
14637
}
14638
static void *_p_OpenTURNS__Uncertainty__Model__EventTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14639
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Uncertainty::Model::RandomVectorImplementation > *)(OpenTURNS::Uncertainty::Model::RandomVector *) ((OpenTURNS::Uncertainty::Model::Event *) x));
14640
}
14641
static void *_p_OpenTURNS__Uncertainty__Distribution__WeibullTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14642
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Weibull *) x));
14643
}
14644
static void *_p_OpenTURNS__Base__Type__IntervalTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14645
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::Interval *) x));
14646
}
14647
static void *_p_OpenTURNS__Base__Stat__ConfidenceIntervalTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14648
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::ConfidenceInterval *) x));
14649
}
14650
static void *_p_OpenTURNS__Base__Stat__LowDiscrepancySequenceTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14651
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation > *) ((OpenTURNS::Base::Stat::LowDiscrepancySequence *) x));
14652
}
14653
static void *_p_OpenTURNS__Base__Stat__SobolSequenceTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14654
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation *) ((OpenTURNS::Base::Stat::SobolSequence *) x));
14655
}
14656
static void *_p_OpenTURNS__Base__Stat__HaltonSequenceTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14657
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation *) ((OpenTURNS::Base::Stat::HaltonSequence *) x));
14658
}
14659
static void *_p_OpenTURNS__Base__Graph__GraphTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14660
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Graph::GraphImplementation > *) ((OpenTURNS::Base::Graph::Graph *) x));
14661
}
14662
static void *_p_OpenTURNS__Base__Func__WrapperDataFileTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14663
return (void *)((OpenTURNS::Base::Common::Object *) ((OpenTURNS::Base::Func::WrapperDataFile *) x));
14664
}
14665
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14666
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Func::UniVariatePolynomial > *) x));
14667
}
14668
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14669
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Type::NumericalPointWithDescription > *) x));
14670
}
14671
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14672
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Type::NumericalPoint > *) x));
14673
}
14674
static void *_p_OpenTURNS__Uncertainty__Distribution__UserDefinedTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14675
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::DiscreteDistribution *) ((OpenTURNS::Uncertainty::Distribution::UserDefined *) x));
14676
}
14677
static void *_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14678
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) x));
14679
}
14680
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathFunctionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14681
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathFunctionImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathFunction *) x));
14682
}
14683
static void *_p_OpenTURNS__Base__Stat__NullTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14684
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Null *) x));
14685
}
14686
static void *_p_OpenTURNS__Uncertainty__Distribution__GeometricFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14687
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::GeometricFactory *) x));
14688
}
14689
static void *_p_OpenTURNS__Base__Optim__AbdoRackwitzTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14690
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Optim::NearestPointAlgorithmImplementation *) ((OpenTURNS::Base::Optim::AbdoRackwitz *) x));
14691
}
14692
static void *_p_OpenTURNS__Uncertainty__Distribution__MixtureTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14693
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *) ((OpenTURNS::Uncertainty::Distribution::Mixture *) x));
14694
}
14695
static void *_p_OpenTURNS__Uncertainty__Distribution__ExponentialTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14696
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Exponential *) x));
14697
}
14698
static void *_p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14699
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::IndicatorNumericalMathEvaluationImplementation *) x));
14700
}
14701
static void *_p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14702
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::QuadraticNumericalMathEvaluationImplementation *) x));
14703
}
14704
static void *_p_OpenTURNS__Base__Stat__LinearModelTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14705
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::LinearModel *) x));
14706
}
14707
static void *_p_OpenTURNS__Base__Func__LinearCombinationGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14708
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::LinearCombinationGradientImplementation *) x));
14709
}
14710
static void *_p_OpenTURNS__Base__Func__NumericalMathFunctionImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14711
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::NumericalMathFunctionImplementation *) x));
14712
}
14713
static void *_p_OpenTURNS__Base__Func__NumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14714
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::NumericalMathGradientImplementation *) x));
14715
}
14716
static void *_p_OpenTURNS__Base__Optim__NearestPointAlgorithmTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14717
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Optim::NearestPointAlgorithmImplementation > *) ((OpenTURNS::Base::Optim::NearestPointAlgorithm *) x));
14718
}
14719
static void *_p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14720
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Optim::BoundConstrainedAlgorithmImplementation > *) ((OpenTURNS::Base::Optim::BoundConstrainedAlgorithm *) x));
14721
}
14722
static void *_p_OpenTURNS__Base__Stat__CompactTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14723
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Compact *) x));
14724
}
14725
static void *_p_OpenTURNS__Uncertainty__Model__DistributionImplementationFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14726
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) x));
14727
}
14728
static void *_p_OpenTURNS__Uncertainty__Model__DistributionImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14729
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Uncertainty::Model::DistributionImplementation *) x));
14730
}
14731
static void *_p_OpenTURNS__Base__Func__UniVariatePolynomialImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14732
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::UniVariatePolynomialImplementation *) x));
14733
}
14734
static void *_p_OpenTURNS__Base__Func__NumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14735
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::NumericalMathHessianImplementation *) x));
14736
}
14737
static void *_p_OpenTURNS__Base__Common__ComparisonOperatorImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14738
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Common::ComparisonOperatorImplementation *) x));
14739
}
14740
static void *_p_OpenTURNS__Uncertainty__Model__RandomVectorImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14741
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Uncertainty::Model::RandomVectorImplementation *) x));
14742
}
14743
static void *_p_OpenTURNS__Uncertainty__Distribution__TriangularFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14744
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::TriangularFactory *) x));
14745
}
14746
static void *_p_OpenTURNS__Uncertainty__Distribution__LaplaceFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14747
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::LaplaceFactory *) x));
14748
}
14749
static void *_p_OpenTURNS__Base__Optim__CobylaTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14750
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Optim::NearestPointAlgorithmImplementation *) ((OpenTURNS::Base::Optim::Cobyla *) x));
14751
}
14752
static void *_p_OpenTURNS__Base__Graph__CurveTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14753
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Graph::DrawableImplementation *) ((OpenTURNS::Base::Graph::Curve *) x));
14754
}
14755
static void *_p_OpenTURNS__Uncertainty__Distribution__WeibullFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14756
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::WeibullFactory *) x));
14757
}
14758
static void *_p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14759
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *)(OpenTURNS::Uncertainty::Model::ArchimedeanCopula *) ((OpenTURNS::Uncertainty::Distribution::ClaytonCopula *) x));
14760
}
14761
static void *_p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14762
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::ClaytonCopulaFactory *) x));
14763
}
14764
static void *_p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14765
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::NoNumericalMathHessianImplementation *) x));
14766
}
14767
static void *_p_OpenTURNS__Base__Optim__NearestPointCheckerTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14768
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::NearestPointChecker *) x));
14769
}
14770
static void *_p_OpenTURNS__Uncertainty__Distribution__EpanechnikovTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14771
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Epanechnikov *) x));
14772
}
14773
static void *_p_OpenTURNS__Base__Graph__StaircaseTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14774
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Graph::DrawableImplementation *) ((OpenTURNS::Base::Graph::Staircase *) x));
14775
}
14776
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14777
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathGradientImplementation *) x));
14778
}
14779
static void *_p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14780
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ComputedNumericalMathGradientImplementation *) x));
14781
}
14782
static void *_p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14783
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ConstantNumericalMathGradientImplementation *) x));
14784
}
14785
static void *_p_OpenTURNS__Uncertainty__Distribution__GumbelTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14786
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Gumbel *) x));
14787
}
14788
static void *_p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14789
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::BoundConstrainedAlgorithmImplementation *) x));
14790
}
14791
static void *_p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationResultTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14792
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::BoundConstrainedAlgorithmImplementationResult *) x));
14793
}
14794
static void *_p_OpenTURNS__Uncertainty__Distribution__HistogramTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14795
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Histogram *) x));
14796
}
14797
static void *_p_OpenTURNS__Uncertainty__Distribution__ComposedDistributionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14798
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *) ((OpenTURNS::Uncertainty::Distribution::ComposedDistribution *) x));
14799
}
14800
static void *_p_OpenTURNS__Uncertainty__Distribution__IndependentCopulaTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14801
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *) ((OpenTURNS::Uncertainty::Distribution::IndependentCopula *) x));
14802
}
14803
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14804
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Uncertainty::Model::DistributionImplementationFactory > *) x));
14805
}
14806
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14807
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Uncertainty::Model::DistributionImplementation > *) x));
14808
}
14809
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Solver__SolverImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14810
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Solver::SolverImplementation > *) x));
14811
}
14812
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14813
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Optim::NearestPointAlgorithmImplementation > *) x));
14814
}
14815
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14816
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Optim::BoundConstrainedAlgorithmImplementation > *) x));
14817
}
14818
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__UniVariatePolynomialImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14819
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Func::UniVariatePolynomialImplementation > *) x));
14820
}
14821
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__NumericalMathFunctionImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14822
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Func::NumericalMathFunctionImplementation > *) x));
14823
}
14824
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14825
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::DescriptionImplementation > *) x));
14826
}
14827
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Common__ComparisonOperatorImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14828
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Common::ComparisonOperatorImplementation > *) x));
14829
}
14830
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__MatrixImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14831
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::MatrixImplementation > *) x));
14832
}
14833
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__TensorImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14834
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::TensorImplementation > *) x));
14835
}
14836
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14837
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Stat::NumericalSampleImplementation > *) x));
14838
}
14839
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__HistoryStrategyImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14840
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Stat::HistoryStrategyImplementation > *) x));
14841
}
14842
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14843
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation > *) x));
14844
}
14845
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__DrawableImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14846
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Graph::DrawableImplementation > *) x));
14847
}
14848
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__GraphImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14849
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Graph::GraphImplementation > *) x));
14850
}
14851
static void *_p_OpenTURNS__Base__Solver__SolverImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14852
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Solver::SolverImplementation *) x));
14853
}
14854
static void *_p_OpenTURNS__Base__Type__DescriptionImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14855
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::String > *) ((OpenTURNS::Base::Type::DescriptionImplementation *) x));
14856
}
14857
static void *_p_OpenTURNS__Base__Type__MatrixImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14858
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::NumericalScalar > *) ((OpenTURNS::Base::Type::MatrixImplementation *) x));
14859
}
14860
static void *_p_OpenTURNS__Base__Type__TensorImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14861
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::NumericalScalar > *) ((OpenTURNS::Base::Type::TensorImplementation *) x));
14862
}
14863
static void *_p_OpenTURNS__Base__Graph__DrawableImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14864
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Graph::DrawableImplementation *) x));
14865
}
14866
static void *_p_OpenTURNS__Base__Graph__GraphImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14867
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Graph::GraphImplementation *) x));
14868
}
14869
static void *_p_OpenTURNS__Uncertainty__Distribution__LaplaceTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14870
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Laplace *) x));
14871
}
14872
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__RandomVectorImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14873
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Uncertainty::Model::RandomVectorImplementation > *) x));
14874
}
14875
static void *_p_OpenTURNS__Uncertainty__Model__ConstantRandomVectorTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14876
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::RandomVectorImplementation *) ((OpenTURNS::Uncertainty::Model::ConstantRandomVector *) x));
14877
}
14878
static void *_p_OpenTURNS__Base__Func__WrapperFrameworkDataTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14879
return (void *)((OpenTURNS::Base::Common::Object *) ((OpenTURNS::Base::Func::WrapperFrameworkData *) x));
14880
}
14881
static void *_p_OpenTURNS__Base__Common__PersistentObjectTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14882
return (void *)((OpenTURNS::Base::Common::Object *) ((OpenTURNS::Base::Common::PersistentObject *) x));
14883
}
14884
static void *_p_OpenTURNS__Base__Common__StudyTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14885
return (void *)((OpenTURNS::Base::Common::Object *) ((OpenTURNS::Base::Common::Study *) x));
14886
}
14887
static void *_p_OpenTURNS__Uncertainty__Distribution__GammaTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14888
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Gamma *) x));
14889
}
14890
static void *_p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14891
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::NoNumericalMathGradientImplementation *) x));
14892
}
14893
static void *_p_OpenTURNS__Uncertainty__Distribution__ComposedCopulaTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14894
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *) ((OpenTURNS::Uncertainty::Distribution::ComposedCopula *) x));
14895
}
14896
static void *_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14897
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) x));
14898
}
14899
static void *_p_OpenTURNS__Base__Common__ComparisonOperatorTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14900
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Common::ComparisonOperatorImplementation > *) ((OpenTURNS::Base::Common::ComparisonOperator *) x));
14901
}
14902
static void *_p_OpenTURNS__Base__Common__GreaterOrEqualTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14903
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::GreaterOrEqual *) x));
14904
}
14905
static void *_p_OpenTURNS__Base__Common__LessOrEqualTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14906
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::LessOrEqual *) x));
14907
}
14908
static void *_p_OpenTURNS__Uncertainty__Model__UsualDistributionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14909
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *) ((OpenTURNS::Uncertainty::Model::UsualDistribution *) x));
14910
}
14911
static void *_p_OpenTURNS__Uncertainty__Model__DistributionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14912
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Uncertainty::Model::DistributionImplementation > *) ((OpenTURNS::Uncertainty::Model::Distribution *) x));
14913
}
14914
static void *_p_OpenTURNS__Uncertainty__Distribution__UniformTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14915
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Uniform *) x));
14916
}
14917
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14918
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathEvaluationImplementation *) x));
14919
}
14920
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14921
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< unsigned long > *) x));
14922
}
14923
static void *_p_OpenTURNS__Uncertainty__Distribution__HistogramFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14924
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::HistogramFactory *) x));
14925
}
14926
static void *_p_OpenTURNS__Base__Stat__NumericalSampleImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14927
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Type::NumericalPoint > *) ((OpenTURNS::Base::Stat::NumericalSampleImplementation *) x));
14928
}
14929
static void *_p_OpenTURNS__Base__Stat__HistoryStrategyImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14930
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::HistoryStrategyImplementation *) x));
14931
}
14932
static void *_p_OpenTURNS__Base__Type__NumericalPointWithDescriptionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14933
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::NumericalScalar > *)(OpenTURNS::Base::Type::NumericalPoint *) ((OpenTURNS::Base::Type::NumericalPointWithDescription *) x));
14934
}
14935
static void *_p_OpenTURNS__Base__Func__UniVariatePolynomialTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14936
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Func::UniVariatePolynomialImplementation > *) ((OpenTURNS::Base::Func::UniVariatePolynomial *) x));
14937
}
14938
static void *_p_OpenTURNS__Base__Common__InterfaceObjectTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14939
return (void *)((OpenTURNS::Base::Common::Object *) ((OpenTURNS::Base::Common::InterfaceObject *) x));
14940
}
14941
static void *_p_OpenTURNS__Uncertainty__Distribution__LogNormalFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14942
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::LogNormalFactory *) x));
14943
}
14944
static void *_p_OpenTURNS__Uncertainty__Distribution__LogisticTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14945
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Logistic *) x));
14946
}
14947
static void *_p_OpenTURNS__Uncertainty__Distribution__GeometricTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14948
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::DiscreteDistribution *) ((OpenTURNS::Uncertainty::Distribution::Geometric *) x));
14949
}
14950
static void *_p_OpenTURNS__Uncertainty__Model__SklarCopulaTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14951
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *) ((OpenTURNS::Uncertainty::Model::SklarCopula *) x));
14952
}
14953
static void *_p_OpenTURNS__Uncertainty__Model__ArchimedeanCopulaTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14954
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *) ((OpenTURNS::Uncertainty::Model::ArchimedeanCopula *) x));
14955
}
14956
static void *_p_OpenTURNS__Uncertainty__Model__CopulaTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14957
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Uncertainty::Model::DistributionImplementation > *)(OpenTURNS::Uncertainty::Model::Distribution *) ((OpenTURNS::Uncertainty::Model::Copula *) x));
14958
}
14959
static void *_p_OpenTURNS__Uncertainty__Distribution__NormalCopulaTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14960
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *) ((OpenTURNS::Uncertainty::Distribution::NormalCopula *) x));
14961
}
14962
static void *_p_OpenTURNS__Uncertainty__Distribution__NormalCopulaFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14963
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::NormalCopulaFactory *) x));
14964
}
14965
static void *_p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14966
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *)(OpenTURNS::Uncertainty::Model::ArchimedeanCopula *) ((OpenTURNS::Uncertainty::Distribution::GumbelCopula *) x));
14967
}
14968
static void *_p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14969
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::GumbelCopulaFactory *) x));
14970
}
14971
static void *_p_OpenTURNS__Base__Type__DescriptionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14972
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::DescriptionImplementation > *)(OpenTURNS::Base::Common::TypedCollectionInterfaceObject< OpenTURNS::Base::Type::DescriptionImplementation > *) ((OpenTURNS::Base::Type::Description *) x));
14973
}
14974
static void *_p_OpenTURNS__Base__Func__WrapperFunctionDescriptionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14975
return (void *)((OpenTURNS::Base::Common::Object *) ((OpenTURNS::Base::Func::WrapperFunctionDescription *) x));
14976
}
14977
static void *_p_OpenTURNS__Uncertainty__Distribution__StudentFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14978
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::StudentFactory *) x));
14979
}
14980
static void *_p_OpenTURNS__Uncertainty__Distribution__UserDefinedFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14981
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::UserDefinedFactory *) x));
14982
}
14983
static void *_p_OpenTURNS__Base__Optim__PenalizedLeastSquaresAlgorithmTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14984
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::PenalizedLeastSquaresAlgorithm *) x));
14985
}
14986
static void *_p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14987
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation *) x));
14988
}
14989
static void *_p_OpenTURNS__Base__Optim__TNCTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14990
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Optim::BoundConstrainedAlgorithmImplementation *) ((OpenTURNS::Base::Optim::TNC *) x));
14991
}
14992
static void *_p_OpenTURNS__Uncertainty__Distribution__KernelMixtureTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14993
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::KernelMixture *) x));
14994
}
14995
static void *_p_OpenTURNS__Uncertainty__Distribution__MultiNomialFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14996
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::MultiNomialFactory *) x));
14997
}
14998
static void *_p_OpenTURNS__Uncertainty__Distribution__MultiNomialTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
14999
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::DiscreteDistribution *) ((OpenTURNS::Uncertainty::Distribution::MultiNomial *) x));
15000
}
15001
static void *_p_OpenTURNS__Uncertainty__Distribution__UniformFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15002
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::UniformFactory *) x));
15003
}
15004
static void *_p_OpenTURNS__Uncertainty__Model__ConditionalRandomVectorTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15005
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::RandomVectorImplementation *) ((OpenTURNS::Uncertainty::Model::ConditionalRandomVector *) x));
15006
}
15007
static void *_p_OpenTURNS__Base__Func__LinearNumericalMathFunctionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15008
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Func::NumericalMathFunctionImplementation > *)(OpenTURNS::Base::Func::NumericalMathFunction *) ((OpenTURNS::Base::Func::LinearNumericalMathFunction *) x));
15009
}
15010
static void *_p_OpenTURNS__Base__Func__NumericalMathFunctionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15011
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Func::NumericalMathFunctionImplementation > *) ((OpenTURNS::Base::Func::NumericalMathFunction *) x));
15012
}
15013
static void *_p_OpenTURNS__Uncertainty__Distribution__FrankCopulaTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15014
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::CopulaImplementation *)(OpenTURNS::Uncertainty::Model::ArchimedeanCopula *) ((OpenTURNS::Uncertainty::Distribution::FrankCopula *) x));
15015
}
15016
static void *_p_OpenTURNS__Uncertainty__Model__UsualRandomVectorTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15017
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::RandomVectorImplementation *) ((OpenTURNS::Uncertainty::Model::UsualRandomVector *) x));
15018
}
15019
static void *_p_OpenTURNS__Uncertainty__Model__RandomVectorTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15020
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Uncertainty::Model::RandomVectorImplementation > *) ((OpenTURNS::Uncertainty::Model::RandomVector *) x));
15021
}
15022
static void *_p_OpenTURNS__Uncertainty__Model__CompositeRandomVectorTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15023
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::RandomVectorImplementation *) ((OpenTURNS::Uncertainty::Model::CompositeRandomVector *) x));
15024
}
15025
static void *_p_OpenTURNS__Base__Type__IndicesTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15026
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::UnsignedLong > *) ((OpenTURNS::Base::Type::Indices *) x));
15027
}
15028
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15029
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathHessianImplementation *) x));
15030
}
15031
static void *_p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15032
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ComputedNumericalMathHessianImplementation *) x));
15033
}
15034
static void *_p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15035
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ConstantNumericalMathHessianImplementation *) x));
15036
}
15037
static void *_p_OpenTURNS__Uncertainty__Model__CopulaImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15038
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *) ((OpenTURNS::Uncertainty::Model::CopulaImplementation *) x));
15039
}
15040
static void *_p_OT__Base__Optim__SQPSpecificParametersTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15041
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::SQPSpecificParameters *) x));
15042
}
15043
static void *_p_OT__Base__Optim__TNCSpecificParametersTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15044
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::TNCSpecificParameters *) x));
15045
}
15046
static void *_p_OT__Base__Optim__CobylaSpecificParametersTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15047
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::CobylaSpecificParameters *) x));
15048
}
15049
static void *_p_OpenTURNS__Uncertainty__Distribution__RayleighFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15050
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::RayleighFactory *) x));
15051
}
15052
static void *_p_OpenTURNS__Base__Type__MatrixTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15053
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::MatrixImplementation > *) ((OpenTURNS::Base::Type::Matrix *) x));
15054
}
15055
static void *_p_OpenTURNS__Base__Stat__CorrelationMatrixTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15056
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::MatrixImplementation > *)(OpenTURNS::Base::Type::Matrix *)(OpenTURNS::Base::Type::SquareMatrix *)(OpenTURNS::Base::Type::SymmetricMatrix *)(OpenTURNS::Base::Stat::CovarianceMatrix *) ((OpenTURNS::Base::Stat::CorrelationMatrix *) x));
15057
}
15058
static void *_p_OpenTURNS__Uncertainty__Distribution__FrankCopulaFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15059
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::FrankCopulaFactory *) x));
15060
}
15061
static void *_p_OpenTURNS__Uncertainty__Distribution__RandomMixtureTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15062
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *) ((OpenTURNS::Uncertainty::Distribution::RandomMixture *) x));
15063
}
15064
static void *_p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15065
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ProductPolynomialEvaluationImplementation *) x));
15066
}
15067
static void *_p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15068
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::LinearCombinationEvaluationImplementation *) x));
15069
}
15070
static void *_p_OpenTURNS__Uncertainty__Model__DiscreteDistributionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15071
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *) ((OpenTURNS::Uncertainty::Model::DiscreteDistribution *) x));
15072
}
15073
static void *_p_OpenTURNS__Base__Solver__SecantTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15074
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Solver::SolverImplementation *) ((OpenTURNS::Base::Solver::Secant *) x));
15075
}
15076
static void *_p_OpenTURNS__Uncertainty__Distribution__BetaTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15077
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Beta *) x));
15078
}
15079
static void *_p_OpenTURNS__Uncertainty__Distribution__TriangularTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15080
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Triangular *) x));
15081
}
15082
static void *_p_OpenTURNS__Uncertainty__Distribution__NormalTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15083
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::EllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Normal *) x));
15084
}
15085
static void *_p_OpenTURNS__Uncertainty__Model__EventRandomVectorImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15086
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::RandomVectorImplementation *)(OpenTURNS::Uncertainty::Model::CompositeRandomVector *) ((OpenTURNS::Uncertainty::Model::EventRandomVectorImplementation *) x));
15087
}
15088
static void *_p_OpenTURNS__Base__Type__TensorTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15089
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::TensorImplementation > *) ((OpenTURNS::Base::Type::Tensor *) x));
15090
}
15091
static void *_p_OpenTURNS__Uncertainty__Model__EllipticalDistributionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15092
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *) ((OpenTURNS::Uncertainty::Model::EllipticalDistribution *) x));
15093
}
15094
static void *_p_OpenTURNS__Uncertainty__Model__ContinuousDistributionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15095
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *) ((OpenTURNS::Uncertainty::Model::ContinuousDistribution *) x));
15096
}
15097
static void *_p_OpenTURNS__Base__Graph__ContourTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15098
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Graph::DrawableImplementation *) ((OpenTURNS::Base::Graph::Contour *) x));
15099
}
15100
static void *_p_OpenTURNS__Uncertainty__Distribution__LogisticFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15101
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::LogisticFactory *) x));
15102
}
15103
static void *_p_OpenTURNS__Base__Func__WrapperFileTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15104
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::WrapperFile *) x));
15105
}
15106
static void *_p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15107
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::NoNumericalMathEvaluationImplementation *) x));
15108
}
15109
static void *_p_OpenTURNS__Uncertainty__Distribution__NonCentralStudentTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15110
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::NonCentralStudent *) x));
15111
}
15112
static void *_p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15113
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::DescriptionImplementation > *) ((OpenTURNS::Base::Common::TypedCollectionInterfaceObject< OpenTURNS::Base::Type::DescriptionImplementation > *) x));
15114
}
15115
static void *_p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15116
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Stat::NumericalSampleImplementation > *) ((OpenTURNS::Base::Common::TypedCollectionInterfaceObject< OpenTURNS::Base::Stat::NumericalSampleImplementation > *) x));
15117
}
15118
static void *_p_OpenTURNS__Uncertainty__Distribution__BetaFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15119
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::BetaFactory *) x));
15120
}
15121
static void *_p_OpenTURNS__Uncertainty__Model__DistributionFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15122
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Uncertainty::Model::DistributionImplementationFactory > *) ((OpenTURNS::Uncertainty::Model::DistributionFactory *) x));
15123
}
15124
static void *_p_OpenTURNS__Uncertainty__Distribution__GammaFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15125
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::GammaFactory *) x));
15126
}
15127
static void *_p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15128
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::LinearNumericalMathGradientImplementation *) x));
15129
}
15130
static void *_p_OpenTURNS__Base__Common__EqualTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15131
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::Equal *) x));
15132
}
15133
static void *_p_OpenTURNS__Base__Stat__LastTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15134
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Last *) x));
15135
}
15136
static void *_p_OpenTURNS__Base__Common__GreaterTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15137
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::Greater *) x));
15138
}
15139
static void *_p_OpenTURNS__Base__Type__SquareMatrixTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15140
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::MatrixImplementation > *)(OpenTURNS::Base::Type::Matrix *) ((OpenTURNS::Base::Type::SquareMatrix *) x));
15141
}
15142
static void *_p_OpenTURNS__Base__Type__SymmetricMatrixTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15143
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::MatrixImplementation > *)(OpenTURNS::Base::Type::Matrix *)(OpenTURNS::Base::Type::SquareMatrix *) ((OpenTURNS::Base::Type::SymmetricMatrix *) x));
15144
}
15145
static void *_p_OpenTURNS__Base__Stat__CovarianceMatrixTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15146
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::MatrixImplementation > *)(OpenTURNS::Base::Type::Matrix *)(OpenTURNS::Base::Type::SquareMatrix *)(OpenTURNS::Base::Type::SymmetricMatrix *) ((OpenTURNS::Base::Stat::CovarianceMatrix *) x));
15147
}
15148
static void *_p_OpenTURNS__Base__Type__IdentityMatrixTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15149
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::MatrixImplementation > *)(OpenTURNS::Base::Type::Matrix *)(OpenTURNS::Base::Type::SquareMatrix *)(OpenTURNS::Base::Type::SymmetricMatrix *)(OpenTURNS::Base::Stat::CovarianceMatrix *)(OpenTURNS::Base::Stat::CorrelationMatrix *) ((OpenTURNS::Base::Type::IdentityMatrix *) x));
15150
}
15151
static void *_p_OpenTURNS__Base__Stat__HistoryStrategyTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15152
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Stat::HistoryStrategyImplementation > *) ((OpenTURNS::Base::Stat::HistoryStrategy *) x));
15153
}
15154
static void *_p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15155
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) x));
15156
}
15157
static void *_p_OpenTURNS__Base__Stat__NumericalSampleTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15158
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Stat::NumericalSampleImplementation > *)(OpenTURNS::Base::Common::TypedCollectionInterfaceObject< OpenTURNS::Base::Stat::NumericalSampleImplementation > *) ((OpenTURNS::Base::Stat::NumericalSample *) x));
15159
}
15160
static void *_p_OpenTURNS__Base__Stat__FullTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15161
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Full *) x));
15162
}
15163
static void *_p_OpenTURNS__Base__Type__NumericalPointTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15164
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::NumericalScalar > *) ((OpenTURNS::Base::Type::NumericalPoint *) x));
15165
}
15166
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15167
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathGradientImplementation *) x));
15168
}
15169
static void *_p_OpenTURNS__Uncertainty__Distribution__ChiSquareFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15170
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::ChiSquareFactory *) x));
15171
}
15172
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathFunctionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15173
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathFunctionImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathFunction *) x));
15174
}
15175
static void *_p_OpenTURNS__Base__Graph__DrawableTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15176
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Graph::DrawableImplementation > *) ((OpenTURNS::Base::Graph::Drawable *) x));
15177
}
15178
static void *_p_OpenTURNS__Base__Graph__CloudTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15179
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Graph::DrawableImplementation *) ((OpenTURNS::Base::Graph::Cloud *) x));
15180
}
15181
static void *_p_OpenTURNS__Uncertainty__Distribution__LogNormalTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15182
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::LogNormal *) x));
15183
}
15184
static void *_p_OpenTURNS__Base__Type__SymmetricTensorTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15185
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::TensorImplementation > *)(OpenTURNS::Base::Type::Tensor *) ((OpenTURNS::Base::Type::SymmetricTensor *) x));
15186
}
15187
static void *_p_OT__Base__Optim__AbdoRackwitzSpecificParametersTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15188
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::AbdoRackwitzSpecificParameters *) x));
15189
}
15190
static void *_p_OpenTURNS__Uncertainty__Distribution__PoissonTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15191
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::DiscreteDistribution *) ((OpenTURNS::Uncertainty::Distribution::Poisson *) x));
15192
}
15193
static void *_p_OpenTURNS__Uncertainty__Distribution__PoissonFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15194
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::PoissonFactory *) x));
15195
}
15196
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15197
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< std::string > *) x));
15198
}
15199
static void *_p_OpenTURNS__Uncertainty__Distribution__ChiSquareTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15200
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::ChiSquare *) x));
15201
}
15202
static void *_p_OpenTURNS__Uncertainty__Distribution__ExponentialFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15203
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::ExponentialFactory *) x));
15204
}
15205
static void *_p_OpenTURNS__Base__Optim__SQPTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15206
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Optim::NearestPointAlgorithmImplementation *) ((OpenTURNS::Base::Optim::SQP *) x));
15207
}
15208
static void *_p_OpenTURNS__Uncertainty__Distribution__RayleighTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15209
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Rayleigh *) x));
15210
}
15211
static void *_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessianTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15212
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) x));
15213
}
15214
static void *_p_OpenTURNS__Base__Solver__BisectionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15215
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Solver::SolverImplementation *) ((OpenTURNS::Base::Solver::Bisection *) x));
15216
}
15217
static void *_p_OpenTURNS__Base__Common__LessTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15218
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::Less *) x));
15219
}
15220
static void *_p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParametersTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15221
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::CorrelationAnalysisSobolIndiceParameters *) x));
15222
}
15223
static void *_p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResultTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15224
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::CorrelationAnalysisSobolIndiceResult *) x));
15225
}
15226
static void *_p_OpenTURNS__Base__Graph__BarPlotTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15227
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Graph::DrawableImplementation *) ((OpenTURNS::Base::Graph::BarPlot *) x));
15228
}
15229
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15230
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathEvaluationImplementation *) x));
15231
}
15232
static void *_p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15233
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ComputedNumericalMathEvaluationImplementation *) x));
15234
}
15235
static void *_p_OpenTURNS__Base__Solver__SolverTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15236
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Solver::SolverImplementation > *) ((OpenTURNS::Base::Solver::Solver *) x));
15237
}
15238
static void *_p_OpenTURNS__Base__Func__WrapperParameterTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15239
return (void *)((OpenTURNS::Base::Common::Object *) ((OpenTURNS::Base::Func::WrapperParameter *) x));
15240
}
15241
static void *_p_OpenTURNS__Base__Func__WrapperDataVariableTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15242
return (void *)((OpenTURNS::Base::Common::Object *) ((OpenTURNS::Base::Func::WrapperDataVariable *) x));
15243
}
15244
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_double_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15245
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< double > *) x));
15246
}
15247
static void *_p_OT__Base__Optim__NearestPointAlgorithmImplementation__ResultTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15248
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::NearestPointAlgorithmImplementationResult *) x));
15249
}
15250
static void *_p_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15251
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Optim::NearestPointAlgorithmImplementation *) x));
15252
}
15253
static void *_p_OpenTURNS__Base__Solver__BrentTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15254
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Solver::SolverImplementation *) ((OpenTURNS::Base::Solver::Brent *) x));
15255
}
15256
static void *_p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15257
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::TruncatedNormal *) x));
15258
}
15259
static void *_p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15260
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::TruncatedNormalFactory *) x));
15261
}
15262
static void *_p_OpenTURNS__Base__Func__WrapperDataTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15263
return (void *)((OpenTURNS::Base::Common::Object *) ((OpenTURNS::Base::Func::WrapperData *) x));
15264
}
15265
static void *_p_OpenTURNS__Uncertainty__Distribution__TruncatedDistributionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15266
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::NonEllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::TruncatedDistribution *) x));
15267
}
15268
static void *_p_OpenTURNS__Uncertainty__Distribution__GumbelFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15269
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::GumbelFactory *) x));
15270
}
15271
static void *_p_OpenTURNS__Uncertainty__Distribution__NormalFactoryTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15272
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementationFactory *) ((OpenTURNS::Uncertainty::Distribution::NormalFactory *) x));
15273
}
15274
static void *_p_OpenTURNS__Uncertainty__Distribution__StudentTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15275
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Uncertainty::Model::DistributionImplementation *)(OpenTURNS::Uncertainty::Model::UsualDistribution *)(OpenTURNS::Uncertainty::Model::ContinuousDistribution *)(OpenTURNS::Uncertainty::Model::EllipticalDistribution *) ((OpenTURNS::Uncertainty::Distribution::Student *) x));
15276
}
15277
static void *_p_OpenTURNS__Uncertainty__Distribution__KernelSmoothingTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15278
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Uncertainty::Distribution::KernelSmoothing *) x));
15279
}
15280
static void *_p_OpenTURNS__Base__Common__StorageManagerTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15281
return (void *)((OpenTURNS::Base::Common::Object *) ((OpenTURNS::Base::Common::StorageManager *) x));
15282
}
15283
static void *_p_OpenTURNS__Base__Common__XMLStorageManagerTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15284
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::StorageManager *) ((OpenTURNS::Base::Common::XMLStorageManager *) x));
15285
}
15286
static void *_p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15287
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::LinearNumericalMathEvaluationImplementation *) x));
15288
}
15289
static void *_p_OpenTURNS__Uncertainty__Model__StandardEventTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15290
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Uncertainty::Model::RandomVectorImplementation > *)(OpenTURNS::Uncertainty::Model::RandomVector *)(OpenTURNS::Uncertainty::Model::Event *) ((OpenTURNS::Uncertainty::Model::StandardEvent *) x));
15291
}
15292
static void *_p_OpenTURNS__Base__Graph__PieTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15293
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Graph::DrawableImplementation *) ((OpenTURNS::Base::Graph::Pie *) x));
15294
}
15295
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15296
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathHessianImplementation *) x));
15297
}
15298
static void *_p_OpenTURNS__Base__Func__LinearCombinationHessianImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15299
return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::LinearCombinationHessianImplementation *) x));
15300
}
15301
static void *_p_OpenTURNS__Uncertainty__Model__CopulaTo_p_OpenTURNS__Uncertainty__Model__Distribution(void *x, int *SWIGUNUSEDPARM(newmemory)) {
15302
return (void *)((OpenTURNS::Uncertainty::Model::Distribution *) ((OpenTURNS::Uncertainty::Model::Copula *) x));
15303
}
15304
static swig_type_info _swigt__p_Antecedent = {"_p_Antecedent", "Antecedent *", 0, 0, (void*)0, 0};
15305
static swig_type_info _swigt__p_ArchimedeanCopula = {"_p_ArchimedeanCopula", "ArchimedeanCopula *", 0, 0, (void*)0, 0};
15306
static swig_type_info _swigt__p_BoolCollection = {"_p_BoolCollection", "BoolCollection *", 0, 0, (void*)0, 0};
15307
static swig_type_info _swigt__p_BoolPersistentCollection = {"_p_BoolPersistentCollection", "BoolPersistentCollection *", 0, 0, (void*)0, 0};
15308
static swig_type_info _swigt__p_BoundingBox = {"_p_BoundingBox", "BoundingBox *", 0, 0, (void*)0, 0};
15309
static swig_type_info _swigt__p_CacheImplementation = {"_p_CacheImplementation", "CacheImplementation *", 0, 0, (void*)0, 0};
15310
static swig_type_info _swigt__p_CacheKeyType = {"_p_CacheKeyType", "CacheKeyType *", 0, 0, (void*)0, 0};
15311
static swig_type_info _swigt__p_CacheType = {"_p_CacheType", "CacheType *", 0, 0, (void*)0, 0};
15312
static swig_type_info _swigt__p_CacheValueType = {"_p_CacheValueType", "CacheValueType *", 0, 0, (void*)0, 0};
15313
static swig_type_info _swigt__p_Coefficients = {"_p_Coefficients", "Coefficients *", 0, 0, (void*)0, 0};
15314
static swig_type_info _swigt__p_ComparisonOperator = {"_p_ComparisonOperator", "ComparisonOperator *", 0, 0, (void*)0, 0};
15315
static swig_type_info _swigt__p_ConfidenceIntervalCollection = {"_p_ConfidenceIntervalCollection", "ConfidenceIntervalCollection *", 0, 0, (void*)0, 0};
15316
static swig_type_info _swigt__p_ConfidenceIntervalPersistentCollection = {"_p_ConfidenceIntervalPersistentCollection", "ConfidenceIntervalPersistentCollection *", 0, 0, (void*)0, 0};
15317
static swig_type_info _swigt__p_Copula = {"_p_Copula", "Copula *", 0, 0, (void*)0, 0};
15318
static swig_type_info _swigt__p_CopulaCollection = {"_p_CopulaCollection", "CopulaCollection *", 0, 0, (void*)0, 0};
15319
static swig_type_info _swigt__p_CopulaImplementation = {"_p_CopulaImplementation", "CopulaImplementation *", 0, 0, (void*)0, 0};
15320
static swig_type_info _swigt__p_CopulaPersistentCollection = {"_p_CopulaPersistentCollection", "CopulaPersistentCollection *", 0, 0, (void*)0, 0};
15321
static swig_type_info _swigt__p_CorrelationMatrix = {"_p_CorrelationMatrix", "CorrelationMatrix *", 0, 0, (void*)0, 0};
15322
static swig_type_info _swigt__p_CovarianceMatrix = {"_p_CovarianceMatrix", "CovarianceMatrix *", 0, 0, (void*)0, 0};
15323
static swig_type_info _swigt__p_Description = {"_p_Description", "Description *", 0, 0, (void*)0, 0};
15324
static swig_type_info _swigt__p_DirectoryList = {"_p_DirectoryList", "DirectoryList *", 0, 0, (void*)0, 0};
15325
static swig_type_info _swigt__p_DiscreteDistribution = {"_p_DiscreteDistribution", "DiscreteDistribution *", 0, 0, (void*)0, 0};
15326
static swig_type_info _swigt__p_Distribution = {"_p_Distribution", "Distribution *", 0, 0, (void*)0, 0};
15327
static swig_type_info _swigt__p_DistributionCollection = {"_p_DistributionCollection", "DistributionCollection *", 0, 0, (void*)0, 0};
15328
static swig_type_info _swigt__p_DistributionFactory = {"_p_DistributionFactory", "DistributionFactory *", 0, 0, (void*)0, 0};
15329
static swig_type_info _swigt__p_DistributionFactoryCollection = {"_p_DistributionFactoryCollection", "DistributionFactoryCollection *", 0, 0, (void*)0, 0};
15330
static swig_type_info _swigt__p_DistributionImplementation = {"_p_DistributionImplementation", "DistributionImplementation *", 0, 0, (void*)0, 0};
15331
static swig_type_info _swigt__p_DistributionImplementationFactory = {"_p_DistributionImplementationFactory", "DistributionImplementationFactory *", 0, 0, (void*)0, 0};
15332
static swig_type_info _swigt__p_DistributionPersistentCollection = {"_p_DistributionPersistentCollection", "DistributionPersistentCollection *", 0, 0, (void*)0, 0};
15333
static swig_type_info _swigt__p_DrawableCollection = {"_p_DrawableCollection", "DrawableCollection *", 0, 0, (void*)0, 0};
15334
static swig_type_info _swigt__p_DrawablePersistentCollection = {"_p_DrawablePersistentCollection", "DrawablePersistentCollection *", 0, 0, (void*)0, 0};
15335
static swig_type_info _swigt__p_ElementType = {"_p_ElementType", "ElementType *", 0, 0, (void*)0, 0};
15336
static swig_type_info _swigt__p_EllipticalDistribution = {"_p_EllipticalDistribution", "EllipticalDistribution *", 0, 0, (void*)0, 0};
15337
static swig_type_info _swigt__p_EvaluationImplementation = {"_p_EvaluationImplementation", "EvaluationImplementation *", 0, 0, (void*)0, 0};
15338
static swig_type_info _swigt__p_Factory = {"_p_Factory", "Factory *", 0, 0, (void*)0, 0};
15339
static swig_type_info _swigt__p_FileListType = {"_p_FileListType", "FileListType *", 0, 0, (void*)0, 0};
15340
static swig_type_info _swigt__p_FileNotFoundException = {"_p_FileNotFoundException", "FileNotFoundException *", 0, 0, (void*)0, 0};
15341
static swig_type_info _swigt__p_Format = {"_p_Format", "Format *", 0, 0, (void*)0, 0};
15342
static swig_type_info _swigt__p_FunctionalChaosResult = {"_p_FunctionalChaosResult", "FunctionalChaosResult *", 0, 0, (void*)0, 0};
15343
static swig_type_info _swigt__p_GradientImplementation = {"_p_GradientImplementation", "GradientImplementation *", 0, 0, (void*)0, 0};
15344
static swig_type_info _swigt__p_Graph = {"_p_Graph", "Graph *", 0, 0, (void*)0, 0};
15345
static swig_type_info _swigt__p_GraphCollection = {"_p_GraphCollection", "GraphCollection *", 0, 0, (void*)0, 0};
15346
static swig_type_info _swigt__p_HessianImplementation = {"_p_HessianImplementation", "HessianImplementation *", 0, 0, (void*)0, 0};
15347
static swig_type_info _swigt__p_IdentityMatrix = {"_p_IdentityMatrix", "IdentityMatrix *", 0, 0, (void*)0, 0};
15348
static swig_type_info _swigt__p_Implementation = {"_p_Implementation", "Implementation *", 0, 0, (void*)0, 0};
15349
static swig_type_info _swigt__p_ImplementationAsPersistentObject = {"_p_ImplementationAsPersistentObject", "ImplementationAsPersistentObject *", 0, 0, (void*)0, 0};
15350
static swig_type_info _swigt__p_ImplementationElementType = {"_p_ImplementationElementType", "ImplementationElementType *", 0, 0, (void*)0, 0};
15351
static swig_type_info _swigt__p_ImplementationType = {"_p_ImplementationType", "ImplementationType *", 0, 0, (void*)0, 0};
15352
static swig_type_info _swigt__p_Indices = {"_p_Indices", "Indices *", 0, 0, (void*)0, 0};
15353
static swig_type_info _swigt__p_InternalException = {"_p_InternalException", "InternalException *", 0, 0, (void*)0, 0};
15354
static swig_type_info _swigt__p_InternalFunction = {"_p_InternalFunction", "InternalFunction *", 0, 0, (void*)0, 0};
15355
static swig_type_info _swigt__p_InternalGradient = {"_p_InternalGradient", "InternalGradient *", 0, 0, (void*)0, 0};
15356
static swig_type_info _swigt__p_InternalHessian = {"_p_InternalHessian", "InternalHessian *", 0, 0, (void*)0, 0};
15357
static swig_type_info _swigt__p_InternalType = {"_p_InternalType", "InternalType *", 0, 0, (void*)0, 0};
15358
static swig_type_info _swigt__p_Interval = {"_p_Interval", "Interval *", 0, 0, (void*)0, 0};
15359
static swig_type_info _swigt__p_InvalidArgumentException = {"_p_InvalidArgumentException", "InvalidArgumentException *", 0, 0, (void*)0, 0};
15360
static swig_type_info _swigt__p_InvalidDimensionException = {"_p_InvalidDimensionException", "InvalidDimensionException *", 0, 0, (void*)0, 0};
15361
static swig_type_info _swigt__p_InverseIsoProbabilisticTransformation = {"_p_InverseIsoProbabilisticTransformation", "InverseIsoProbabilisticTransformation *", 0, 0, (void*)0, 0};
15362
static swig_type_info _swigt__p_IsoProbabilisticTransformation = {"_p_IsoProbabilisticTransformation", "IsoProbabilisticTransformation *", 0, 0, (void*)0, 0};
15363
static swig_type_info _swigt__p_KeyType = {"_p_KeyType", "KeyType *", 0, 0, (void*)0, 0};
15364
static swig_type_info _swigt__p_LabelMap = {"_p_LabelMap", "LabelMap *", 0, 0, (void*)0, 0};
15365
static swig_type_info _swigt__p_LinearModel = {"_p_LinearModel", "LinearModel *", 0, 0, (void*)0, 0};
15366
static swig_type_info _swigt__p_Map = {"_p_Map", "Map *", 0, 0, (void*)0, 0};
15367
static swig_type_info _swigt__p_MapElement = {"_p_MapElement", "MapElement *", 0, 0, (void*)0, 0};
15368
static swig_type_info _swigt__p_MappedType = {"_p_MappedType", "MappedType *", 0, 0, (void*)0, 0};
15369
static swig_type_info _swigt__p_Matrix = {"_p_Matrix", "Matrix *", 0, 0, (void*)0, 0};
15370
static swig_type_info _swigt__p_MersenneTwister = {"_p_MersenneTwister", "MersenneTwister *", 0, 0, (void*)0, 0};
15371
static swig_type_info _swigt__p_NoWrapperFileFoundException = {"_p_NoWrapperFileFoundException", "NoWrapperFileFoundException *", 0, 0, (void*)0, 0};
15372
static swig_type_info _swigt__p_NonEllipticalDistribution = {"_p_NonEllipticalDistribution", "NonEllipticalDistribution *", 0, 0, (void*)0, 0};
15373
static swig_type_info _swigt__p_Normal = {"_p_Normal", "Normal *", 0, 0, (void*)0, 0};
15374
static swig_type_info _swigt__p_NotDefinedException = {"_p_NotDefinedException", "NotDefinedException *", 0, 0, (void*)0, 0};
15375
static swig_type_info _swigt__p_NotSymmetricDefinitePositiveException = {"_p_NotSymmetricDefinitePositiveException", "NotSymmetricDefinitePositiveException *", 0, 0, (void*)0, 0};
15376
static swig_type_info _swigt__p_NumericalComplexCollection = {"_p_NumericalComplexCollection", "NumericalComplexCollection *", 0, 0, (void*)0, 0};
15377
static swig_type_info _swigt__p_NumericalComplexPersistentCollection = {"_p_NumericalComplexPersistentCollection", "NumericalComplexPersistentCollection *", 0, 0, (void*)0, 0};
15378
static swig_type_info _swigt__p_NumericalMathFunction = {"_p_NumericalMathFunction", "NumericalMathFunction *", 0, 0, (void*)0, 0};
15379
static swig_type_info _swigt__p_NumericalMathFunctionCollection = {"_p_NumericalMathFunctionCollection", "NumericalMathFunctionCollection *", 0, 0, (void*)0, 0};
15380
static swig_type_info _swigt__p_NumericalMathFunctionPersistentCollection = {"_p_NumericalMathFunctionPersistentCollection", "NumericalMathFunctionPersistentCollection *", 0, 0, (void*)0, 0};
15381
static swig_type_info _swigt__p_NumericalPoint = {"_p_NumericalPoint", "NumericalPoint *", 0, 0, (void*)0, 0};
15382
static swig_type_info _swigt__p_NumericalPointCollection = {"_p_NumericalPointCollection", "NumericalPointCollection *", 0, 0, (void*)0, 0};
15383
static swig_type_info _swigt__p_NumericalPointWithDescription = {"_p_NumericalPointWithDescription", "NumericalPointWithDescription *", 0, 0, (void*)0, 0};
15384
static swig_type_info _swigt__p_NumericalPointWithDescriptionCollection = {"_p_NumericalPointWithDescriptionCollection", "NumericalPointWithDescriptionCollection *", 0, 0, (void*)0, 0};
15385
static swig_type_info _swigt__p_NumericalSample = {"_p_NumericalSample", "NumericalSample *", 0, 0, (void*)0, 0};
15386
static swig_type_info _swigt__p_NumericalScalarCollection = {"_p_NumericalScalarCollection", "NumericalScalarCollection *", 0, 0, (void*)0, 0};
15387
static swig_type_info _swigt__p_NumericalScalarPersistentCollection = {"_p_NumericalScalarPersistentCollection", "NumericalScalarPersistentCollection *", 0, 0, (void*)0, 0};
15388
static swig_type_info _swigt__p_OT__Base__Optim__AbdoRackwitzSpecificParameters = {"_p_OT__Base__Optim__AbdoRackwitzSpecificParameters", "OT::Base::Optim::AbdoRackwitzSpecificParameters *|OpenTURNS::Base::Optim::AbdoRackwitzSpecificParameters *", 0, 0, (void*)0, 0};
15389
static swig_type_info _swigt__p_OT__Base__Optim__CobylaSpecificParameters = {"_p_OT__Base__Optim__CobylaSpecificParameters", "OT::Base::Optim::CobylaSpecificParameters *|OpenTURNS::Base::Optim::CobylaSpecificParameters *", 0, 0, (void*)0, 0};
15390
static swig_type_info _swigt__p_OT__Base__Optim__NearestPointAlgorithmImplementation__Result = {"_p_OT__Base__Optim__NearestPointAlgorithmImplementation__Result", "OpenTURNS::Base::Optim::NearestPointAlgorithmImplementationResult *|OT::Base::Optim::NearestPointAlgorithmImplementation::Result *", 0, 0, (void*)0, 0};
15391
static swig_type_info _swigt__p_OT__Base__Optim__NearestPointChecker__Result = {"_p_OT__Base__Optim__NearestPointChecker__Result", "OT::Base::Optim::NearestPointChecker::Result *|OpenTURNS::Base::Optim::NearestPointCheckerResult *", 0, 0, (void*)0, 0};
15392
static swig_type_info _swigt__p_OT__Base__Optim__SQPSpecificParameters = {"_p_OT__Base__Optim__SQPSpecificParameters", "OT::Base::Optim::SQPSpecificParameters *|OpenTURNS::Base::Optim::SQPSpecificParameters *", 0, 0, (void*)0, 0};
15393
static swig_type_info _swigt__p_OT__Base__Optim__TNCSpecificParameters = {"_p_OT__Base__Optim__TNCSpecificParameters", "OT::Base::Optim::TNCSpecificParameters *|OpenTURNS::Base::Optim::TNCSpecificParameters *", 0, 0, (void*)0, 0};
15394
static swig_type_info _swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters = {"_p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters", "OpenTURNS::Base::Stat::CorrelationAnalysisSobolIndiceParameters *|OT::Base::Stat::CorrelationAnalysisSobolIndiceParameters *", 0, 0, (void*)0, 0};
15395
static swig_type_info _swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult = {"_p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult", "OpenTURNS::Base::Stat::CorrelationAnalysisSobolIndiceResult *|OT::Base::Stat::CorrelationAnalysisSobolIndiceResult *", 0, 0, (void*)0, 0};
15396
static swig_type_info _swigt__p_OT__Base__Stat__RandomGeneratorState = {"_p_OT__Base__Stat__RandomGeneratorState", "OT::Base::Stat::RandomGeneratorState *|OpenTURNS::Base::Stat::RandomGeneratorState *", 0, 0, (void*)0, 0};
15397
static swig_type_info _swigt__p_OT__Uncertainty__Distribution__HistogramPair = {"_p_OT__Uncertainty__Distribution__HistogramPair", "OT::Uncertainty::Distribution::HistogramPair *|OpenTURNS::Uncertainty::Distribution::HistogramPair *", 0, 0, (void*)0, 0};
15398
static swig_type_info _swigt__p_OT__Uncertainty__Distribution__UserDefinedPair = {"_p_OT__Uncertainty__Distribution__UserDefinedPair", "OT::Uncertainty::Distribution::UserDefinedPair *|OpenTURNS::Uncertainty::Distribution::UserDefinedPair *", 0, 0, (void*)0, 0};
15399
static swig_type_info _swigt__p_OpenTURNS__Base__Common__Object = {"_p_OpenTURNS__Base__Common__Object", "OpenTURNS::Base::Common::Object *", 0, 0, (void*)0, 0};
15400
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__EllipticalDistribution = {"_p_OpenTURNS__Uncertainty__Model__EllipticalDistribution", 0, 0, 0, 0, 0};
15401
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Gamma = {"_p_OpenTURNS__Uncertainty__Distribution__Gamma", 0, 0, 0, 0, 0};
15402
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Weibull = {"_p_OpenTURNS__Uncertainty__Distribution__Weibull", 0, 0, 0, 0, 0};
15403
static swig_type_info _swigt__p_OpenTURNS__Base__Common__Study = {"_p_OpenTURNS__Base__Common__Study", 0, 0, 0, 0, 0};
15404
static swig_type_info _swigt__p_OpenTURNS__Base__Type__Interval = {"_p_OpenTURNS__Base__Type__Interval", 0, 0, 0, 0, 0};
15405
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__ConfidenceInterval = {"_p_OpenTURNS__Base__Stat__ConfidenceInterval", 0, 0, 0, 0, 0};
15406
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__UniformFactory = {"_p_OpenTURNS__Uncertainty__Distribution__UniformFactory", 0, 0, 0, 0, 0};
15407
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__Full = {"_p_OpenTURNS__Base__Stat__Full", 0, 0, 0, 0, 0};
15408
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__LowDiscrepancySequence = {"_p_OpenTURNS__Base__Stat__LowDiscrepancySequence", 0, 0, 0, 0, 0};
15409
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__SobolSequence = {"_p_OpenTURNS__Base__Stat__SobolSequence", 0, 0, 0, 0, 0};
15410
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__HaltonSequence = {"_p_OpenTURNS__Base__Stat__HaltonSequence", 0, 0, 0, 0, 0};
15411
static swig_type_info _swigt__p_OpenTURNS__Base__Func__WrapperDataFile = {"_p_OpenTURNS__Base__Func__WrapperDataFile", 0, 0, 0, 0, 0};
15412
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NumericalMathHessianImplementation = {"_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation", 0, 0, 0, 0, 0};
15413
static swig_type_info _swigt__p_OpenTURNS__Base__Solver__Solver = {"_p_OpenTURNS__Base__Solver__Solver", 0, 0, 0, 0, 0};
15414
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Mixture = {"_p_OpenTURNS__Uncertainty__Distribution__Mixture", 0, 0, 0, 0, 0};
15415
static swig_type_info _swigt__p_OpenTURNS__Base__Optim__AbdoRackwitz = {"_p_OpenTURNS__Base__Optim__AbdoRackwitz", 0, 0, 0, 0, 0};
15416
static swig_type_info _swigt__p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation = {"_p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation", 0, 0, 0, 0, 0};
15417
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation = {"_p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation", 0, 0, 0, 0, 0};
15418
static swig_type_info _swigt__p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
15419
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__TruncatedDistribution = {"_p_OpenTURNS__Uncertainty__Distribution__TruncatedDistribution", 0, 0, 0, 0, 0};
15420
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalFactory = {"_p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalFactory", 0, 0, 0, 0, 0};
15421
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__TruncatedNormal = {"_p_OpenTURNS__Uncertainty__Distribution__TruncatedNormal", 0, 0, 0, 0, 0};
15422
static swig_type_info _swigt__p_OpenTURNS__Base__Common__Less = {"_p_OpenTURNS__Base__Common__Less", 0, 0, 0, 0, 0};
15423
static swig_type_info _swigt__p_OpenTURNS__Base__Optim__NearestPointAlgorithm = {"_p_OpenTURNS__Base__Optim__NearestPointAlgorithm", 0, 0, 0, 0, 0};
15424
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__Compact = {"_p_OpenTURNS__Base__Stat__Compact", 0, 0, 0, 0, 0};
15425
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__ContinuousDistribution = {"_p_OpenTURNS__Uncertainty__Model__ContinuousDistribution", 0, 0, 0, 0, 0};
15426
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__ArchimedeanCopula = {"_p_OpenTURNS__Uncertainty__Model__ArchimedeanCopula", 0, 0, 0, 0, 0};
15427
static swig_type_info _swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_t = {"_p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_t", 0, 0, 0, 0, 0};
15428
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__LaplaceFactory = {"_p_OpenTURNS__Uncertainty__Distribution__LaplaceFactory", 0, 0, 0, 0, 0};
15429
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__RandomMixture = {"_p_OpenTURNS__Uncertainty__Distribution__RandomMixture", 0, 0, 0, 0, 0};
15430
static swig_type_info _swigt__p_OpenTURNS__Base__Optim__NearestPointChecker = {"_p_OpenTURNS__Base__Optim__NearestPointChecker", 0, 0, 0, 0, 0};
15431
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__MultiNomial = {"_p_OpenTURNS__Uncertainty__Distribution__MultiNomial", 0, 0, 0, 0, 0};
15432
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__MultiNomialFactory = {"_p_OpenTURNS__Uncertainty__Distribution__MultiNomialFactory", 0, 0, 0, 0, 0};
15433
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__RayleighFactory = {"_p_OpenTURNS__Uncertainty__Distribution__RayleighFactory", 0, 0, 0, 0, 0};
15434
static swig_type_info _swigt__p_OpenTURNS__Base__Graph__Staircase = {"_p_OpenTURNS__Base__Graph__Staircase", 0, 0, 0, 0, 0};
15435
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__HistogramFactory = {"_p_OpenTURNS__Uncertainty__Distribution__HistogramFactory", 0, 0, 0, 0, 0};
15436
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Histogram = {"_p_OpenTURNS__Uncertainty__Distribution__Histogram", 0, 0, 0, 0, 0};
15437
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__GammaFactory = {"_p_OpenTURNS__Uncertainty__Distribution__GammaFactory", 0, 0, 0, 0, 0};
15438
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__StudentFactory = {"_p_OpenTURNS__Uncertainty__Distribution__StudentFactory", 0, 0, 0, 0, 0};
15439
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Laplace = {"_p_OpenTURNS__Uncertainty__Distribution__Laplace", 0, 0, 0, 0, 0};
15440
static swig_type_info _swigt__p_OpenTURNS__Base__Graph__GraphImplementation = {"_p_OpenTURNS__Base__Graph__GraphImplementation", 0, 0, 0, 0, 0};
15441
static swig_type_info _swigt__p_OpenTURNS__Base__Graph__DrawableImplementation = {"_p_OpenTURNS__Base__Graph__DrawableImplementation", 0, 0, 0, 0, 0};
15442
static swig_type_info _swigt__p_OpenTURNS__Base__Type__TensorImplementation = {"_p_OpenTURNS__Base__Type__TensorImplementation", 0, 0, 0, 0, 0};
15443
static swig_type_info _swigt__p_OpenTURNS__Base__Type__MatrixImplementation = {"_p_OpenTURNS__Base__Type__MatrixImplementation", 0, 0, 0, 0, 0};
15444
static swig_type_info _swigt__p_OpenTURNS__Base__Solver__SolverImplementation = {"_p_OpenTURNS__Base__Solver__SolverImplementation", 0, 0, 0, 0, 0};
15445
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__RandomVectorImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__RandomVectorImplementation_t", 0, 0, 0, 0, 0};
15446
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__GraphImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__GraphImplementation_t", 0, 0, 0, 0, 0};
15447
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory_t", 0, 0, 0, 0, 0};
15448
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementation_t", 0, 0, 0, 0, 0};
15449
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Solver__SolverImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Solver__SolverImplementation_t", 0, 0, 0, 0, 0};
15450
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation_t", 0, 0, 0, 0, 0};
15451
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation_t", 0, 0, 0, 0, 0};
15452
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__UniVariatePolynomialImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__UniVariatePolynomialImplementation_t", 0, 0, 0, 0, 0};
15453
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__NumericalMathFunctionImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__NumericalMathFunctionImplementation_t", 0, 0, 0, 0, 0};
15454
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t", 0, 0, 0, 0, 0};
15455
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Common__ComparisonOperatorImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Common__ComparisonOperatorImplementation_t", 0, 0, 0, 0, 0};
15456
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__MatrixImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__MatrixImplementation_t", 0, 0, 0, 0, 0};
15457
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__TensorImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__TensorImplementation_t", 0, 0, 0, 0, 0};
15458
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t", 0, 0, 0, 0, 0};
15459
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__HistoryStrategyImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__HistoryStrategyImplementation_t", 0, 0, 0, 0, 0};
15460
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation_t", 0, 0, 0, 0, 0};
15461
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__DrawableImplementation_t = {"_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__DrawableImplementation_t", 0, 0, 0, 0, 0};
15462
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__EventRandomVectorImplementation = {"_p_OpenTURNS__Uncertainty__Model__EventRandomVectorImplementation", 0, 0, 0, 0, 0};
15463
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__UsualRandomVector = {"_p_OpenTURNS__Uncertainty__Model__UsualRandomVector", 0, 0, 0, 0, 0};
15464
static swig_type_info _swigt__p_OpenTURNS__Base__Func__WrapperFrameworkData = {"_p_OpenTURNS__Base__Func__WrapperFrameworkData", 0, 0, 0, 0, 0};
15465
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__Null = {"_p_OpenTURNS__Base__Stat__Null", 0, 0, 0, 0, 0};
15466
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__NonEllipticalDistribution = {"_p_OpenTURNS__Uncertainty__Model__NonEllipticalDistribution", 0, 0, 0, 0, 0};
15467
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NumericalMathGradientImplementation = {"_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation", 0, 0, 0, 0, 0};
15468
static swig_type_info _swigt__p_OpenTURNS__Base__Type__NumericalPointWithDescription = {"_p_OpenTURNS__Base__Type__NumericalPointWithDescription", 0, 0, 0, 0, 0};
15469
static swig_type_info _swigt__p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation = {"_p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation", 0, 0, 0, 0, 0};
15470
static swig_type_info _swigt__p_OpenTURNS__Base__Optim__PenalizedLeastSquaresAlgorithm = {"_p_OpenTURNS__Base__Optim__PenalizedLeastSquaresAlgorithm", 0, 0, 0, 0, 0};
15471
static swig_type_info _swigt__p_OpenTURNS__Base__Optim__Cobyla = {"_p_OpenTURNS__Base__Optim__Cobyla", 0, 0, 0, 0, 0};
15472
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation = {"_p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation", 0, 0, 0, 0, 0};
15473
static swig_type_info _swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient = {"_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient", 0, 0, 0, 0, 0};
15474
static swig_type_info _swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian = {"_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian", 0, 0, 0, 0, 0};
15475
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation = {"_p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation", 0, 0, 0, 0, 0};
15476
static swig_type_info _swigt__p_OpenTURNS__Base__Common__ComparisonOperator = {"_p_OpenTURNS__Base__Common__ComparisonOperator", 0, 0, 0, 0, 0};
15477
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__UserDefined = {"_p_OpenTURNS__Uncertainty__Distribution__UserDefined", 0, 0, 0, 0, 0};
15478
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__UserDefinedFactory = {"_p_OpenTURNS__Uncertainty__Distribution__UserDefinedFactory", 0, 0, 0, 0, 0};
15479
static swig_type_info _swigt__p_OpenTURNS__Base__Common__LessOrEqual = {"_p_OpenTURNS__Base__Common__LessOrEqual", 0, 0, 0, 0, 0};
15480
static swig_type_info _swigt__p_OpenTURNS__Base__Common__GreaterOrEqual = {"_p_OpenTURNS__Base__Common__GreaterOrEqual", 0, 0, 0, 0, 0};
15481
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation = {"_p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation", 0, 0, 0, 0, 0};
15482
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation = {"_p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation", 0, 0, 0, 0, 0};
15483
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation = {"_p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation", 0, 0, 0, 0, 0};
15484
static swig_type_info _swigt__p_OpenTURNS__Base__Optim__SQP = {"_p_OpenTURNS__Base__Optim__SQP", 0, 0, 0, 0, 0};
15485
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Uniform = {"_p_OpenTURNS__Uncertainty__Distribution__Uniform", 0, 0, 0, 0, 0};
15486
static swig_type_info _swigt__p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation = {"_p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation", 0, 0, 0, 0, 0};
15487
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation = {"_p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation", 0, 0, 0, 0, 0};
15488
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__TriangularFactory = {"_p_OpenTURNS__Uncertainty__Distribution__TriangularFactory", 0, 0, 0, 0, 0};
15489
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Triangular = {"_p_OpenTURNS__Uncertainty__Distribution__Triangular", 0, 0, 0, 0, 0};
15490
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Gumbel = {"_p_OpenTURNS__Uncertainty__Distribution__Gumbel", 0, 0, 0, 0, 0};
15491
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__NumericalSampleImplementation = {"_p_OpenTURNS__Base__Stat__NumericalSampleImplementation", 0, 0, 0, 0, 0};
15492
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__HistoryStrategyImplementation = {"_p_OpenTURNS__Base__Stat__HistoryStrategyImplementation", 0, 0, 0, 0, 0};
15493
static swig_type_info _swigt__p_OpenTURNS__Base__Func__WrapperFunctionDescription = {"_p_OpenTURNS__Base__Func__WrapperFunctionDescription", 0, 0, 0, 0, 0};
15494
static swig_type_info _swigt__p_OpenTURNS__Base__Func__UniVariatePolynomial = {"_p_OpenTURNS__Base__Func__UniVariatePolynomial", 0, 0, 0, 0, 0};
15495
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__NormalCopulaFactory = {"_p_OpenTURNS__Uncertainty__Distribution__NormalCopulaFactory", 0, 0, 0, 0, 0};
15496
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__NormalCopula = {"_p_OpenTURNS__Uncertainty__Distribution__NormalCopula", 0, 0, 0, 0, 0};
15497
static swig_type_info _swigt__p_OpenTURNS__Base__Graph__Pie = {"_p_OpenTURNS__Base__Graph__Pie", 0, 0, 0, 0, 0};
15498
static swig_type_info _swigt__p_OpenTURNS__Base__Common__InterfaceObject = {"_p_OpenTURNS__Base__Common__InterfaceObject", 0, 0, 0, 0, 0};
15499
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__ClaytonCopula = {"_p_OpenTURNS__Uncertainty__Distribution__ClaytonCopula", 0, 0, 0, 0, 0};
15500
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaFactory = {"_p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaFactory", 0, 0, 0, 0, 0};
15501
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__NormalFactory = {"_p_OpenTURNS__Uncertainty__Distribution__NormalFactory", 0, 0, 0, 0, 0};
15502
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Logistic = {"_p_OpenTURNS__Uncertainty__Distribution__Logistic", 0, 0, 0, 0, 0};
15503
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
15504
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__GeometricFactory = {"_p_OpenTURNS__Uncertainty__Distribution__GeometricFactory", 0, 0, 0, 0, 0};
15505
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Geometric = {"_p_OpenTURNS__Uncertainty__Distribution__Geometric", 0, 0, 0, 0, 0};
15506
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__KernelMixture = {"_p_OpenTURNS__Uncertainty__Distribution__KernelMixture", 0, 0, 0, 0, 0};
15507
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__SklarCopula = {"_p_OpenTURNS__Uncertainty__Model__SklarCopula", 0, 0, 0, 0, 0};
15508
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__NonCentralStudent = {"_p_OpenTURNS__Uncertainty__Distribution__NonCentralStudent", 0, 0, 0, 0, 0};
15509
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__PoissonFactory = {"_p_OpenTURNS__Uncertainty__Distribution__PoissonFactory", 0, 0, 0, 0, 0};
15510
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation = {"_p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation", 0, 0, 0, 0, 0};
15511
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation = {"_p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation", 0, 0, 0, 0, 0};
15512
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation = {"_p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation", 0, 0, 0, 0, 0};
15513
static swig_type_info _swigt__p_OpenTURNS__Base__Common__Equal = {"_p_OpenTURNS__Base__Common__Equal", 0, 0, 0, 0, 0};
15514
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t = {"_p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t", 0, 0, 0, 0, 0};
15515
static swig_type_info _swigt__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t = {"_p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t", 0, 0, 0, 0, 0};
15516
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Epanechnikov = {"_p_OpenTURNS__Uncertainty__Distribution__Epanechnikov", 0, 0, 0, 0, 0};
15517
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__IndependentCopula = {"_p_OpenTURNS__Uncertainty__Distribution__IndependentCopula", 0, 0, 0, 0, 0};
15518
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation = {"_p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation", 0, 0, 0, 0, 0};
15519
static swig_type_info _swigt__p_OpenTURNS__Base__Graph__Cloud = {"_p_OpenTURNS__Base__Graph__Cloud", 0, 0, 0, 0, 0};
15520
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__ConstantRandomVector = {"_p_OpenTURNS__Uncertainty__Model__ConstantRandomVector", 0, 0, 0, 0, 0};
15521
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NumericalMathFunction = {"_p_OpenTURNS__Base__Func__NumericalMathFunction", 0, 0, 0, 0, 0};
15522
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__Copula = {"_p_OpenTURNS__Uncertainty__Model__Copula", 0, 0, 0, 0, 0};
15523
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__RandomVector = {"_p_OpenTURNS__Uncertainty__Model__RandomVector", 0, 0, 0, 0, 0};
15524
static swig_type_info _swigt__p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient = {"_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient", 0, 0, 0, 0, 0};
15525
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__ComposedCopula = {"_p_OpenTURNS__Uncertainty__Distribution__ComposedCopula", 0, 0, 0, 0, 0};
15526
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__ComposedDistribution = {"_p_OpenTURNS__Uncertainty__Distribution__ComposedDistribution", 0, 0, 0, 0, 0};
15527
static swig_type_info _swigt__p_OpenTURNS__Base__Type__DescriptionImplementation = {"_p_OpenTURNS__Base__Type__DescriptionImplementation", 0, 0, 0, 0, 0};
15528
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__LogisticFactory = {"_p_OpenTURNS__Uncertainty__Distribution__LogisticFactory", 0, 0, 0, 0, 0};
15529
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__CorrelationMatrix = {"_p_OpenTURNS__Base__Stat__CorrelationMatrix", 0, 0, 0, 0, 0};
15530
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__BetaFactory = {"_p_OpenTURNS__Uncertainty__Distribution__BetaFactory", 0, 0, 0, 0, 0};
15531
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaFactory = {"_p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaFactory", 0, 0, 0, 0, 0};
15532
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__GumbelCopula = {"_p_OpenTURNS__Uncertainty__Distribution__GumbelCopula", 0, 0, 0, 0, 0};
15533
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__UsualDistribution = {"_p_OpenTURNS__Uncertainty__Model__UsualDistribution", 0, 0, 0, 0, 0};
15534
static swig_type_info _swigt__p_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation = {"_p_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation", 0, 0, 0, 0, 0};
15535
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ProductNumericalMathFunction = {"_p_OpenTURNS__Base__Func__ProductNumericalMathFunction", 0, 0, 0, 0, 0};
15536
static swig_type_info _swigt__p_OpenTURNS__Base__Solver__Brent = {"_p_OpenTURNS__Base__Solver__Brent", 0, 0, 0, 0, 0};
15537
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__GumbelFactory = {"_p_OpenTURNS__Uncertainty__Distribution__GumbelFactory", 0, 0, 0, 0, 0};
15538
static swig_type_info _swigt__p_OpenTURNS__Base__Graph__Contour = {"_p_OpenTURNS__Base__Graph__Contour", 0, 0, 0, 0, 0};
15539
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
15540
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
15541
static swig_type_info _swigt__p_OpenTURNS__Base__Func__WrapperFile = {"_p_OpenTURNS__Base__Func__WrapperFile", 0, 0, 0, 0, 0};
15542
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__CopulaImplementation = {"_p_OpenTURNS__Uncertainty__Model__CopulaImplementation", 0, 0, 0, 0, 0};
15543
static swig_type_info _swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_t = {"_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_t", 0, 0, 0, 0, 0};
15544
static swig_type_info _swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_t = {"_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_t", 0, 0, 0, 0, 0};
15545
static swig_type_info _swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_t = {"_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_t", 0, 0, 0, 0, 0};
15546
static swig_type_info _swigt__p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
15547
static swig_type_info _swigt__p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
15548
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__Event = {"_p_OpenTURNS__Uncertainty__Model__Event", 0, 0, 0, 0, 0};
15549
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__ConditionalRandomVector = {"_p_OpenTURNS__Uncertainty__Model__ConditionalRandomVector", 0, 0, 0, 0, 0};
15550
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__DiscreteDistribution = {"_p_OpenTURNS__Uncertainty__Model__DiscreteDistribution", 0, 0, 0, 0, 0};
15551
static swig_type_info _swigt__p_OpenTURNS__Base__Common__Greater = {"_p_OpenTURNS__Base__Common__Greater", 0, 0, 0, 0, 0};
15552
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
15553
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory = {"_p_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory", 0, 0, 0, 0, 0};
15554
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__DistributionImplementation = {"_p_OpenTURNS__Uncertainty__Model__DistributionImplementation", 0, 0, 0, 0, 0};
15555
static swig_type_info _swigt__p_OpenTURNS__Base__Type__Matrix = {"_p_OpenTURNS__Base__Type__Matrix", 0, 0, 0, 0, 0};
15556
static swig_type_info _swigt__p_OpenTURNS__Base__Type__SquareMatrix = {"_p_OpenTURNS__Base__Type__SquareMatrix", 0, 0, 0, 0, 0};
15557
static swig_type_info _swigt__p_OpenTURNS__Base__Type__SymmetricMatrix = {"_p_OpenTURNS__Base__Type__SymmetricMatrix", 0, 0, 0, 0, 0};
15558
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__CovarianceMatrix = {"_p_OpenTURNS__Base__Stat__CovarianceMatrix", 0, 0, 0, 0, 0};
15559
static swig_type_info _swigt__p_OpenTURNS__Base__Type__IdentityMatrix = {"_p_OpenTURNS__Base__Type__IdentityMatrix", 0, 0, 0, 0, 0};
15560
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__HistoryStrategy = {"_p_OpenTURNS__Base__Stat__HistoryStrategy", 0, 0, 0, 0, 0};
15561
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__WeibullFactory = {"_p_OpenTURNS__Uncertainty__Distribution__WeibullFactory", 0, 0, 0, 0, 0};
15562
static swig_type_info _swigt__p_OpenTURNS__Base__Type__NumericalPoint = {"_p_OpenTURNS__Base__Type__NumericalPoint", 0, 0, 0, 0, 0};
15563
static swig_type_info _swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_t = {"_p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_t", 0, 0, 0, 0, 0};
15564
static swig_type_info _swigt__p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation = {"_p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation", 0, 0, 0, 0, 0};
15565
static swig_type_info _swigt__p_OpenTURNS__Base__Solver__Secant = {"_p_OpenTURNS__Base__Solver__Secant", 0, 0, 0, 0, 0};
15566
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__LogNormal = {"_p_OpenTURNS__Uncertainty__Distribution__LogNormal", 0, 0, 0, 0, 0};
15567
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Normal = {"_p_OpenTURNS__Uncertainty__Distribution__Normal", 0, 0, 0, 0, 0};
15568
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__LogNormalFactory = {"_p_OpenTURNS__Uncertainty__Distribution__LogNormalFactory", 0, 0, 0, 0, 0};
15569
static swig_type_info _swigt__p_OpenTURNS__Base__Graph__Drawable = {"_p_OpenTURNS__Base__Graph__Drawable", 0, 0, 0, 0, 0};
15570
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Poisson = {"_p_OpenTURNS__Uncertainty__Distribution__Poisson", 0, 0, 0, 0, 0};
15571
static swig_type_info _swigt__p_OpenTURNS__Base__Type__Tensor = {"_p_OpenTURNS__Base__Type__Tensor", 0, 0, 0, 0, 0};
15572
static swig_type_info _swigt__p_OpenTURNS__Base__Type__SymmetricTensor = {"_p_OpenTURNS__Base__Type__SymmetricTensor", 0, 0, 0, 0, 0};
15573
static swig_type_info _swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_double_t = {"_p_OpenTURNS__Base__Type__PersistentCollectionT_double_t", 0, 0, 0, 0, 0};
15574
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__ChiSquare = {"_p_OpenTURNS__Uncertainty__Distribution__ChiSquare", 0, 0, 0, 0, 0};
15575
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__ChiSquareFactory = {"_p_OpenTURNS__Uncertainty__Distribution__ChiSquareFactory", 0, 0, 0, 0, 0};
15576
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__ExponentialFactory = {"_p_OpenTURNS__Uncertainty__Distribution__ExponentialFactory", 0, 0, 0, 0, 0};
15577
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Exponential = {"_p_OpenTURNS__Uncertainty__Distribution__Exponential", 0, 0, 0, 0, 0};
15578
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__CompositeRandomVector = {"_p_OpenTURNS__Uncertainty__Model__CompositeRandomVector", 0, 0, 0, 0, 0};
15579
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathFunction = {"_p_OpenTURNS__Base__Func__ComposedNumericalMathFunction", 0, 0, 0, 0, 0};
15580
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
15581
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__KernelSmoothing = {"_p_OpenTURNS__Uncertainty__Distribution__KernelSmoothing", 0, 0, 0, 0, 0};
15582
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__FrankCopulaFactory = {"_p_OpenTURNS__Uncertainty__Distribution__FrankCopulaFactory", 0, 0, 0, 0, 0};
15583
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__FrankCopula = {"_p_OpenTURNS__Uncertainty__Distribution__FrankCopula", 0, 0, 0, 0, 0};
15584
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation = {"_p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation", 0, 0, 0, 0, 0};
15585
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__RandomVectorImplementation = {"_p_OpenTURNS__Uncertainty__Model__RandomVectorImplementation", 0, 0, 0, 0, 0};
15586
static swig_type_info _swigt__p_OpenTURNS__Base__Common__ComparisonOperatorImplementation = {"_p_OpenTURNS__Base__Common__ComparisonOperatorImplementation", 0, 0, 0, 0, 0};
15587
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Rayleigh = {"_p_OpenTURNS__Uncertainty__Distribution__Rayleigh", 0, 0, 0, 0, 0};
15588
static swig_type_info _swigt__p_OpenTURNS__Base__Solver__Bisection = {"_p_OpenTURNS__Base__Solver__Bisection", 0, 0, 0, 0, 0};
15589
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Beta = {"_p_OpenTURNS__Uncertainty__Distribution__Beta", 0, 0, 0, 0, 0};
15590
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation = {"_p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation", 0, 0, 0, 0, 0};
15591
static swig_type_info _swigt__p_OpenTURNS__Base__Graph__Curve = {"_p_OpenTURNS__Base__Graph__Curve", 0, 0, 0, 0, 0};
15592
static swig_type_info _swigt__p_OpenTURNS__Base__Graph__BarPlot = {"_p_OpenTURNS__Base__Graph__BarPlot", 0, 0, 0, 0, 0};
15593
static swig_type_info _swigt__p_OpenTURNS__Base__Func__WrapperParameter = {"_p_OpenTURNS__Base__Func__WrapperParameter", 0, 0, 0, 0, 0};
15594
static swig_type_info _swigt__p_OpenTURNS__Base__Func__WrapperDataVariable = {"_p_OpenTURNS__Base__Func__WrapperDataVariable", 0, 0, 0, 0, 0};
15595
static swig_type_info _swigt__p_OpenTURNS__Base__Func__LinearNumericalMathFunction = {"_p_OpenTURNS__Base__Func__LinearNumericalMathFunction", 0, 0, 0, 0, 0};
15596
static swig_type_info _swigt__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation = {"_p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation", 0, 0, 0, 0, 0};
15597
static swig_type_info _swigt__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationResult = {"_p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationResult", 0, 0, 0, 0, 0};
15598
static swig_type_info _swigt__p_OpenTURNS__Base__Optim__TNC = {"_p_OpenTURNS__Base__Optim__TNC", 0, 0, 0, 0, 0};
15599
static swig_type_info _swigt__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithm = {"_p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithm", 0, 0, 0, 0, 0};
15600
static swig_type_info _swigt__p_OpenTURNS__Base__Func__WrapperData = {"_p_OpenTURNS__Base__Func__WrapperData", 0, 0, 0, 0, 0};
15601
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Distribution__Student = {"_p_OpenTURNS__Uncertainty__Distribution__Student", 0, 0, 0, 0, 0};
15602
static swig_type_info _swigt__p_OpenTURNS__Base__Common__StorageManager = {"_p_OpenTURNS__Base__Common__StorageManager", 0, 0, 0, 0, 0};
15603
static swig_type_info _swigt__p_OpenTURNS__Base__Common__XMLStorageManager = {"_p_OpenTURNS__Base__Common__XMLStorageManager", 0, 0, 0, 0, 0};
15604
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__StandardEvent = {"_p_OpenTURNS__Uncertainty__Model__StandardEvent", 0, 0, 0, 0, 0};
15605
static swig_type_info _swigt__p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation = {"_p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation", 0, 0, 0, 0, 0};
15606
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__Last = {"_p_OpenTURNS__Base__Stat__Last", 0, 0, 0, 0, 0};
15607
static swig_type_info _swigt__p_OpenTURNS__Base__Common__PersistentObject = {"_p_OpenTURNS__Base__Common__PersistentObject", "OpenTURNS::Base::Common::PersistentObject *", 0, 0, (void*)0, 0};
15608
static swig_type_info _swigt__p_OpenTURNS__Base__Graph__Graph = {"_p_OpenTURNS__Base__Graph__Graph", "OpenTURNS::Base::Graph::Graph *|OpenTURNS::Uncertainty::StatTest::VisualTest::Graph *", 0, 0, (void*)0, 0};
15609
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__LinearModel = {"_p_OpenTURNS__Base__Stat__LinearModel", "OpenTURNS::Base::Stat::LinearModel *|OpenTURNS::Uncertainty::StatTest::LinearModelTest::LinearModel *|OpenTURNS::Uncertainty::StatTest::VisualTest::LinearModel *", 0, 0, (void*)0, 0};
15610
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__NumericalSample = {"_p_OpenTURNS__Base__Stat__NumericalSample", "OpenTURNS::Uncertainty::StatTest::VisualTest::NumericalSample *|OpenTURNS::Base::Stat::NumericalSample *|OpenTURNS::Uncertainty::StatTest::LinearModelTest::NumericalSample *|OpenTURNS::Uncertainty::StatTest::HypothesisTest::NumericalSample *|OpenTURNS::Uncertainty::StatTest::NormalityTest::NumericalSample *|OpenTURNS::Uncertainty::StatTest::FittingTest::NumericalSample *", 0, 0, (void*)0, 0};
15611
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__TestResult = {"_p_OpenTURNS__Base__Stat__TestResult", "OpenTURNS::Base::Stat::TestResult *|OpenTURNS::Uncertainty::StatTest::LinearModelTest::TestResult *|OpenTURNS::Uncertainty::StatTest::FittingTest::TestResult *|OpenTURNS::Uncertainty::StatTest::NormalityTest::TestResult *|OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResult *", 0, 0, (void*)0, 0};
15612
static swig_type_info _swigt__p_OpenTURNS__Base__Type__CollectionT_OT__Uncertainty__Distribution__HistogramPair_t = {"_p_OpenTURNS__Base__Type__CollectionT_OT__Uncertainty__Distribution__HistogramPair_t", "OpenTURNS::Base::Type::Collection< OT::Uncertainty::Distribution::HistogramPair > *|OpenTURNS::Uncertainty::Distribution::HistogramPairCollection *", 0, 0, (void*)0, 0};
15613
static swig_type_info _swigt__p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t = {"_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t", "OpenTURNS::Uncertainty::StatTest::HypothesisTest::TestResultCollection *|OpenTURNS::Base::Type::Collection< OpenTURNS::Base::Stat::TestResult > *", 0, 0, (void*)0, 0};
15614
static swig_type_info _swigt__p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__DistributionFactory_t = {"_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__DistributionFactory_t", "OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionFactoryCollection *|OpenTURNS::Base::Type::Collection< OpenTURNS::Uncertainty::Model::DistributionFactory > *", 0, 0, (void*)0, 0};
15615
static swig_type_info _swigt__p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__Distribution_t = {"_p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__Distribution_t", "OpenTURNS::Uncertainty::StatTest::FittingTest::DistributionCollection *|OpenTURNS::Base::Type::Collection< OpenTURNS::Uncertainty::Model::Distribution > *", 0, 0, (void*)0, 0};
15616
static swig_type_info _swigt__p_OpenTURNS__Base__Type__Description = {"_p_OpenTURNS__Base__Type__Description", "OpenTURNS::Base::Type::Description *|OpenTURNS::Base::Stat::TestResult::Description *", 0, 0, (void*)0, 0};
15617
static swig_type_info _swigt__p_OpenTURNS__Base__Type__Indices = {"_p_OpenTURNS__Base__Type__Indices", "OpenTURNS::Uncertainty::StatTest::HypothesisTest::Indices *|OpenTURNS::Base::Type::Indices *", 0, 0, (void*)0, 0};
15618
static swig_type_info _swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OT__Uncertainty__Distribution__UserDefinedPair_t = {"_p_OpenTURNS__Base__Type__PersistentCollectionT_OT__Uncertainty__Distribution__UserDefinedPair_t", "OpenTURNS::Base::Type::PersistentCollection< OT::Uncertainty::Distribution::UserDefinedPair > *|OpenTURNS::Uncertainty::Distribution::UserDefinedPairPersistentCollection *", 0, 0, (void*)0, 0};
15619
static swig_type_info _swigt__p_OpenTURNS__PointInSourceFile = {"_p_OpenTURNS__PointInSourceFile", "OpenTURNS::PointInSourceFile *|PointInSourceFile *", 0, 0, (void*)0, 0};
15620
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__Distribution = {"_p_OpenTURNS__Uncertainty__Model__Distribution", "OpenTURNS::Uncertainty::StatTest::FittingTest::Distribution *|OpenTURNS::Uncertainty::Model::Distribution *|OpenTURNS::Uncertainty::StatTest::VisualTest::Distribution *", 0, 0, (void*)0, 0};
15621
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__Model__DistributionFactory = {"_p_OpenTURNS__Uncertainty__Model__DistributionFactory", "OpenTURNS::Uncertainty::Model::DistributionFactory *|OpenTURNS::Uncertainty::StatTest::FittingTest::Factory *", 0, 0, (void*)0, 0};
15622
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__StatTest__FittingTest = {"_p_OpenTURNS__Uncertainty__StatTest__FittingTest", "OpenTURNS::Uncertainty::StatTest::FittingTest *", 0, 0, (void*)0, 0};
15623
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__StatTest__HypothesisTest = {"_p_OpenTURNS__Uncertainty__StatTest__HypothesisTest", "OpenTURNS::Uncertainty::StatTest::HypothesisTest *", 0, 0, (void*)0, 0};
15624
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__StatTest__LinearModelTest = {"_p_OpenTURNS__Uncertainty__StatTest__LinearModelTest", "OpenTURNS::Uncertainty::StatTest::LinearModelTest *", 0, 0, (void*)0, 0};
15625
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__StatTest__NormalityTest = {"_p_OpenTURNS__Uncertainty__StatTest__NormalityTest", "OpenTURNS::Uncertainty::StatTest::NormalityTest *", 0, 0, (void*)0, 0};
15626
static swig_type_info _swigt__p_OpenTURNS__Uncertainty__StatTest__VisualTest = {"_p_OpenTURNS__Uncertainty__StatTest__VisualTest", "OpenTURNS::Uncertainty::StatTest::VisualTest *", 0, 0, (void*)0, 0};
15627
static swig_type_info _swigt__p_OptimizationProblem = {"_p_OptimizationProblem", "OptimizationProblem *", 0, 0, (void*)0, 0};
15628
static swig_type_info _swigt__p_OutOfBoundException = {"_p_OutOfBoundException", "OutOfBoundException *", 0, 0, (void*)0, 0};
15629
static swig_type_info _swigt__p_Pair = {"_p_Pair", "Pair *", 0, 0, (void*)0, 0};
15630
static swig_type_info _swigt__p_PairCollection = {"_p_PairCollection", "PairCollection *", 0, 0, (void*)0, 0};
15631
static swig_type_info _swigt__p_PersistentObject = {"_p_PersistentObject", "PersistentObject *", 0, 0, (void*)0, 0};
15632
static swig_type_info _swigt__p_PolynomialCollection = {"_p_PolynomialCollection", "PolynomialCollection *", 0, 0, (void*)0, 0};
15633
static swig_type_info _swigt__p_PolynomialPersistentCollection = {"_p_PolynomialPersistentCollection", "PolynomialPersistentCollection *", 0, 0, (void*)0, 0};
15634
static swig_type_info _swigt__p_Result = {"_p_Result", "Result *", 0, 0, (void*)0, 0};
15635
static swig_type_info _swigt__p_Severity = {"_p_Severity", "Severity *", 0, 0, (void*)0, 0};
15636
static swig_type_info _swigt__p_SobolIndiceParameters = {"_p_SobolIndiceParameters", "SobolIndiceParameters *", 0, 0, (void*)0, 0};
15637
static swig_type_info _swigt__p_SobolIndiceResult = {"_p_SobolIndiceResult", "SobolIndiceResult *", 0, 0, (void*)0, 0};
15638
static swig_type_info _swigt__p_SpecificParameters = {"_p_SpecificParameters", "SpecificParameters *", 0, 0, (void*)0, 0};
15639
static swig_type_info _swigt__p_SquareMatrix = {"_p_SquareMatrix", "SquareMatrix *", 0, 0, (void*)0, 0};
15640
static swig_type_info _swigt__p_State = {"_p_State", "State *", 0, 0, (void*)0, 0};
15641
static swig_type_info _swigt__p_StorageManager = {"_p_StorageManager", "StorageManager *", 0, 0, (void*)0, 0};
15642
static swig_type_info _swigt__p_StorageManagerImplementation = {"_p_StorageManagerImplementation", "StorageManagerImplementation *", 0, 0, (void*)0, 0};
15643
static swig_type_info _swigt__p_SymmetricMatrix = {"_p_SymmetricMatrix", "SymmetricMatrix *", 0, 0, (void*)0, 0};
15644
static swig_type_info _swigt__p_SymmetricTensor = {"_p_SymmetricTensor", "SymmetricTensor *", 0, 0, (void*)0, 0};
15645
static swig_type_info _swigt__p_Tensor = {"_p_Tensor", "Tensor *", 0, 0, (void*)0, 0};
15646
static swig_type_info _swigt__p_TestResult = {"_p_TestResult", "TestResult *", 0, 0, (void*)0, 0};
15647
static swig_type_info _swigt__p_TestResultCollection = {"_p_TestResultCollection", "TestResultCollection *", 0, 0, (void*)0, 0};
15648
static swig_type_info _swigt__p_UnsignedLongCollection = {"_p_UnsignedLongCollection", "UnsignedLongCollection *", 0, 0, (void*)0, 0};
15649
static swig_type_info _swigt__p_Value = {"_p_Value", "Value *", 0, 0, (void*)0, 0};
15650
static swig_type_info _swigt__p_ValueType = {"_p_ValueType", "ValueType *", 0, 0, (void*)0, 0};
15651
static swig_type_info _swigt__p_VariableListType = {"_p_VariableListType", "VariableListType *", 0, 0, (void*)0, 0};
15652
static swig_type_info _swigt__p_WrapperFileParsingException = {"_p_WrapperFileParsingException", "WrapperFileParsingException *", 0, 0, (void*)0, 0};
15653
static swig_type_info _swigt__p_WrapperInternalException = {"_p_WrapperInternalException", "WrapperInternalException *", 0, 0, (void*)0, 0};
15654
static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
15655
static swig_type_info _swigt__p_bool = {"_p_bool", "Bool *|OpenTURNS::Bool *|bool *", 0, 0, (void*)0, 0};
15656
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
15657
static swig_type_info _swigt__p_const_iterator = {"_p_const_iterator", "const_iterator *", 0, 0, (void*)0, 0};
15658
static swig_type_info _swigt__p_const_reverse_iterator = {"_p_const_reverse_iterator", "const_reverse_iterator *", 0, 0, (void*)0, 0};
15659
static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
15660
static swig_type_info _swigt__p_double = {"_p_double", "double *|OpenTURNS::NumericalScalar *|NumericalScalar *", 0, 0, (void*)0, 0};
15661
static swig_type_info _swigt__p_iterator = {"_p_iterator", "iterator *", 0, 0, (void*)0, 0};
15662
static swig_type_info _swigt__p_key_type = {"_p_key_type", "key_type *", 0, 0, (void*)0, 0};
15663
static swig_type_info _swigt__p_long = {"_p_long", "OpenTURNS::IndexType *|OpenTURNS::SizeType *|long *", 0, 0, (void*)0, 0};
15664
static swig_type_info _swigt__p_mapped_type = {"_p_mapped_type", "mapped_type *", 0, 0, (void*)0, 0};
15665
static swig_type_info _swigt__p_pointer_type = {"_p_pointer_type", "pointer_type *", 0, 0, (void*)0, 0};
15666
static swig_type_info _swigt__p_reverse_iterator = {"_p_reverse_iterator", "reverse_iterator *", 0, 0, (void*)0, 0};
15667
static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
15668
static swig_type_info _swigt__p_std__complexT_double_t = {"_p_std__complexT_double_t", "OpenTURNS::NumericalComplex *|NumericalComplex *|std::complex< double > *", 0, 0, (void*)0, 0};
15669
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
15670
static swig_type_info _swigt__p_std__string = {"_p_std__string", "OpenTURNS::FileName *|FileName *|std::string *|OpenTURNS::String *|String *", 0, 0, (void*)0, 0};
15671
static swig_type_info _swigt__p_swig__PySwigIterator = {"_p_swig__PySwigIterator", "swig::PySwigIterator *", 0, 0, (void*)0, 0};
15672
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "Id *|OpenTURNS::UnsignedLong *|unsigned long *|OpenTURNS::Id *", 0, 0, (void*)0, 0};
15673
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
15674
static swig_type_info _swigt__p_xNumericalSample = {"_p_xNumericalSample", "xNumericalSample *", 0, 0, (void*)0, 0};
15675
15676
static swig_type_info *swig_type_initial[] = {
15677
&_swigt__p_Antecedent,
15678
&_swigt__p_ArchimedeanCopula,
15679
&_swigt__p_BoolCollection,
15680
&_swigt__p_BoolPersistentCollection,
15681
&_swigt__p_BoundingBox,
15682
&_swigt__p_CacheImplementation,
15683
&_swigt__p_CacheKeyType,
15684
&_swigt__p_CacheType,
15685
&_swigt__p_CacheValueType,
15686
&_swigt__p_Coefficients,
15687
&_swigt__p_ComparisonOperator,
15688
&_swigt__p_ConfidenceIntervalCollection,
15689
&_swigt__p_ConfidenceIntervalPersistentCollection,
15690
&_swigt__p_Copula,
15691
&_swigt__p_CopulaCollection,
15692
&_swigt__p_CopulaImplementation,
15693
&_swigt__p_CopulaPersistentCollection,
15694
&_swigt__p_CorrelationMatrix,
15695
&_swigt__p_CovarianceMatrix,
15696
&_swigt__p_Description,
15697
&_swigt__p_DirectoryList,
15698
&_swigt__p_DiscreteDistribution,
15699
&_swigt__p_Distribution,
15700
&_swigt__p_DistributionCollection,
15701
&_swigt__p_DistributionFactory,
15702
&_swigt__p_DistributionFactoryCollection,
15703
&_swigt__p_DistributionImplementation,
15704
&_swigt__p_DistributionImplementationFactory,
15705
&_swigt__p_DistributionPersistentCollection,
15706
&_swigt__p_DrawableCollection,
15707
&_swigt__p_DrawablePersistentCollection,
15708
&_swigt__p_ElementType,
15709
&_swigt__p_EllipticalDistribution,
15710
&_swigt__p_EvaluationImplementation,
15711
&_swigt__p_Factory,
15712
&_swigt__p_FileListType,
15713
&_swigt__p_FileNotFoundException,
15714
&_swigt__p_Format,
15715
&_swigt__p_FunctionalChaosResult,
15716
&_swigt__p_GradientImplementation,
15717
&_swigt__p_Graph,
15718
&_swigt__p_GraphCollection,
15719
&_swigt__p_HessianImplementation,
15720
&_swigt__p_IdentityMatrix,
15721
&_swigt__p_Implementation,
15722
&_swigt__p_ImplementationAsPersistentObject,
15723
&_swigt__p_ImplementationElementType,
15724
&_swigt__p_ImplementationType,
15725
&_swigt__p_Indices,
15726
&_swigt__p_InternalException,
15727
&_swigt__p_InternalFunction,
15728
&_swigt__p_InternalGradient,
15729
&_swigt__p_InternalHessian,
15730
&_swigt__p_InternalType,
15731
&_swigt__p_Interval,
15732
&_swigt__p_InvalidArgumentException,
15733
&_swigt__p_InvalidDimensionException,
15734
&_swigt__p_InverseIsoProbabilisticTransformation,
15735
&_swigt__p_IsoProbabilisticTransformation,
15736
&_swigt__p_KeyType,
15737
&_swigt__p_LabelMap,
15738
&_swigt__p_LinearModel,
15739
&_swigt__p_Map,
15740
&_swigt__p_MapElement,
15741
&_swigt__p_MappedType,
15742
&_swigt__p_Matrix,
15743
&_swigt__p_MersenneTwister,
15744
&_swigt__p_NoWrapperFileFoundException,
15745
&_swigt__p_NonEllipticalDistribution,
15746
&_swigt__p_Normal,
15747
&_swigt__p_NotDefinedException,
15748
&_swigt__p_NotSymmetricDefinitePositiveException,
15749
&_swigt__p_NumericalComplexCollection,
15750
&_swigt__p_NumericalComplexPersistentCollection,
15751
&_swigt__p_NumericalMathFunction,
15752
&_swigt__p_NumericalMathFunctionCollection,
15753
&_swigt__p_NumericalMathFunctionPersistentCollection,
15754
&_swigt__p_NumericalPoint,
15755
&_swigt__p_NumericalPointCollection,
15756
&_swigt__p_NumericalPointWithDescription,
15757
&_swigt__p_NumericalPointWithDescriptionCollection,
15758
&_swigt__p_NumericalSample,
15759
&_swigt__p_NumericalScalarCollection,
15760
&_swigt__p_NumericalScalarPersistentCollection,
15761
&_swigt__p_OT__Base__Optim__AbdoRackwitzSpecificParameters,
15762
&_swigt__p_OT__Base__Optim__CobylaSpecificParameters,
15763
&_swigt__p_OT__Base__Optim__NearestPointAlgorithmImplementation__Result,
15764
&_swigt__p_OT__Base__Optim__NearestPointChecker__Result,
15765
&_swigt__p_OT__Base__Optim__SQPSpecificParameters,
15766
&_swigt__p_OT__Base__Optim__TNCSpecificParameters,
15767
&_swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters,
15768
&_swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult,
15769
&_swigt__p_OT__Base__Stat__RandomGeneratorState,
15770
&_swigt__p_OT__Uncertainty__Distribution__HistogramPair,
15771
&_swigt__p_OT__Uncertainty__Distribution__UserDefinedPair,
15772
&_swigt__p_OpenTURNS__Base__Common__ComparisonOperator,
15773
&_swigt__p_OpenTURNS__Base__Common__ComparisonOperatorImplementation,
15774
&_swigt__p_OpenTURNS__Base__Common__Equal,
15775
&_swigt__p_OpenTURNS__Base__Common__Greater,
15776
&_swigt__p_OpenTURNS__Base__Common__GreaterOrEqual,
15777
&_swigt__p_OpenTURNS__Base__Common__InterfaceObject,
15778
&_swigt__p_OpenTURNS__Base__Common__Less,
15779
&_swigt__p_OpenTURNS__Base__Common__LessOrEqual,
15780
&_swigt__p_OpenTURNS__Base__Common__Object,
15781
&_swigt__p_OpenTURNS__Base__Common__PersistentObject,
15782
&_swigt__p_OpenTURNS__Base__Common__StorageManager,
15783
&_swigt__p_OpenTURNS__Base__Common__Study,
15784
&_swigt__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t,
15785
&_swigt__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t,
15786
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Common__ComparisonOperatorImplementation_t,
15787
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__NumericalMathFunctionImplementation_t,
15788
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__UniVariatePolynomialImplementation_t,
15789
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__DrawableImplementation_t,
15790
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__GraphImplementation_t,
15791
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation_t,
15792
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation_t,
15793
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Solver__SolverImplementation_t,
15794
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__HistoryStrategyImplementation_t,
15795
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation_t,
15796
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t,
15797
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t,
15798
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__MatrixImplementation_t,
15799
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__TensorImplementation_t,
15800
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory_t,
15801
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementation_t,
15802
&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__RandomVectorImplementation_t,
15803
&_swigt__p_OpenTURNS__Base__Common__XMLStorageManager,
15804
&_swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient,
15805
&_swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian,
15806
&_swigt__p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient,
15807
&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation,
15808
&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathFunction,
15809
&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation,
15810
&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation,
15811
&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation,
15812
&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation,
15813
&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation,
15814
&_swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation,
15815
&_swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation,
15816
&_swigt__p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation,
15817
&_swigt__p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation,
15818
&_swigt__p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation,
15819
&_swigt__p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation,
15820
&_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation,
15821
&_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathFunction,
15822
&_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation,
15823
&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation,
15824
&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation,
15825
&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation,
15826
&_swigt__p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation,
15827
&_swigt__p_OpenTURNS__Base__Func__NumericalMathFunction,
15828
&_swigt__p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation,
15829
&_swigt__p_OpenTURNS__Base__Func__NumericalMathGradientImplementation,
15830
&_swigt__p_OpenTURNS__Base__Func__NumericalMathHessianImplementation,
15831
&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation,
15832
&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathFunction,
15833
&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation,
15834
&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation,
15835
&_swigt__p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation,
15836
&_swigt__p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation,
15837
&_swigt__p_OpenTURNS__Base__Func__UniVariatePolynomial,
15838
&_swigt__p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation,
15839
&_swigt__p_OpenTURNS__Base__Func__WrapperData,
15840
&_swigt__p_OpenTURNS__Base__Func__WrapperDataFile,
15841
&_swigt__p_OpenTURNS__Base__Func__WrapperDataVariable,
15842
&_swigt__p_OpenTURNS__Base__Func__WrapperFile,
15843
&_swigt__p_OpenTURNS__Base__Func__WrapperFrameworkData,
15844
&_swigt__p_OpenTURNS__Base__Func__WrapperFunctionDescription,
15845
&_swigt__p_OpenTURNS__Base__Func__WrapperParameter,
15846
&_swigt__p_OpenTURNS__Base__Graph__BarPlot,
15847
&_swigt__p_OpenTURNS__Base__Graph__Cloud,
15848
&_swigt__p_OpenTURNS__Base__Graph__Contour,
15849
&_swigt__p_OpenTURNS__Base__Graph__Curve,
15850
&_swigt__p_OpenTURNS__Base__Graph__Drawable,
15851
&_swigt__p_OpenTURNS__Base__Graph__DrawableImplementation,
15852
&_swigt__p_OpenTURNS__Base__Graph__Graph,
15853
&_swigt__p_OpenTURNS__Base__Graph__GraphImplementation,
15854
&_swigt__p_OpenTURNS__Base__Graph__Pie,
15855
&_swigt__p_OpenTURNS__Base__Graph__Staircase,
15856
&_swigt__p_OpenTURNS__Base__Optim__AbdoRackwitz,
15857
&_swigt__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithm,
15858
&_swigt__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation,
15859
&_swigt__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationResult,
15860
&_swigt__p_OpenTURNS__Base__Optim__Cobyla,
15861
&_swigt__p_OpenTURNS__Base__Optim__NearestPointAlgorithm,
15862
&_swigt__p_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation,
15863
&_swigt__p_OpenTURNS__Base__Optim__NearestPointChecker,
15864
&_swigt__p_OpenTURNS__Base__Optim__PenalizedLeastSquaresAlgorithm,
15865
&_swigt__p_OpenTURNS__Base__Optim__SQP,
15866
&_swigt__p_OpenTURNS__Base__Optim__TNC,
15867
&_swigt__p_OpenTURNS__Base__Solver__Bisection,
15868
&_swigt__p_OpenTURNS__Base__Solver__Brent,
15869
&_swigt__p_OpenTURNS__Base__Solver__Secant,
15870
&_swigt__p_OpenTURNS__Base__Solver__Solver,
15871
&_swigt__p_OpenTURNS__Base__Solver__SolverImplementation,
15872
&_swigt__p_OpenTURNS__Base__Stat__Compact,
15873
&_swigt__p_OpenTURNS__Base__Stat__ConfidenceInterval,
15874
&_swigt__p_OpenTURNS__Base__Stat__CorrelationMatrix,
15875
&_swigt__p_OpenTURNS__Base__Stat__CovarianceMatrix,
15876
&_swigt__p_OpenTURNS__Base__Stat__Full,
15877
&_swigt__p_OpenTURNS__Base__Stat__HaltonSequence,
15878
&_swigt__p_OpenTURNS__Base__Stat__HistoryStrategy,
15879
&_swigt__p_OpenTURNS__Base__Stat__HistoryStrategyImplementation,
15880
&_swigt__p_OpenTURNS__Base__Stat__Last,
15881
&_swigt__p_OpenTURNS__Base__Stat__LinearModel,
15882
&_swigt__p_OpenTURNS__Base__Stat__LowDiscrepancySequence,
15883
&_swigt__p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation,
15884
&_swigt__p_OpenTURNS__Base__Stat__Null,
15885
&_swigt__p_OpenTURNS__Base__Stat__NumericalSample,
15886
&_swigt__p_OpenTURNS__Base__Stat__NumericalSampleImplementation,
15887
&_swigt__p_OpenTURNS__Base__Stat__SobolSequence,
15888
&_swigt__p_OpenTURNS__Base__Stat__TestResult,
15889
&_swigt__p_OpenTURNS__Base__Type__CollectionT_OT__Uncertainty__Distribution__HistogramPair_t,
15890
&_swigt__p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t,
15891
&_swigt__p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__DistributionFactory_t,
15892
&_swigt__p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__Distribution_t,
15893
&_swigt__p_OpenTURNS__Base__Type__Description,
15894
&_swigt__p_OpenTURNS__Base__Type__DescriptionImplementation,
15895
&_swigt__p_OpenTURNS__Base__Type__IdentityMatrix,
15896
&_swigt__p_OpenTURNS__Base__Type__Indices,
15897
&_swigt__p_OpenTURNS__Base__Type__Interval,
15898
&_swigt__p_OpenTURNS__Base__Type__Matrix,
15899
&_swigt__p_OpenTURNS__Base__Type__MatrixImplementation,
15900
&_swigt__p_OpenTURNS__Base__Type__NumericalPoint,
15901
&_swigt__p_OpenTURNS__Base__Type__NumericalPointWithDescription,
15902
&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OT__Uncertainty__Distribution__UserDefinedPair_t,
15903
&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_t,
15904
&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_t,
15905
&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_t,
15906
&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_double_t,
15907
&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_t,
15908
&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_t,
15909
&_swigt__p_OpenTURNS__Base__Type__SquareMatrix,
15910
&_swigt__p_OpenTURNS__Base__Type__SymmetricMatrix,
15911
&_swigt__p_OpenTURNS__Base__Type__SymmetricTensor,
15912
&_swigt__p_OpenTURNS__Base__Type__Tensor,
15913
&_swigt__p_OpenTURNS__Base__Type__TensorImplementation,
15914
&_swigt__p_OpenTURNS__PointInSourceFile,
15915
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Beta,
15916
&_swigt__p_OpenTURNS__Uncertainty__Distribution__BetaFactory,
15917
&_swigt__p_OpenTURNS__Uncertainty__Distribution__ChiSquare,
15918
&_swigt__p_OpenTURNS__Uncertainty__Distribution__ChiSquareFactory,
15919
&_swigt__p_OpenTURNS__Uncertainty__Distribution__ClaytonCopula,
15920
&_swigt__p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaFactory,
15921
&_swigt__p_OpenTURNS__Uncertainty__Distribution__ComposedCopula,
15922
&_swigt__p_OpenTURNS__Uncertainty__Distribution__ComposedDistribution,
15923
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Epanechnikov,
15924
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Exponential,
15925
&_swigt__p_OpenTURNS__Uncertainty__Distribution__ExponentialFactory,
15926
&_swigt__p_OpenTURNS__Uncertainty__Distribution__FrankCopula,
15927
&_swigt__p_OpenTURNS__Uncertainty__Distribution__FrankCopulaFactory,
15928
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Gamma,
15929
&_swigt__p_OpenTURNS__Uncertainty__Distribution__GammaFactory,
15930
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Geometric,
15931
&_swigt__p_OpenTURNS__Uncertainty__Distribution__GeometricFactory,
15932
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Gumbel,
15933
&_swigt__p_OpenTURNS__Uncertainty__Distribution__GumbelCopula,
15934
&_swigt__p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaFactory,
15935
&_swigt__p_OpenTURNS__Uncertainty__Distribution__GumbelFactory,
15936
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Histogram,
15937
&_swigt__p_OpenTURNS__Uncertainty__Distribution__HistogramFactory,
15938
&_swigt__p_OpenTURNS__Uncertainty__Distribution__IndependentCopula,
15939
&_swigt__p_OpenTURNS__Uncertainty__Distribution__KernelMixture,
15940
&_swigt__p_OpenTURNS__Uncertainty__Distribution__KernelSmoothing,
15941
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Laplace,
15942
&_swigt__p_OpenTURNS__Uncertainty__Distribution__LaplaceFactory,
15943
&_swigt__p_OpenTURNS__Uncertainty__Distribution__LogNormal,
15944
&_swigt__p_OpenTURNS__Uncertainty__Distribution__LogNormalFactory,
15945
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Logistic,
15946
&_swigt__p_OpenTURNS__Uncertainty__Distribution__LogisticFactory,
15947
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Mixture,
15948
&_swigt__p_OpenTURNS__Uncertainty__Distribution__MultiNomial,
15949
&_swigt__p_OpenTURNS__Uncertainty__Distribution__MultiNomialFactory,
15950
&_swigt__p_OpenTURNS__Uncertainty__Distribution__NonCentralStudent,
15951
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Normal,
15952
&_swigt__p_OpenTURNS__Uncertainty__Distribution__NormalCopula,
15953
&_swigt__p_OpenTURNS__Uncertainty__Distribution__NormalCopulaFactory,
15954
&_swigt__p_OpenTURNS__Uncertainty__Distribution__NormalFactory,
15955
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Poisson,
15956
&_swigt__p_OpenTURNS__Uncertainty__Distribution__PoissonFactory,
15957
&_swigt__p_OpenTURNS__Uncertainty__Distribution__RandomMixture,
15958
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Rayleigh,
15959
&_swigt__p_OpenTURNS__Uncertainty__Distribution__RayleighFactory,
15960
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Student,
15961
&_swigt__p_OpenTURNS__Uncertainty__Distribution__StudentFactory,
15962
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Triangular,
15963
&_swigt__p_OpenTURNS__Uncertainty__Distribution__TriangularFactory,
15964
&_swigt__p_OpenTURNS__Uncertainty__Distribution__TruncatedDistribution,
15965
&_swigt__p_OpenTURNS__Uncertainty__Distribution__TruncatedNormal,
15966
&_swigt__p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalFactory,
15967
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Uniform,
15968
&_swigt__p_OpenTURNS__Uncertainty__Distribution__UniformFactory,
15969
&_swigt__p_OpenTURNS__Uncertainty__Distribution__UserDefined,
15970
&_swigt__p_OpenTURNS__Uncertainty__Distribution__UserDefinedFactory,
15971
&_swigt__p_OpenTURNS__Uncertainty__Distribution__Weibull,
15972
&_swigt__p_OpenTURNS__Uncertainty__Distribution__WeibullFactory,
15973
&_swigt__p_OpenTURNS__Uncertainty__Model__ArchimedeanCopula,
15974
&_swigt__p_OpenTURNS__Uncertainty__Model__CompositeRandomVector,
15975
&_swigt__p_OpenTURNS__Uncertainty__Model__ConditionalRandomVector,
15976
&_swigt__p_OpenTURNS__Uncertainty__Model__ConstantRandomVector,
15977
&_swigt__p_OpenTURNS__Uncertainty__Model__ContinuousDistribution,
15978
&_swigt__p_OpenTURNS__Uncertainty__Model__Copula,
15979
&_swigt__p_OpenTURNS__Uncertainty__Model__CopulaImplementation,
15980
&_swigt__p_OpenTURNS__Uncertainty__Model__DiscreteDistribution,
15981
&_swigt__p_OpenTURNS__Uncertainty__Model__Distribution,
15982
&_swigt__p_OpenTURNS__Uncertainty__Model__DistributionFactory,
15983
&_swigt__p_OpenTURNS__Uncertainty__Model__DistributionImplementation,
15984
&_swigt__p_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory,
15985
&_swigt__p_OpenTURNS__Uncertainty__Model__EllipticalDistribution,
15986
&_swigt__p_OpenTURNS__Uncertainty__Model__Event,
15987
&_swigt__p_OpenTURNS__Uncertainty__Model__EventRandomVectorImplementation,
15988
&_swigt__p_OpenTURNS__Uncertainty__Model__NonEllipticalDistribution,
15989
&_swigt__p_OpenTURNS__Uncertainty__Model__RandomVector,
15990
&_swigt__p_OpenTURNS__Uncertainty__Model__RandomVectorImplementation,
15991
&_swigt__p_OpenTURNS__Uncertainty__Model__SklarCopula,
15992
&_swigt__p_OpenTURNS__Uncertainty__Model__StandardEvent,
15993
&_swigt__p_OpenTURNS__Uncertainty__Model__UsualDistribution,
15994
&_swigt__p_OpenTURNS__Uncertainty__Model__UsualRandomVector,
15995
&_swigt__p_OpenTURNS__Uncertainty__StatTest__FittingTest,
15996
&_swigt__p_OpenTURNS__Uncertainty__StatTest__HypothesisTest,
15997
&_swigt__p_OpenTURNS__Uncertainty__StatTest__LinearModelTest,
15998
&_swigt__p_OpenTURNS__Uncertainty__StatTest__NormalityTest,
15999
&_swigt__p_OpenTURNS__Uncertainty__StatTest__VisualTest,
16000
&_swigt__p_OptimizationProblem,
16001
&_swigt__p_OutOfBoundException,
16002
&_swigt__p_Pair,
16003
&_swigt__p_PairCollection,
16004
&_swigt__p_PersistentObject,
16005
&_swigt__p_PolynomialCollection,
16006
&_swigt__p_PolynomialPersistentCollection,
16007
&_swigt__p_Result,
16008
&_swigt__p_Severity,
16009
&_swigt__p_SobolIndiceParameters,
16010
&_swigt__p_SobolIndiceResult,
16011
&_swigt__p_SpecificParameters,
16012
&_swigt__p_SquareMatrix,
16013
&_swigt__p_State,
16014
&_swigt__p_StorageManager,
16015
&_swigt__p_StorageManagerImplementation,
16016
&_swigt__p_SymmetricMatrix,
16017
&_swigt__p_SymmetricTensor,
16018
&_swigt__p_Tensor,
16019
&_swigt__p_TestResult,
16020
&_swigt__p_TestResultCollection,
16021
&_swigt__p_UnsignedLongCollection,
16022
&_swigt__p_Value,
16023
&_swigt__p_ValueType,
16024
&_swigt__p_VariableListType,
16025
&_swigt__p_WrapperFileParsingException,
16026
&_swigt__p_WrapperInternalException,
16027
&_swigt__p_allocator_type,
16028
&_swigt__p_bool,
16029
&_swigt__p_char,
16030
&_swigt__p_const_iterator,
16031
&_swigt__p_const_reverse_iterator,
16032
&_swigt__p_difference_type,
16033
&_swigt__p_double,
16034
&_swigt__p_iterator,
16035
&_swigt__p_key_type,
16036
&_swigt__p_long,
16037
&_swigt__p_mapped_type,
16038
&_swigt__p_pointer_type,
16039
&_swigt__p_reverse_iterator,
16040
&_swigt__p_size_type,
16041
&_swigt__p_std__complexT_double_t,
16042
&_swigt__p_std__invalid_argument,
16043
&_swigt__p_std__string,
16044
&_swigt__p_swig__PySwigIterator,
16045
&_swigt__p_unsigned_long,
16046
&_swigt__p_value_type,
16047
&_swigt__p_xNumericalSample,
16048
};
16049
16050
static swig_cast_info _swigc__p_Antecedent[] = { {&_swigt__p_Antecedent, 0, 0, 0},{0, 0, 0, 0}};
16051
static swig_cast_info _swigc__p_ArchimedeanCopula[] = { {&_swigt__p_ArchimedeanCopula, 0, 0, 0},{0, 0, 0, 0}};
16052
static swig_cast_info _swigc__p_BoolCollection[] = { {&_swigt__p_BoolCollection, 0, 0, 0},{0, 0, 0, 0}};
16053
static swig_cast_info _swigc__p_BoolPersistentCollection[] = { {&_swigt__p_BoolPersistentCollection, 0, 0, 0},{0, 0, 0, 0}};
16054
static swig_cast_info _swigc__p_BoundingBox[] = { {&_swigt__p_BoundingBox, 0, 0, 0},{0, 0, 0, 0}};
16055
static swig_cast_info _swigc__p_CacheImplementation[] = { {&_swigt__p_CacheImplementation, 0, 0, 0},{0, 0, 0, 0}};
16056
static swig_cast_info _swigc__p_CacheKeyType[] = { {&_swigt__p_CacheKeyType, 0, 0, 0},{0, 0, 0, 0}};
16057
static swig_cast_info _swigc__p_CacheType[] = { {&_swigt__p_CacheType, 0, 0, 0},{0, 0, 0, 0}};
16058
static swig_cast_info _swigc__p_CacheValueType[] = { {&_swigt__p_CacheValueType, 0, 0, 0},{0, 0, 0, 0}};
16059
static swig_cast_info _swigc__p_Coefficients[] = { {&_swigt__p_Coefficients, 0, 0, 0},{0, 0, 0, 0}};
16060
static swig_cast_info _swigc__p_ComparisonOperator[] = { {&_swigt__p_ComparisonOperator, 0, 0, 0},{0, 0, 0, 0}};
16061
static swig_cast_info _swigc__p_ConfidenceIntervalCollection[] = { {&_swigt__p_ConfidenceIntervalCollection, 0, 0, 0},{0, 0, 0, 0}};
16062
static swig_cast_info _swigc__p_ConfidenceIntervalPersistentCollection[] = { {&_swigt__p_ConfidenceIntervalPersistentCollection, 0, 0, 0},{0, 0, 0, 0}};
16063
static swig_cast_info _swigc__p_Copula[] = { {&_swigt__p_Copula, 0, 0, 0},{0, 0, 0, 0}};
16064
static swig_cast_info _swigc__p_CopulaCollection[] = { {&_swigt__p_CopulaCollection, 0, 0, 0},{0, 0, 0, 0}};
16065
static swig_cast_info _swigc__p_CopulaImplementation[] = { {&_swigt__p_CopulaImplementation, 0, 0, 0},{0, 0, 0, 0}};
16066
static swig_cast_info _swigc__p_CopulaPersistentCollection[] = { {&_swigt__p_CopulaPersistentCollection, 0, 0, 0},{0, 0, 0, 0}};
16067
static swig_cast_info _swigc__p_CorrelationMatrix[] = { {&_swigt__p_CorrelationMatrix, 0, 0, 0},{0, 0, 0, 0}};
16068
static swig_cast_info _swigc__p_CovarianceMatrix[] = { {&_swigt__p_CovarianceMatrix, 0, 0, 0},{0, 0, 0, 0}};
16069
static swig_cast_info _swigc__p_Description[] = { {&_swigt__p_Description, 0, 0, 0},{0, 0, 0, 0}};
16070
static swig_cast_info _swigc__p_DirectoryList[] = { {&_swigt__p_DirectoryList, 0, 0, 0},{0, 0, 0, 0}};
16071
static swig_cast_info _swigc__p_DiscreteDistribution[] = { {&_swigt__p_DiscreteDistribution, 0, 0, 0},{0, 0, 0, 0}};
16072
static swig_cast_info _swigc__p_Distribution[] = { {&_swigt__p_Distribution, 0, 0, 0},{0, 0, 0, 0}};
16073
static swig_cast_info _swigc__p_DistributionCollection[] = { {&_swigt__p_DistributionCollection, 0, 0, 0},{0, 0, 0, 0}};
16074
static swig_cast_info _swigc__p_DistributionFactory[] = { {&_swigt__p_DistributionFactory, 0, 0, 0},{0, 0, 0, 0}};
16075
static swig_cast_info _swigc__p_DistributionFactoryCollection[] = { {&_swigt__p_DistributionFactoryCollection, 0, 0, 0},{0, 0, 0, 0}};
16076
static swig_cast_info _swigc__p_DistributionImplementation[] = { {&_swigt__p_DistributionImplementation, 0, 0, 0},{0, 0, 0, 0}};
16077
static swig_cast_info _swigc__p_DistributionImplementationFactory[] = { {&_swigt__p_DistributionImplementationFactory, 0, 0, 0},{0, 0, 0, 0}};
16078
static swig_cast_info _swigc__p_DistributionPersistentCollection[] = { {&_swigt__p_DistributionPersistentCollection, 0, 0, 0},{0, 0, 0, 0}};
16079
static swig_cast_info _swigc__p_DrawableCollection[] = { {&_swigt__p_DrawableCollection, 0, 0, 0},{0, 0, 0, 0}};
16080
static swig_cast_info _swigc__p_DrawablePersistentCollection[] = { {&_swigt__p_DrawablePersistentCollection, 0, 0, 0},{0, 0, 0, 0}};
16081
static swig_cast_info _swigc__p_ElementType[] = { {&_swigt__p_ElementType, 0, 0, 0},{0, 0, 0, 0}};
16082
static swig_cast_info _swigc__p_EllipticalDistribution[] = { {&_swigt__p_EllipticalDistribution, 0, 0, 0},{0, 0, 0, 0}};
16083
static swig_cast_info _swigc__p_EvaluationImplementation[] = { {&_swigt__p_EvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
16084
static swig_cast_info _swigc__p_Factory[] = { {&_swigt__p_Factory, 0, 0, 0},{0, 0, 0, 0}};
16085
static swig_cast_info _swigc__p_FileListType[] = { {&_swigt__p_FileListType, 0, 0, 0},{0, 0, 0, 0}};
16086
static swig_cast_info _swigc__p_FileNotFoundException[] = { {&_swigt__p_FileNotFoundException, 0, 0, 0},{0, 0, 0, 0}};
16087
static swig_cast_info _swigc__p_Format[] = { {&_swigt__p_Format, 0, 0, 0},{0, 0, 0, 0}};
16088
static swig_cast_info _swigc__p_FunctionalChaosResult[] = { {&_swigt__p_FunctionalChaosResult, 0, 0, 0},{0, 0, 0, 0}};
16089
static swig_cast_info _swigc__p_GradientImplementation[] = { {&_swigt__p_GradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
16090
static swig_cast_info _swigc__p_Graph[] = { {&_swigt__p_Graph, 0, 0, 0},{0, 0, 0, 0}};
16091
static swig_cast_info _swigc__p_GraphCollection[] = { {&_swigt__p_GraphCollection, 0, 0, 0},{0, 0, 0, 0}};
16092
static swig_cast_info _swigc__p_HessianImplementation[] = { {&_swigt__p_HessianImplementation, 0, 0, 0},{0, 0, 0, 0}};
16093
static swig_cast_info _swigc__p_IdentityMatrix[] = { {&_swigt__p_IdentityMatrix, 0, 0, 0},{0, 0, 0, 0}};
16094
static swig_cast_info _swigc__p_Implementation[] = { {&_swigt__p_Implementation, 0, 0, 0},{0, 0, 0, 0}};
16095
static swig_cast_info _swigc__p_ImplementationAsPersistentObject[] = { {&_swigt__p_ImplementationAsPersistentObject, 0, 0, 0},{0, 0, 0, 0}};
16096
static swig_cast_info _swigc__p_ImplementationElementType[] = { {&_swigt__p_ImplementationElementType, 0, 0, 0},{0, 0, 0, 0}};
16097
static swig_cast_info _swigc__p_ImplementationType[] = { {&_swigt__p_ImplementationType, 0, 0, 0},{0, 0, 0, 0}};
16098
static swig_cast_info _swigc__p_Indices[] = { {&_swigt__p_Indices, 0, 0, 0},{0, 0, 0, 0}};
16099
static swig_cast_info _swigc__p_InternalException[] = { {&_swigt__p_InternalException, 0, 0, 0},{0, 0, 0, 0}};
16100
static swig_cast_info _swigc__p_InternalFunction[] = { {&_swigt__p_InternalFunction, 0, 0, 0},{0, 0, 0, 0}};
16101
static swig_cast_info _swigc__p_InternalGradient[] = { {&_swigt__p_InternalGradient, 0, 0, 0},{0, 0, 0, 0}};
16102
static swig_cast_info _swigc__p_InternalHessian[] = { {&_swigt__p_InternalHessian, 0, 0, 0},{0, 0, 0, 0}};
16103
static swig_cast_info _swigc__p_InternalType[] = { {&_swigt__p_InternalType, 0, 0, 0},{0, 0, 0, 0}};
16104
static swig_cast_info _swigc__p_Interval[] = { {&_swigt__p_Interval, 0, 0, 0},{0, 0, 0, 0}};
16105
static swig_cast_info _swigc__p_InvalidArgumentException[] = { {&_swigt__p_InvalidArgumentException, 0, 0, 0},{0, 0, 0, 0}};
16106
static swig_cast_info _swigc__p_InvalidDimensionException[] = { {&_swigt__p_InvalidDimensionException, 0, 0, 0},{0, 0, 0, 0}};
16107
static swig_cast_info _swigc__p_InverseIsoProbabilisticTransformation[] = { {&_swigt__p_InverseIsoProbabilisticTransformation, 0, 0, 0},{0, 0, 0, 0}};
16108
static swig_cast_info _swigc__p_IsoProbabilisticTransformation[] = { {&_swigt__p_IsoProbabilisticTransformation, 0, 0, 0},{0, 0, 0, 0}};
16109
static swig_cast_info _swigc__p_KeyType[] = { {&_swigt__p_KeyType, 0, 0, 0},{0, 0, 0, 0}};
16110
static swig_cast_info _swigc__p_LabelMap[] = { {&_swigt__p_LabelMap, 0, 0, 0},{0, 0, 0, 0}};
16111
static swig_cast_info _swigc__p_LinearModel[] = { {&_swigt__p_LinearModel, 0, 0, 0},{0, 0, 0, 0}};
16112
static swig_cast_info _swigc__p_Map[] = { {&_swigt__p_Map, 0, 0, 0},{0, 0, 0, 0}};
16113
static swig_cast_info _swigc__p_MapElement[] = { {&_swigt__p_MapElement, 0, 0, 0},{0, 0, 0, 0}};
16114
static swig_cast_info _swigc__p_MappedType[] = { {&_swigt__p_MappedType, 0, 0, 0},{0, 0, 0, 0}};
16115
static swig_cast_info _swigc__p_Matrix[] = { {&_swigt__p_Matrix, 0, 0, 0},{0, 0, 0, 0}};
16116
static swig_cast_info _swigc__p_MersenneTwister[] = { {&_swigt__p_MersenneTwister, 0, 0, 0},{0, 0, 0, 0}};
16117
static swig_cast_info _swigc__p_NoWrapperFileFoundException[] = { {&_swigt__p_NoWrapperFileFoundException, 0, 0, 0},{0, 0, 0, 0}};
16118
static swig_cast_info _swigc__p_NonEllipticalDistribution[] = { {&_swigt__p_NonEllipticalDistribution, 0, 0, 0},{0, 0, 0, 0}};
16119
static swig_cast_info _swigc__p_Normal[] = { {&_swigt__p_Normal, 0, 0, 0},{0, 0, 0, 0}};
16120
static swig_cast_info _swigc__p_NotDefinedException[] = { {&_swigt__p_NotDefinedException, 0, 0, 0},{0, 0, 0, 0}};
16121
static swig_cast_info _swigc__p_NotSymmetricDefinitePositiveException[] = { {&_swigt__p_NotSymmetricDefinitePositiveException, 0, 0, 0},{0, 0, 0, 0}};
16122
static swig_cast_info _swigc__p_NumericalComplexCollection[] = { {&_swigt__p_NumericalComplexCollection, 0, 0, 0},{0, 0, 0, 0}};
16123
static swig_cast_info _swigc__p_NumericalComplexPersistentCollection[] = { {&_swigt__p_NumericalComplexPersistentCollection, 0, 0, 0},{0, 0, 0, 0}};
16124
static swig_cast_info _swigc__p_NumericalMathFunction[] = { {&_swigt__p_NumericalMathFunction, 0, 0, 0},{0, 0, 0, 0}};
16125
static swig_cast_info _swigc__p_NumericalMathFunctionCollection[] = { {&_swigt__p_NumericalMathFunctionCollection, 0, 0, 0},{0, 0, 0, 0}};
16126
static swig_cast_info _swigc__p_NumericalMathFunctionPersistentCollection[] = { {&_swigt__p_NumericalMathFunctionPersistentCollection, 0, 0, 0},{0, 0, 0, 0}};
16127
static swig_cast_info _swigc__p_NumericalPoint[] = { {&_swigt__p_NumericalPoint, 0, 0, 0},{0, 0, 0, 0}};
16128
static swig_cast_info _swigc__p_NumericalPointCollection[] = { {&_swigt__p_NumericalPointCollection, 0, 0, 0},{0, 0, 0, 0}};
16129
static swig_cast_info _swigc__p_NumericalPointWithDescription[] = { {&_swigt__p_NumericalPointWithDescription, 0, 0, 0},{0, 0, 0, 0}};
16130
static swig_cast_info _swigc__p_NumericalPointWithDescriptionCollection[] = { {&_swigt__p_NumericalPointWithDescriptionCollection, 0, 0, 0},{0, 0, 0, 0}};
16131
static swig_cast_info _swigc__p_NumericalSample[] = { {&_swigt__p_NumericalSample, 0, 0, 0},{0, 0, 0, 0}};
16132
static swig_cast_info _swigc__p_NumericalScalarCollection[] = { {&_swigt__p_NumericalScalarCollection, 0, 0, 0},{0, 0, 0, 0}};
16133
static swig_cast_info _swigc__p_NumericalScalarPersistentCollection[] = { {&_swigt__p_NumericalScalarPersistentCollection, 0, 0, 0},{0, 0, 0, 0}};
16134
static swig_cast_info _swigc__p_OT__Base__Optim__AbdoRackwitzSpecificParameters[] = { {&_swigt__p_OT__Base__Optim__AbdoRackwitzSpecificParameters, 0, 0, 0},{0, 0, 0, 0}};
16135
static swig_cast_info _swigc__p_OT__Base__Optim__CobylaSpecificParameters[] = { {&_swigt__p_OT__Base__Optim__CobylaSpecificParameters, 0, 0, 0},{0, 0, 0, 0}};
16136
static swig_cast_info _swigc__p_OT__Base__Optim__NearestPointAlgorithmImplementation__Result[] = { {&_swigt__p_OT__Base__Optim__NearestPointAlgorithmImplementation__Result, 0, 0, 0},{0, 0, 0, 0}};
16137
static swig_cast_info _swigc__p_OT__Base__Optim__NearestPointChecker__Result[] = { {&_swigt__p_OT__Base__Optim__NearestPointChecker__Result, 0, 0, 0},{0, 0, 0, 0}};
16138
static swig_cast_info _swigc__p_OT__Base__Optim__SQPSpecificParameters[] = { {&_swigt__p_OT__Base__Optim__SQPSpecificParameters, 0, 0, 0},{0, 0, 0, 0}};
16139
static swig_cast_info _swigc__p_OT__Base__Optim__TNCSpecificParameters[] = { {&_swigt__p_OT__Base__Optim__TNCSpecificParameters, 0, 0, 0},{0, 0, 0, 0}};
16140
static swig_cast_info _swigc__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters[] = { {&_swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters, 0, 0, 0},{0, 0, 0, 0}};
16141
static swig_cast_info _swigc__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult[] = { {&_swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult, 0, 0, 0},{0, 0, 0, 0}};
16142
static swig_cast_info _swigc__p_OT__Base__Stat__RandomGeneratorState[] = { {&_swigt__p_OT__Base__Stat__RandomGeneratorState, 0, 0, 0},{0, 0, 0, 0}};
16143
static swig_cast_info _swigc__p_OT__Uncertainty__Distribution__HistogramPair[] = { {&_swigt__p_OT__Uncertainty__Distribution__HistogramPair, 0, 0, 0},{0, 0, 0, 0}};
16144
static swig_cast_info _swigc__p_OT__Uncertainty__Distribution__UserDefinedPair[] = { {&_swigt__p_OT__Uncertainty__Distribution__UserDefinedPair, 0, 0, 0},{0, 0, 0, 0}};
16145
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__EllipticalDistribution[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__EllipticalDistribution, 0, 0, 0},{0, 0, 0, 0}};
16146
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Gamma[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Gamma, 0, 0, 0},{0, 0, 0, 0}};
16147
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Weibull[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Weibull, 0, 0, 0},{0, 0, 0, 0}};
16148
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__Study[] = {{&_swigt__p_OpenTURNS__Base__Common__Study, 0, 0, 0},{0, 0, 0, 0}};
16149
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__Interval[] = {{&_swigt__p_OpenTURNS__Base__Type__Interval, 0, 0, 0},{0, 0, 0, 0}};
16150
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__ConfidenceInterval[] = {{&_swigt__p_OpenTURNS__Base__Stat__ConfidenceInterval, 0, 0, 0},{0, 0, 0, 0}};
16151
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__UniformFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__UniformFactory, 0, 0, 0},{0, 0, 0, 0}};
16152
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__Full[] = {{&_swigt__p_OpenTURNS__Base__Stat__Full, 0, 0, 0},{0, 0, 0, 0}};
16153
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__LowDiscrepancySequence[] = {{&_swigt__p_OpenTURNS__Base__Stat__LowDiscrepancySequence, 0, 0, 0},{0, 0, 0, 0}};
16154
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__SobolSequence[] = {{&_swigt__p_OpenTURNS__Base__Stat__SobolSequence, 0, 0, 0},{0, 0, 0, 0}};
16155
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__HaltonSequence[] = {{&_swigt__p_OpenTURNS__Base__Stat__HaltonSequence, 0, 0, 0},{0, 0, 0, 0}};
16156
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__WrapperDataFile[] = {{&_swigt__p_OpenTURNS__Base__Func__WrapperDataFile, 0, 0, 0},{0, 0, 0, 0}};
16157
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NumericalMathHessianImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__NumericalMathHessianImplementation, 0, 0, 0},{0, 0, 0, 0}};
16158
static swig_cast_info _swigc__p_OpenTURNS__Base__Solver__Solver[] = {{&_swigt__p_OpenTURNS__Base__Solver__Solver, 0, 0, 0},{0, 0, 0, 0}};
16159
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Mixture[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Mixture, 0, 0, 0},{0, 0, 0, 0}};
16160
static swig_cast_info _swigc__p_OpenTURNS__Base__Optim__AbdoRackwitz[] = {{&_swigt__p_OpenTURNS__Base__Optim__AbdoRackwitz, 0, 0, 0},{0, 0, 0, 0}};
16161
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation, 0, 0, 0},{0, 0, 0, 0}};
16162
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
16163
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
16164
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__TruncatedDistribution[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__TruncatedDistribution, 0, 0, 0},{0, 0, 0, 0}};
16165
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalFactory, 0, 0, 0},{0, 0, 0, 0}};
16166
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__TruncatedNormal[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__TruncatedNormal, 0, 0, 0},{0, 0, 0, 0}};
16167
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__Less[] = {{&_swigt__p_OpenTURNS__Base__Common__Less, 0, 0, 0},{0, 0, 0, 0}};
16168
static swig_cast_info _swigc__p_OpenTURNS__Base__Optim__NearestPointAlgorithm[] = {{&_swigt__p_OpenTURNS__Base__Optim__NearestPointAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
16169
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__Compact[] = {{&_swigt__p_OpenTURNS__Base__Stat__Compact, 0, 0, 0},{0, 0, 0, 0}};
16170
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__ContinuousDistribution[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__ContinuousDistribution, 0, 0, 0},{0, 0, 0, 0}};
16171
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__ArchimedeanCopula[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__ArchimedeanCopula, 0, 0, 0},{0, 0, 0, 0}};
16172
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_t[] = {{&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_t, 0, 0, 0},{0, 0, 0, 0}};
16173
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__LaplaceFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__LaplaceFactory, 0, 0, 0},{0, 0, 0, 0}};
16174
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__RandomMixture[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__RandomMixture, 0, 0, 0},{0, 0, 0, 0}};
16175
static swig_cast_info _swigc__p_OpenTURNS__Base__Optim__NearestPointChecker[] = {{&_swigt__p_OpenTURNS__Base__Optim__NearestPointChecker, 0, 0, 0},{0, 0, 0, 0}};
16176
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__MultiNomial[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__MultiNomial, 0, 0, 0},{0, 0, 0, 0}};
16177
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__MultiNomialFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__MultiNomialFactory, 0, 0, 0},{0, 0, 0, 0}};
16178
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__RayleighFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__RayleighFactory, 0, 0, 0},{0, 0, 0, 0}};
16179
static swig_cast_info _swigc__p_OpenTURNS__Base__Graph__Staircase[] = {{&_swigt__p_OpenTURNS__Base__Graph__Staircase, 0, 0, 0},{0, 0, 0, 0}};
16180
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__HistogramFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__HistogramFactory, 0, 0, 0},{0, 0, 0, 0}};
16181
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Histogram[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Histogram, 0, 0, 0},{0, 0, 0, 0}};
16182
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__GammaFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__GammaFactory, 0, 0, 0},{0, 0, 0, 0}};
16183
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__StudentFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__StudentFactory, 0, 0, 0},{0, 0, 0, 0}};
16184
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Laplace[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Laplace, 0, 0, 0},{0, 0, 0, 0}};
16185
static swig_cast_info _swigc__p_OpenTURNS__Base__Graph__GraphImplementation[] = {{&_swigt__p_OpenTURNS__Base__Graph__GraphImplementation, 0, 0, 0},{0, 0, 0, 0}};
16186
static swig_cast_info _swigc__p_OpenTURNS__Base__Graph__DrawableImplementation[] = {{&_swigt__p_OpenTURNS__Base__Graph__DrawableImplementation, 0, 0, 0},{0, 0, 0, 0}};
16187
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__TensorImplementation[] = {{&_swigt__p_OpenTURNS__Base__Type__TensorImplementation, 0, 0, 0},{0, 0, 0, 0}};
16188
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__MatrixImplementation[] = {{&_swigt__p_OpenTURNS__Base__Type__MatrixImplementation, 0, 0, 0},{0, 0, 0, 0}};
16189
static swig_cast_info _swigc__p_OpenTURNS__Base__Solver__SolverImplementation[] = {{&_swigt__p_OpenTURNS__Base__Solver__SolverImplementation, 0, 0, 0},{0, 0, 0, 0}};
16190
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__RandomVectorImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__RandomVectorImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16191
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__GraphImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__GraphImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16192
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory_t, 0, 0, 0},{0, 0, 0, 0}};
16193
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16194
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Solver__SolverImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Solver__SolverImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16195
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16196
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16197
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__UniVariatePolynomialImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__UniVariatePolynomialImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16198
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__NumericalMathFunctionImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__NumericalMathFunctionImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16199
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16200
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Common__ComparisonOperatorImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Common__ComparisonOperatorImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16201
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__MatrixImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__MatrixImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16202
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__TensorImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__TensorImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16203
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16204
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__HistoryStrategyImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__HistoryStrategyImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16205
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16206
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__DrawableImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__DrawableImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16207
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__EventRandomVectorImplementation[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__EventRandomVectorImplementation, 0, 0, 0},{0, 0, 0, 0}};
16208
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__UsualRandomVector[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__UsualRandomVector, 0, 0, 0},{0, 0, 0, 0}};
16209
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__WrapperFrameworkData[] = {{&_swigt__p_OpenTURNS__Base__Func__WrapperFrameworkData, 0, 0, 0},{0, 0, 0, 0}};
16210
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__Null[] = {{&_swigt__p_OpenTURNS__Base__Stat__Null, 0, 0, 0},{0, 0, 0, 0}};
16211
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__NonEllipticalDistribution[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__NonEllipticalDistribution, 0, 0, 0},{0, 0, 0, 0}};
16212
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NumericalMathGradientImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__NumericalMathGradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
16213
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__NumericalPointWithDescription[] = {{&_swigt__p_OpenTURNS__Base__Type__NumericalPointWithDescription, 0, 0, 0},{0, 0, 0, 0}};
16214
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
16215
static swig_cast_info _swigc__p_OpenTURNS__Base__Optim__PenalizedLeastSquaresAlgorithm[] = {{&_swigt__p_OpenTURNS__Base__Optim__PenalizedLeastSquaresAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
16216
static swig_cast_info _swigc__p_OpenTURNS__Base__Optim__Cobyla[] = {{&_swigt__p_OpenTURNS__Base__Optim__Cobyla, 0, 0, 0},{0, 0, 0, 0}};
16217
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation, 0, 0, 0},{0, 0, 0, 0}};
16218
static swig_cast_info _swigc__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient[] = {{&_swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, 0, 0, 0},{0, 0, 0, 0}};
16219
static swig_cast_info _swigc__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian[] = {{&_swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, 0, 0, 0},{0, 0, 0, 0}};
16220
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
16221
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__ComparisonOperator[] = {{&_swigt__p_OpenTURNS__Base__Common__ComparisonOperator, 0, 0, 0},{0, 0, 0, 0}};
16222
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__UserDefined[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__UserDefined, 0, 0, 0},{0, 0, 0, 0}};
16223
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__UserDefinedFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__UserDefinedFactory, 0, 0, 0},{0, 0, 0, 0}};
16224
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__LessOrEqual[] = {{&_swigt__p_OpenTURNS__Base__Common__LessOrEqual, 0, 0, 0},{0, 0, 0, 0}};
16225
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__GreaterOrEqual[] = {{&_swigt__p_OpenTURNS__Base__Common__GreaterOrEqual, 0, 0, 0},{0, 0, 0, 0}};
16226
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation, 0, 0, 0},{0, 0, 0, 0}};
16227
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation, 0, 0, 0},{0, 0, 0, 0}};
16228
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation, 0, 0, 0},{0, 0, 0, 0}};
16229
static swig_cast_info _swigc__p_OpenTURNS__Base__Optim__SQP[] = {{&_swigt__p_OpenTURNS__Base__Optim__SQP, 0, 0, 0},{0, 0, 0, 0}};
16230
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Uniform[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Uniform, 0, 0, 0},{0, 0, 0, 0}};
16231
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
16232
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
16233
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__TriangularFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__TriangularFactory, 0, 0, 0},{0, 0, 0, 0}};
16234
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Triangular[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Triangular, 0, 0, 0},{0, 0, 0, 0}};
16235
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Gumbel[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Gumbel, 0, 0, 0},{0, 0, 0, 0}};
16236
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__NumericalSampleImplementation[] = {{&_swigt__p_OpenTURNS__Base__Stat__NumericalSampleImplementation, 0, 0, 0},{0, 0, 0, 0}};
16237
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__HistoryStrategyImplementation[] = {{&_swigt__p_OpenTURNS__Base__Stat__HistoryStrategyImplementation, 0, 0, 0},{0, 0, 0, 0}};
16238
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__WrapperFunctionDescription[] = {{&_swigt__p_OpenTURNS__Base__Func__WrapperFunctionDescription, 0, 0, 0},{0, 0, 0, 0}};
16239
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__UniVariatePolynomial[] = {{&_swigt__p_OpenTURNS__Base__Func__UniVariatePolynomial, 0, 0, 0},{0, 0, 0, 0}};
16240
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__NormalCopulaFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__NormalCopulaFactory, 0, 0, 0},{0, 0, 0, 0}};
16241
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__NormalCopula[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__NormalCopula, 0, 0, 0},{0, 0, 0, 0}};
16242
static swig_cast_info _swigc__p_OpenTURNS__Base__Graph__Pie[] = {{&_swigt__p_OpenTURNS__Base__Graph__Pie, 0, 0, 0},{0, 0, 0, 0}};
16243
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__InterfaceObject[] = {{&_swigt__p_OpenTURNS__Base__Common__InterfaceObject, 0, 0, 0},{0, 0, 0, 0}};
16244
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__ClaytonCopula[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__ClaytonCopula, 0, 0, 0},{0, 0, 0, 0}};
16245
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaFactory, 0, 0, 0},{0, 0, 0, 0}};
16246
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__NormalFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__NormalFactory, 0, 0, 0},{0, 0, 0, 0}};
16247
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Logistic[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Logistic, 0, 0, 0},{0, 0, 0, 0}};
16248
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
16249
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__GeometricFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__GeometricFactory, 0, 0, 0},{0, 0, 0, 0}};
16250
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Geometric[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Geometric, 0, 0, 0},{0, 0, 0, 0}};
16251
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__KernelMixture[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__KernelMixture, 0, 0, 0},{0, 0, 0, 0}};
16252
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__SklarCopula[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__SklarCopula, 0, 0, 0},{0, 0, 0, 0}};
16253
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__NonCentralStudent[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__NonCentralStudent, 0, 0, 0},{0, 0, 0, 0}};
16254
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__PoissonFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__PoissonFactory, 0, 0, 0},{0, 0, 0, 0}};
16255
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
16256
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
16257
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
16258
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__Equal[] = {{&_swigt__p_OpenTURNS__Base__Common__Equal, 0, 0, 0},{0, 0, 0, 0}};
16259
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16260
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t[] = {{&_swigt__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
16261
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Epanechnikov[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Epanechnikov, 0, 0, 0},{0, 0, 0, 0}};
16262
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__IndependentCopula[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__IndependentCopula, 0, 0, 0},{0, 0, 0, 0}};
16263
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation[] = {{&_swigt__p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation, 0, 0, 0},{0, 0, 0, 0}};
16264
static swig_cast_info _swigc__p_OpenTURNS__Base__Graph__Cloud[] = {{&_swigt__p_OpenTURNS__Base__Graph__Cloud, 0, 0, 0},{0, 0, 0, 0}};
16265
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__ConstantRandomVector[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__ConstantRandomVector, 0, 0, 0},{0, 0, 0, 0}};
16266
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NumericalMathFunction[] = {{&_swigt__p_OpenTURNS__Base__Func__NumericalMathFunction, 0, 0, 0},{0, 0, 0, 0}};
16267
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__Copula[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__Copula, 0, 0, 0},{0, 0, 0, 0}};
16268
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__RandomVector[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__RandomVector, 0, 0, 0},{0, 0, 0, 0}};
16269
static swig_cast_info _swigc__p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient[] = {{&_swigt__p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, 0, 0, 0},{0, 0, 0, 0}};
16270
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__ComposedCopula[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__ComposedCopula, 0, 0, 0},{0, 0, 0, 0}};
16271
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__ComposedDistribution[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__ComposedDistribution, 0, 0, 0},{0, 0, 0, 0}};
16272
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__DescriptionImplementation[] = {{&_swigt__p_OpenTURNS__Base__Type__DescriptionImplementation, 0, 0, 0},{0, 0, 0, 0}};
16273
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__LogisticFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__LogisticFactory, 0, 0, 0},{0, 0, 0, 0}};
16274
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__CorrelationMatrix[] = {{&_swigt__p_OpenTURNS__Base__Stat__CorrelationMatrix, 0, 0, 0},{0, 0, 0, 0}};
16275
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__BetaFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__BetaFactory, 0, 0, 0},{0, 0, 0, 0}};
16276
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaFactory, 0, 0, 0},{0, 0, 0, 0}};
16277
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__GumbelCopula[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__GumbelCopula, 0, 0, 0},{0, 0, 0, 0}};
16278
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__UsualDistribution[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__UsualDistribution, 0, 0, 0},{0, 0, 0, 0}};
16279
static swig_cast_info _swigc__p_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation[] = {{&_swigt__p_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation, 0, 0, 0},{0, 0, 0, 0}};
16280
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ProductNumericalMathFunction[] = {{&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathFunction, 0, 0, 0},{0, 0, 0, 0}};
16281
static swig_cast_info _swigc__p_OpenTURNS__Base__Solver__Brent[] = {{&_swigt__p_OpenTURNS__Base__Solver__Brent, 0, 0, 0},{0, 0, 0, 0}};
16282
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__GumbelFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__GumbelFactory, 0, 0, 0},{0, 0, 0, 0}};
16283
static swig_cast_info _swigc__p_OpenTURNS__Base__Graph__Contour[] = {{&_swigt__p_OpenTURNS__Base__Graph__Contour, 0, 0, 0},{0, 0, 0, 0}};
16284
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
16285
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
16286
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__WrapperFile[] = {{&_swigt__p_OpenTURNS__Base__Func__WrapperFile, 0, 0, 0},{0, 0, 0, 0}};
16287
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__CopulaImplementation[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__CopulaImplementation, 0, 0, 0},{0, 0, 0, 0}};
16288
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_t[] = {{&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_t, 0, 0, 0},{0, 0, 0, 0}};
16289
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_t[] = {{&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_t, 0, 0, 0},{0, 0, 0, 0}};
16290
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_t[] = {{&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_t, 0, 0, 0},{0, 0, 0, 0}};
16291
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
16292
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
16293
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__Event[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__Event, 0, 0, 0},{0, 0, 0, 0}};
16294
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__ConditionalRandomVector[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__ConditionalRandomVector, 0, 0, 0},{0, 0, 0, 0}};
16295
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__DiscreteDistribution[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__DiscreteDistribution, 0, 0, 0},{0, 0, 0, 0}};
16296
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__Greater[] = {{&_swigt__p_OpenTURNS__Base__Common__Greater, 0, 0, 0},{0, 0, 0, 0}};
16297
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
16298
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory, 0, 0, 0},{0, 0, 0, 0}};
16299
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__DistributionImplementation[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__DistributionImplementation, 0, 0, 0},{0, 0, 0, 0}};
16300
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__Matrix[] = {{&_swigt__p_OpenTURNS__Base__Type__Matrix, 0, 0, 0},{0, 0, 0, 0}};
16301
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__SquareMatrix[] = {{&_swigt__p_OpenTURNS__Base__Type__SquareMatrix, 0, 0, 0},{0, 0, 0, 0}};
16302
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__SymmetricMatrix[] = {{&_swigt__p_OpenTURNS__Base__Type__SymmetricMatrix, 0, 0, 0},{0, 0, 0, 0}};
16303
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__CovarianceMatrix[] = {{&_swigt__p_OpenTURNS__Base__Stat__CovarianceMatrix, 0, 0, 0},{0, 0, 0, 0}};
16304
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__IdentityMatrix[] = {{&_swigt__p_OpenTURNS__Base__Type__IdentityMatrix, 0, 0, 0},{0, 0, 0, 0}};
16305
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__HistoryStrategy[] = {{&_swigt__p_OpenTURNS__Base__Stat__HistoryStrategy, 0, 0, 0},{0, 0, 0, 0}};
16306
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__WeibullFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__WeibullFactory, 0, 0, 0},{0, 0, 0, 0}};
16307
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__NumericalPoint[] = {{&_swigt__p_OpenTURNS__Base__Type__NumericalPoint, 0, 0, 0},{0, 0, 0, 0}};
16308
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_t[] = {{&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
16309
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
16310
static swig_cast_info _swigc__p_OpenTURNS__Base__Solver__Secant[] = {{&_swigt__p_OpenTURNS__Base__Solver__Secant, 0, 0, 0},{0, 0, 0, 0}};
16311
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__LogNormal[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__LogNormal, 0, 0, 0},{0, 0, 0, 0}};
16312
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Normal[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Normal, 0, 0, 0},{0, 0, 0, 0}};
16313
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__LogNormalFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__LogNormalFactory, 0, 0, 0},{0, 0, 0, 0}};
16314
static swig_cast_info _swigc__p_OpenTURNS__Base__Graph__Drawable[] = {{&_swigt__p_OpenTURNS__Base__Graph__Drawable, 0, 0, 0},{0, 0, 0, 0}};
16315
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Poisson[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Poisson, 0, 0, 0},{0, 0, 0, 0}};
16316
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__Tensor[] = {{&_swigt__p_OpenTURNS__Base__Type__Tensor, 0, 0, 0},{0, 0, 0, 0}};
16317
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__SymmetricTensor[] = {{&_swigt__p_OpenTURNS__Base__Type__SymmetricTensor, 0, 0, 0},{0, 0, 0, 0}};
16318
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_double_t[] = {{&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_double_t, 0, 0, 0},{0, 0, 0, 0}};
16319
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__ChiSquare[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__ChiSquare, 0, 0, 0},{0, 0, 0, 0}};
16320
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__ChiSquareFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__ChiSquareFactory, 0, 0, 0},{0, 0, 0, 0}};
16321
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__ExponentialFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__ExponentialFactory, 0, 0, 0},{0, 0, 0, 0}};
16322
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Exponential[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Exponential, 0, 0, 0},{0, 0, 0, 0}};
16323
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__CompositeRandomVector[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__CompositeRandomVector, 0, 0, 0},{0, 0, 0, 0}};
16324
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathFunction[] = {{&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathFunction, 0, 0, 0},{0, 0, 0, 0}};
16325
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
16326
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__KernelSmoothing[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__KernelSmoothing, 0, 0, 0},{0, 0, 0, 0}};
16327
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__FrankCopulaFactory[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__FrankCopulaFactory, 0, 0, 0},{0, 0, 0, 0}};
16328
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__FrankCopula[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__FrankCopula, 0, 0, 0},{0, 0, 0, 0}};
16329
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation, 0, 0, 0},{0, 0, 0, 0}};
16330
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__RandomVectorImplementation[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__RandomVectorImplementation, 0, 0, 0},{0, 0, 0, 0}};
16331
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__ComparisonOperatorImplementation[] = {{&_swigt__p_OpenTURNS__Base__Common__ComparisonOperatorImplementation, 0, 0, 0},{0, 0, 0, 0}};
16332
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Rayleigh[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Rayleigh, 0, 0, 0},{0, 0, 0, 0}};
16333
static swig_cast_info _swigc__p_OpenTURNS__Base__Solver__Bisection[] = {{&_swigt__p_OpenTURNS__Base__Solver__Bisection, 0, 0, 0},{0, 0, 0, 0}};
16334
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Beta[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Beta, 0, 0, 0},{0, 0, 0, 0}};
16335
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation, 0, 0, 0},{0, 0, 0, 0}};
16336
static swig_cast_info _swigc__p_OpenTURNS__Base__Graph__Curve[] = {{&_swigt__p_OpenTURNS__Base__Graph__Curve, 0, 0, 0},{0, 0, 0, 0}};
16337
static swig_cast_info _swigc__p_OpenTURNS__Base__Graph__BarPlot[] = {{&_swigt__p_OpenTURNS__Base__Graph__BarPlot, 0, 0, 0},{0, 0, 0, 0}};
16338
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__WrapperParameter[] = {{&_swigt__p_OpenTURNS__Base__Func__WrapperParameter, 0, 0, 0},{0, 0, 0, 0}};
16339
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__WrapperDataVariable[] = {{&_swigt__p_OpenTURNS__Base__Func__WrapperDataVariable, 0, 0, 0},{0, 0, 0, 0}};
16340
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__LinearNumericalMathFunction[] = {{&_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathFunction, 0, 0, 0},{0, 0, 0, 0}};
16341
static swig_cast_info _swigc__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation[] = {{&_swigt__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation, 0, 0, 0},{0, 0, 0, 0}};
16342
static swig_cast_info _swigc__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationResult[] = {{&_swigt__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationResult, 0, 0, 0},{0, 0, 0, 0}};
16343
static swig_cast_info _swigc__p_OpenTURNS__Base__Optim__TNC[] = {{&_swigt__p_OpenTURNS__Base__Optim__TNC, 0, 0, 0},{0, 0, 0, 0}};
16344
static swig_cast_info _swigc__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithm[] = {{&_swigt__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
16345
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__WrapperData[] = {{&_swigt__p_OpenTURNS__Base__Func__WrapperData, 0, 0, 0},{0, 0, 0, 0}};
16346
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Distribution__Student[] = {{&_swigt__p_OpenTURNS__Uncertainty__Distribution__Student, 0, 0, 0},{0, 0, 0, 0}};
16347
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__StorageManager[] = {{&_swigt__p_OpenTURNS__Base__Common__StorageManager, 0, 0, 0},{0, 0, 0, 0}};
16348
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__XMLStorageManager[] = {{&_swigt__p_OpenTURNS__Base__Common__XMLStorageManager, 0, 0, 0},{0, 0, 0, 0}};
16349
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__StandardEvent[] = {{&_swigt__p_OpenTURNS__Uncertainty__Model__StandardEvent, 0, 0, 0},{0, 0, 0, 0}};
16350
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation, 0, 0, 0},{0, 0, 0, 0}};
16351
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__Last[] = {{&_swigt__p_OpenTURNS__Base__Stat__Last, 0, 0, 0},{0, 0, 0, 0}};
16352
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__Object[] = { {&_swigt__p_OpenTURNS__Uncertainty__Model__EllipticalDistribution, _p_OpenTURNS__Uncertainty__Model__EllipticalDistributionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__TestResult, _p_OpenTURNS__Base__Stat__TestResultTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Gamma, _p_OpenTURNS__Uncertainty__Distribution__GammaTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Weibull, _p_OpenTURNS__Uncertainty__Distribution__WeibullTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__Study, _p_OpenTURNS__Base__Common__StudyTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__Interval, _p_OpenTURNS__Base__Type__IntervalTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__ConfidenceInterval, _p_OpenTURNS__Base__Stat__ConfidenceIntervalTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__UniformFactory, _p_OpenTURNS__Uncertainty__Distribution__UniformFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__Full, _p_OpenTURNS__Base__Stat__FullTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__LowDiscrepancySequence, _p_OpenTURNS__Base__Stat__LowDiscrepancySequenceTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__SobolSequence, _p_OpenTURNS__Base__Stat__SobolSequenceTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__HaltonSequence, _p_OpenTURNS__Base__Stat__HaltonSequenceTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__WrapperDataFile, _p_OpenTURNS__Base__Func__WrapperDataFileTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__NumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__NumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Solver__Solver, _p_OpenTURNS__Base__Solver__SolverTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Mixture, _p_OpenTURNS__Uncertainty__Distribution__MixtureTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__AbdoRackwitz, _p_OpenTURNS__Base__Optim__AbdoRackwitzTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation, _p_OpenTURNS__Base__Func__UniVariatePolynomialImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__TruncatedDistribution, _p_OpenTURNS__Uncertainty__Distribution__TruncatedDistributionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalFactory, _p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__TruncatedNormal, _p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__LinearModel, _p_OpenTURNS__Base__Stat__LinearModelTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__Less, _p_OpenTURNS__Base__Common__LessTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__NearestPointAlgorithm, _p_OpenTURNS__Base__Optim__NearestPointAlgorithmTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__Compact, _p_OpenTURNS__Base__Stat__CompactTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OT__Base__Optim__NearestPointChecker__Result, _p_OT__Base__Optim__NearestPointChecker__ResultTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__ContinuousDistribution, _p_OpenTURNS__Uncertainty__Model__ContinuousDistributionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__ArchimedeanCopula, _p_OpenTURNS__Uncertainty__Model__ArchimedeanCopulaTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_t, _p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__LaplaceFactory, _p_OpenTURNS__Uncertainty__Distribution__LaplaceFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__RandomMixture, _p_OpenTURNS__Uncertainty__Distribution__RandomMixtureTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__NearestPointChecker, _p_OpenTURNS__Base__Optim__NearestPointCheckerTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__MultiNomial, _p_OpenTURNS__Uncertainty__Distribution__MultiNomialTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__MultiNomialFactory, _p_OpenTURNS__Uncertainty__Distribution__MultiNomialFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__RayleighFactory, _p_OpenTURNS__Uncertainty__Distribution__RayleighFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__Staircase, _p_OpenTURNS__Base__Graph__StaircaseTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__HistogramFactory, _p_OpenTURNS__Uncertainty__Distribution__HistogramFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Histogram, _p_OpenTURNS__Uncertainty__Distribution__HistogramTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__GammaFactory, _p_OpenTURNS__Uncertainty__Distribution__GammaFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__StudentFactory, _p_OpenTURNS__Uncertainty__Distribution__StudentFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Laplace, _p_OpenTURNS__Uncertainty__Distribution__LaplaceTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__GraphImplementation, _p_OpenTURNS__Base__Graph__GraphImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__DrawableImplementation, _p_OpenTURNS__Base__Graph__DrawableImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__TensorImplementation, _p_OpenTURNS__Base__Type__TensorImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__MatrixImplementation, _p_OpenTURNS__Base__Type__MatrixImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Solver__SolverImplementation, _p_OpenTURNS__Base__Solver__SolverImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__RandomVectorImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__RandomVectorImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__GraphImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__GraphImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Solver__SolverImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Solver__SolverImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__UniVariatePolynomialImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__UniVariatePolynomialImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__NumericalMathFunctionImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__NumericalMathFunctionImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Common__ComparisonOperatorImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Common__ComparisonOperatorImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__MatrixImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__MatrixImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__TensorImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__TensorImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__HistoryStrategyImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__HistoryStrategyImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__DrawableImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__DrawableImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__EventRandomVectorImplementation, _p_OpenTURNS__Uncertainty__Model__EventRandomVectorImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__UsualRandomVector, _p_OpenTURNS__Uncertainty__Model__UsualRandomVectorTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__WrapperFrameworkData, _p_OpenTURNS__Base__Func__WrapperFrameworkDataTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__PersistentObject, _p_OpenTURNS__Base__Common__PersistentObjectTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__Null, _p_OpenTURNS__Base__Stat__NullTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__NonEllipticalDistribution, _p_OpenTURNS__Uncertainty__Model__NonEllipticalDistributionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__NumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__NumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__NumericalPointWithDescription, _p_OpenTURNS__Base__Type__NumericalPointWithDescriptionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__PenalizedLeastSquaresAlgorithm, _p_OpenTURNS__Base__Optim__PenalizedLeastSquaresAlgorithmTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__Cobyla, _p_OpenTURNS__Base__Optim__CobylaTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, _p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, _p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessianTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__ComparisonOperator, _p_OpenTURNS__Base__Common__ComparisonOperatorTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__UserDefined, _p_OpenTURNS__Uncertainty__Distribution__UserDefinedTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__UserDefinedFactory, _p_OpenTURNS__Uncertainty__Distribution__UserDefinedFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__LessOrEqual, _p_OpenTURNS__Base__Common__LessOrEqualTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__GreaterOrEqual, _p_OpenTURNS__Base__Common__GreaterOrEqualTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__SQP, _p_OpenTURNS__Base__Optim__SQPTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Uniform, _p_OpenTURNS__Uncertainty__Distribution__UniformTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__Distribution, _p_OpenTURNS__Uncertainty__Model__DistributionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation, _p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation, _p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__TriangularFactory, _p_OpenTURNS__Uncertainty__Distribution__TriangularFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Triangular, _p_OpenTURNS__Uncertainty__Distribution__TriangularTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Gumbel, _p_OpenTURNS__Uncertainty__Distribution__GumbelTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__NumericalSampleImplementation, _p_OpenTURNS__Base__Stat__NumericalSampleImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__HistoryStrategyImplementation, _p_OpenTURNS__Base__Stat__HistoryStrategyImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OT__Base__Optim__NearestPointAlgorithmImplementation__Result, _p_OT__Base__Optim__NearestPointAlgorithmImplementation__ResultTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__WrapperFunctionDescription, _p_OpenTURNS__Base__Func__WrapperFunctionDescriptionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters, _p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParametersTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__UniVariatePolynomial, _p_OpenTURNS__Base__Func__UniVariatePolynomialTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult, _p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResultTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__NormalCopulaFactory, _p_OpenTURNS__Uncertainty__Distribution__NormalCopulaFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__NormalCopula, _p_OpenTURNS__Uncertainty__Distribution__NormalCopulaTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__Pie, _p_OpenTURNS__Base__Graph__PieTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__Object, 0, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__InterfaceObject, _p_OpenTURNS__Base__Common__InterfaceObjectTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__ClaytonCopula, _p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaFactory, _p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__NormalFactory, _p_OpenTURNS__Uncertainty__Distribution__NormalFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Logistic, _p_OpenTURNS__Uncertainty__Distribution__LogisticTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__GeometricFactory, _p_OpenTURNS__Uncertainty__Distribution__GeometricFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Geometric, _p_OpenTURNS__Uncertainty__Distribution__GeometricTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__KernelMixture, _p_OpenTURNS__Uncertainty__Distribution__KernelMixtureTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__SklarCopula, _p_OpenTURNS__Uncertainty__Model__SklarCopulaTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__Description, _p_OpenTURNS__Base__Type__DescriptionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__NonCentralStudent, _p_OpenTURNS__Uncertainty__Distribution__NonCentralStudentTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__PoissonFactory, _p_OpenTURNS__Uncertainty__Distribution__PoissonFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__Equal, _p_OpenTURNS__Base__Common__EqualTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t, _p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t, _p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Epanechnikov, _p_OpenTURNS__Uncertainty__Distribution__EpanechnikovTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__IndependentCopula, _p_OpenTURNS__Uncertainty__Distribution__IndependentCopulaTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation, _p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__Cloud, _p_OpenTURNS__Base__Graph__CloudTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__ConstantRandomVector, _p_OpenTURNS__Uncertainty__Model__ConstantRandomVectorTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__NumericalMathFunction, _p_OpenTURNS__Base__Func__NumericalMathFunctionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__Copula, _p_OpenTURNS__Uncertainty__Model__CopulaTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__RandomVector, _p_OpenTURNS__Uncertainty__Model__RandomVectorTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, _p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__ComposedCopula, _p_OpenTURNS__Uncertainty__Distribution__ComposedCopulaTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__Indices, _p_OpenTURNS__Base__Type__IndicesTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__ComposedDistribution, _p_OpenTURNS__Uncertainty__Distribution__ComposedDistributionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__DescriptionImplementation, _p_OpenTURNS__Base__Type__DescriptionImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OT__Base__Optim__SQPSpecificParameters, _p_OT__Base__Optim__SQPSpecificParametersTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OT__Base__Optim__TNCSpecificParameters, _p_OT__Base__Optim__TNCSpecificParametersTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OT__Base__Optim__CobylaSpecificParameters, _p_OT__Base__Optim__CobylaSpecificParametersTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OT__Base__Optim__AbdoRackwitzSpecificParameters, _p_OT__Base__Optim__AbdoRackwitzSpecificParametersTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__LogisticFactory, _p_OpenTURNS__Uncertainty__Distribution__LogisticFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__CorrelationMatrix, _p_OpenTURNS__Base__Stat__CorrelationMatrixTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__BetaFactory, _p_OpenTURNS__Uncertainty__Distribution__BetaFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaFactory, _p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__GumbelCopula, _p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__UsualDistribution, _p_OpenTURNS__Uncertainty__Model__UsualDistributionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation, _p_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathFunction, _p_OpenTURNS__Base__Func__ProductNumericalMathFunctionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Solver__Brent, _p_OpenTURNS__Base__Solver__BrentTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__GumbelFactory, _p_OpenTURNS__Uncertainty__Distribution__GumbelFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__Contour, _p_OpenTURNS__Base__Graph__ContourTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__WrapperFile, _p_OpenTURNS__Base__Func__WrapperFileTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__CopulaImplementation, _p_OpenTURNS__Uncertainty__Model__CopulaImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_t, _p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_t, _p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_t, _p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__Event, _p_OpenTURNS__Uncertainty__Model__EventTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__ConditionalRandomVector, _p_OpenTURNS__Uncertainty__Model__ConditionalRandomVectorTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__DiscreteDistribution, _p_OpenTURNS__Uncertainty__Model__DiscreteDistributionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__Greater, _p_OpenTURNS__Base__Common__GreaterTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__Graph, _p_OpenTURNS__Base__Graph__GraphTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory, _p_OpenTURNS__Uncertainty__Model__DistributionImplementationFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__DistributionImplementation, _p_OpenTURNS__Uncertainty__Model__DistributionImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__Matrix, _p_OpenTURNS__Base__Type__MatrixTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__SquareMatrix, _p_OpenTURNS__Base__Type__SquareMatrixTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__SymmetricMatrix, _p_OpenTURNS__Base__Type__SymmetricMatrixTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__CovarianceMatrix, _p_OpenTURNS__Base__Stat__CovarianceMatrixTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__IdentityMatrix, _p_OpenTURNS__Base__Type__IdentityMatrixTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__HistoryStrategy, _p_OpenTURNS__Base__Stat__HistoryStrategyTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__WeibullFactory, _p_OpenTURNS__Uncertainty__Distribution__WeibullFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__NumericalSample, _p_OpenTURNS__Base__Stat__NumericalSampleTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__NumericalPoint, _p_OpenTURNS__Base__Type__NumericalPointTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__DistributionFactory, _p_OpenTURNS__Uncertainty__Model__DistributionFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_t, _p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation, _p_OpenTURNS__Base__Func__LinearCombinationGradientImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Solver__Secant, _p_OpenTURNS__Base__Solver__SecantTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__LogNormal, _p_OpenTURNS__Uncertainty__Distribution__LogNormalTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Normal, _p_OpenTURNS__Uncertainty__Distribution__NormalTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__LogNormalFactory, _p_OpenTURNS__Uncertainty__Distribution__LogNormalFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__Drawable, _p_OpenTURNS__Base__Graph__DrawableTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Poisson, _p_OpenTURNS__Uncertainty__Distribution__PoissonTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__Tensor, _p_OpenTURNS__Base__Type__TensorTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__SymmetricTensor, _p_OpenTURNS__Base__Type__SymmetricTensorTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_double_t, _p_OpenTURNS__Base__Type__PersistentCollectionT_double_tTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__ChiSquare, _p_OpenTURNS__Uncertainty__Distribution__ChiSquareTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__ChiSquareFactory, _p_OpenTURNS__Uncertainty__Distribution__ChiSquareFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__ExponentialFactory, _p_OpenTURNS__Uncertainty__Distribution__ExponentialFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Exponential, _p_OpenTURNS__Uncertainty__Distribution__ExponentialTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__CompositeRandomVector, _p_OpenTURNS__Uncertainty__Model__CompositeRandomVectorTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathFunction, _p_OpenTURNS__Base__Func__ComposedNumericalMathFunctionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__KernelSmoothing, _p_OpenTURNS__Uncertainty__Distribution__KernelSmoothingTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__FrankCopulaFactory, _p_OpenTURNS__Uncertainty__Distribution__FrankCopulaFactoryTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__FrankCopula, _p_OpenTURNS__Uncertainty__Distribution__FrankCopulaTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation, _p_OpenTURNS__Base__Func__NumericalMathFunctionImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__RandomVectorImplementation, _p_OpenTURNS__Uncertainty__Model__RandomVectorImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__ComparisonOperatorImplementation, _p_OpenTURNS__Base__Common__ComparisonOperatorImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Rayleigh, _p_OpenTURNS__Uncertainty__Distribution__RayleighTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Solver__Bisection, _p_OpenTURNS__Base__Solver__BisectionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Beta, _p_OpenTURNS__Uncertainty__Distribution__BetaTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__Curve, _p_OpenTURNS__Base__Graph__CurveTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__BarPlot, _p_OpenTURNS__Base__Graph__BarPlotTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__WrapperParameter, _p_OpenTURNS__Base__Func__WrapperParameterTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__WrapperDataVariable, _p_OpenTURNS__Base__Func__WrapperDataVariableTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathFunction, _p_OpenTURNS__Base__Func__LinearNumericalMathFunctionTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation, _p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationResult, _p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationResultTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__TNC, _p_OpenTURNS__Base__Optim__TNCTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithm, _p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__WrapperData, _p_OpenTURNS__Base__Func__WrapperDataTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Student, _p_OpenTURNS__Uncertainty__Distribution__StudentTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__StorageManager, _p_OpenTURNS__Base__Common__StorageManagerTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__XMLStorageManager, _p_OpenTURNS__Base__Common__XMLStorageManagerTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__StandardEvent, _p_OpenTURNS__Uncertainty__Model__StandardEventTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation, _p_OpenTURNS__Base__Func__LinearCombinationHessianImplementationTo_p_OpenTURNS__Base__Common__Object, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__Last, _p_OpenTURNS__Base__Stat__LastTo_p_OpenTURNS__Base__Common__Object, 0, 0},{0, 0, 0, 0}};
16353
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__PersistentObject[] = { {&_swigt__p_OpenTURNS__Uncertainty__Model__EllipticalDistribution, _p_OpenTURNS__Uncertainty__Model__EllipticalDistributionTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__TestResult, _p_OpenTURNS__Base__Stat__TestResultTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Gamma, _p_OpenTURNS__Uncertainty__Distribution__GammaTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Weibull, _p_OpenTURNS__Uncertainty__Distribution__WeibullTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__ConfidenceInterval, _p_OpenTURNS__Base__Stat__ConfidenceIntervalTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__Interval, _p_OpenTURNS__Base__Type__IntervalTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__UniformFactory, _p_OpenTURNS__Uncertainty__Distribution__UniformFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__Full, _p_OpenTURNS__Base__Stat__FullTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__HaltonSequence, _p_OpenTURNS__Base__Stat__HaltonSequenceTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__SobolSequence, _p_OpenTURNS__Base__Stat__SobolSequenceTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__NumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__NumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Mixture, _p_OpenTURNS__Uncertainty__Distribution__MixtureTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__AbdoRackwitz, _p_OpenTURNS__Base__Optim__AbdoRackwitzTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation, _p_OpenTURNS__Base__Func__UniVariatePolynomialImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__TruncatedDistribution, _p_OpenTURNS__Uncertainty__Distribution__TruncatedDistributionTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__TruncatedNormal, _p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalFactory, _p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__LinearModel, _p_OpenTURNS__Base__Stat__LinearModelTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__Less, _p_OpenTURNS__Base__Common__LessTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__Compact, _p_OpenTURNS__Base__Stat__CompactTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OT__Base__Optim__NearestPointChecker__Result, _p_OT__Base__Optim__NearestPointChecker__ResultTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__ContinuousDistribution, _p_OpenTURNS__Uncertainty__Model__ContinuousDistributionTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__ArchimedeanCopula, _p_OpenTURNS__Uncertainty__Model__ArchimedeanCopulaTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_t, _p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_tTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__LaplaceFactory, _p_OpenTURNS__Uncertainty__Distribution__LaplaceFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__RandomMixture, _p_OpenTURNS__Uncertainty__Distribution__RandomMixtureTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__NearestPointChecker, _p_OpenTURNS__Base__Optim__NearestPointCheckerTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__MultiNomialFactory, _p_OpenTURNS__Uncertainty__Distribution__MultiNomialFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__MultiNomial, _p_OpenTURNS__Uncertainty__Distribution__MultiNomialTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__RayleighFactory, _p_OpenTURNS__Uncertainty__Distribution__RayleighFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__Staircase, _p_OpenTURNS__Base__Graph__StaircaseTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Histogram, _p_OpenTURNS__Uncertainty__Distribution__HistogramTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__HistogramFactory, _p_OpenTURNS__Uncertainty__Distribution__HistogramFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__GammaFactory, _p_OpenTURNS__Uncertainty__Distribution__GammaFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__StudentFactory, _p_OpenTURNS__Uncertainty__Distribution__StudentFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Laplace, _p_OpenTURNS__Uncertainty__Distribution__LaplaceTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Solver__SolverImplementation, _p_OpenTURNS__Base__Solver__SolverImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__DrawableImplementation, _p_OpenTURNS__Base__Graph__DrawableImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__TensorImplementation, _p_OpenTURNS__Base__Type__TensorImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__MatrixImplementation, _p_OpenTURNS__Base__Type__MatrixImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__GraphImplementation, _p_OpenTURNS__Base__Graph__GraphImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__EventRandomVectorImplementation, _p_OpenTURNS__Uncertainty__Model__EventRandomVectorImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__UsualRandomVector, _p_OpenTURNS__Uncertainty__Model__UsualRandomVectorTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__PersistentObject, 0, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__Null, _p_OpenTURNS__Base__Stat__NullTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__NonEllipticalDistribution, _p_OpenTURNS__Uncertainty__Model__NonEllipticalDistributionTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__NumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__NumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__NumericalPointWithDescription, _p_OpenTURNS__Base__Type__NumericalPointWithDescriptionTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__PenalizedLeastSquaresAlgorithm, _p_OpenTURNS__Base__Optim__PenalizedLeastSquaresAlgorithmTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__Cobyla, _p_OpenTURNS__Base__Optim__CobylaTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, _p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessianTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, _p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__UserDefinedFactory, _p_OpenTURNS__Uncertainty__Distribution__UserDefinedFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__UserDefined, _p_OpenTURNS__Uncertainty__Distribution__UserDefinedTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__GreaterOrEqual, _p_OpenTURNS__Base__Common__GreaterOrEqualTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__LessOrEqual, _p_OpenTURNS__Base__Common__LessOrEqualTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__SQP, _p_OpenTURNS__Base__Optim__SQPTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Uniform, _p_OpenTURNS__Uncertainty__Distribution__UniformTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation, _p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation, _p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Triangular, _p_OpenTURNS__Uncertainty__Distribution__TriangularTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__TriangularFactory, _p_OpenTURNS__Uncertainty__Distribution__TriangularFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Gumbel, _p_OpenTURNS__Uncertainty__Distribution__GumbelTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OT__Base__Optim__NearestPointAlgorithmImplementation__Result, _p_OT__Base__Optim__NearestPointAlgorithmImplementation__ResultTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__HistoryStrategyImplementation, _p_OpenTURNS__Base__Stat__HistoryStrategyImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__NumericalSampleImplementation, _p_OpenTURNS__Base__Stat__NumericalSampleImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters, _p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParametersTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult, _p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResultTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__NormalCopulaFactory, _p_OpenTURNS__Uncertainty__Distribution__NormalCopulaFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__NormalCopula, _p_OpenTURNS__Uncertainty__Distribution__NormalCopulaTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__Pie, _p_OpenTURNS__Base__Graph__PieTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__ClaytonCopula, _p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaFactory, _p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__NormalFactory, _p_OpenTURNS__Uncertainty__Distribution__NormalFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Logistic, _p_OpenTURNS__Uncertainty__Distribution__LogisticTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__GeometricFactory, _p_OpenTURNS__Uncertainty__Distribution__GeometricFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Geometric, _p_OpenTURNS__Uncertainty__Distribution__GeometricTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__KernelMixture, _p_OpenTURNS__Uncertainty__Distribution__KernelMixtureTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__SklarCopula, _p_OpenTURNS__Uncertainty__Model__SklarCopulaTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__NonCentralStudent, _p_OpenTURNS__Uncertainty__Distribution__NonCentralStudentTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__PoissonFactory, _p_OpenTURNS__Uncertainty__Distribution__PoissonFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__Equal, _p_OpenTURNS__Base__Common__EqualTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Epanechnikov, _p_OpenTURNS__Uncertainty__Distribution__EpanechnikovTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__IndependentCopula, _p_OpenTURNS__Uncertainty__Distribution__IndependentCopulaTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation, _p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__Cloud, _p_OpenTURNS__Base__Graph__CloudTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__ConstantRandomVector, _p_OpenTURNS__Uncertainty__Model__ConstantRandomVectorTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, _p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__ComposedCopula, _p_OpenTURNS__Uncertainty__Distribution__ComposedCopulaTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__Indices, _p_OpenTURNS__Base__Type__IndicesTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__ComposedDistribution, _p_OpenTURNS__Uncertainty__Distribution__ComposedDistributionTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__DescriptionImplementation, _p_OpenTURNS__Base__Type__DescriptionImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OT__Base__Optim__SQPSpecificParameters, _p_OT__Base__Optim__SQPSpecificParametersTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OT__Base__Optim__TNCSpecificParameters, _p_OT__Base__Optim__TNCSpecificParametersTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OT__Base__Optim__CobylaSpecificParameters, _p_OT__Base__Optim__CobylaSpecificParametersTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OT__Base__Optim__AbdoRackwitzSpecificParameters, _p_OT__Base__Optim__AbdoRackwitzSpecificParametersTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__LogisticFactory, _p_OpenTURNS__Uncertainty__Distribution__LogisticFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__BetaFactory, _p_OpenTURNS__Uncertainty__Distribution__BetaFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaFactory, _p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__GumbelCopula, _p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__UsualDistribution, _p_OpenTURNS__Uncertainty__Model__UsualDistributionTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation, _p_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathFunction, _p_OpenTURNS__Base__Func__ProductNumericalMathFunctionTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Solver__Brent, _p_OpenTURNS__Base__Solver__BrentTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__GumbelFactory, _p_OpenTURNS__Uncertainty__Distribution__GumbelFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__Contour, _p_OpenTURNS__Base__Graph__ContourTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__WrapperFile, _p_OpenTURNS__Base__Func__WrapperFileTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__CopulaImplementation, _p_OpenTURNS__Uncertainty__Model__CopulaImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_t, _p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_tTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_t, _p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_tTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_t, _p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_tTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__ConditionalRandomVector, _p_OpenTURNS__Uncertainty__Model__ConditionalRandomVectorTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__DiscreteDistribution, _p_OpenTURNS__Uncertainty__Model__DiscreteDistributionTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__Greater, _p_OpenTURNS__Base__Common__GreaterTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory, _p_OpenTURNS__Uncertainty__Model__DistributionImplementationFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__DistributionImplementation, _p_OpenTURNS__Uncertainty__Model__DistributionImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__WeibullFactory, _p_OpenTURNS__Uncertainty__Distribution__WeibullFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__NumericalPoint, _p_OpenTURNS__Base__Type__NumericalPointTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_t, _p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_tTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation, _p_OpenTURNS__Base__Func__LinearCombinationGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Solver__Secant, _p_OpenTURNS__Base__Solver__SecantTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__LogNormalFactory, _p_OpenTURNS__Uncertainty__Distribution__LogNormalFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Normal, _p_OpenTURNS__Uncertainty__Distribution__NormalTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__LogNormal, _p_OpenTURNS__Uncertainty__Distribution__LogNormalTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Poisson, _p_OpenTURNS__Uncertainty__Distribution__PoissonTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_double_t, _p_OpenTURNS__Base__Type__PersistentCollectionT_double_tTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__ChiSquareFactory, _p_OpenTURNS__Uncertainty__Distribution__ChiSquareFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__ChiSquare, _p_OpenTURNS__Uncertainty__Distribution__ChiSquareTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Exponential, _p_OpenTURNS__Uncertainty__Distribution__ExponentialTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__ExponentialFactory, _p_OpenTURNS__Uncertainty__Distribution__ExponentialFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__CompositeRandomVector, _p_OpenTURNS__Uncertainty__Model__CompositeRandomVectorTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathFunction, _p_OpenTURNS__Base__Func__ComposedNumericalMathFunctionTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__KernelSmoothing, _p_OpenTURNS__Uncertainty__Distribution__KernelSmoothingTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__FrankCopula, _p_OpenTURNS__Uncertainty__Distribution__FrankCopulaTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__FrankCopulaFactory, _p_OpenTURNS__Uncertainty__Distribution__FrankCopulaFactoryTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation, _p_OpenTURNS__Base__Func__NumericalMathFunctionImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Common__ComparisonOperatorImplementation, _p_OpenTURNS__Base__Common__ComparisonOperatorImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__RandomVectorImplementation, _p_OpenTURNS__Uncertainty__Model__RandomVectorImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Rayleigh, _p_OpenTURNS__Uncertainty__Distribution__RayleighTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Solver__Bisection, _p_OpenTURNS__Base__Solver__BisectionTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Beta, _p_OpenTURNS__Uncertainty__Distribution__BetaTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__Curve, _p_OpenTURNS__Base__Graph__CurveTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Graph__BarPlot, _p_OpenTURNS__Base__Graph__BarPlotTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation, _p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationResult, _p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationResultTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Optim__TNC, _p_OpenTURNS__Base__Optim__TNCTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Distribution__Student, _p_OpenTURNS__Uncertainty__Distribution__StudentTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation, _p_OpenTURNS__Base__Func__LinearCombinationHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0}, {&_swigt__p_OpenTURNS__Base__Stat__Last, _p_OpenTURNS__Base__Stat__LastTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0},{0, 0, 0, 0}};
16354
static swig_cast_info _swigc__p_OpenTURNS__Base__Graph__Graph[] = { {&_swigt__p_OpenTURNS__Base__Graph__Graph, 0, 0, 0},{0, 0, 0, 0}};
16355
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__LinearModel[] = { {&_swigt__p_OpenTURNS__Base__Stat__LinearModel, 0, 0, 0},{0, 0, 0, 0}};
16356
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__NumericalSample[] = { {&_swigt__p_OpenTURNS__Base__Stat__NumericalSample, 0, 0, 0},{0, 0, 0, 0}};
16357
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__TestResult[] = { {&_swigt__p_OpenTURNS__Base__Stat__TestResult, 0, 0, 0},{0, 0, 0, 0}};
16358
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__CollectionT_OT__Uncertainty__Distribution__HistogramPair_t[] = { {&_swigt__p_OpenTURNS__Base__Type__CollectionT_OT__Uncertainty__Distribution__HistogramPair_t, 0, 0, 0},{0, 0, 0, 0}};
16359
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t[] = { {&_swigt__p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t, 0, 0, 0},{0, 0, 0, 0}};
16360
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__DistributionFactory_t[] = { {&_swigt__p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__DistributionFactory_t, 0, 0, 0},{0, 0, 0, 0}};
16361
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__Distribution_t[] = { {&_swigt__p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__Distribution_t, 0, 0, 0},{0, 0, 0, 0}};
16362
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__Description[] = { {&_swigt__p_OpenTURNS__Base__Type__Description, 0, 0, 0},{0, 0, 0, 0}};
16363
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__Indices[] = { {&_swigt__p_OpenTURNS__Base__Type__Indices, 0, 0, 0},{0, 0, 0, 0}};
16364
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_OT__Uncertainty__Distribution__UserDefinedPair_t[] = { {&_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OT__Uncertainty__Distribution__UserDefinedPair_t, 0, 0, 0},{0, 0, 0, 0}};
16365
static swig_cast_info _swigc__p_OpenTURNS__PointInSourceFile[] = { {&_swigt__p_OpenTURNS__PointInSourceFile, 0, 0, 0},{0, 0, 0, 0}};
16366
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__Distribution[] = { {&_swigt__p_OpenTURNS__Uncertainty__Model__Distribution, 0, 0, 0}, {&_swigt__p_OpenTURNS__Uncertainty__Model__Copula, _p_OpenTURNS__Uncertainty__Model__CopulaTo_p_OpenTURNS__Uncertainty__Model__Distribution, 0, 0},{0, 0, 0, 0}};
16367
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__Model__DistributionFactory[] = { {&_swigt__p_OpenTURNS__Uncertainty__Model__DistributionFactory, 0, 0, 0},{0, 0, 0, 0}};
16368
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__StatTest__FittingTest[] = { {&_swigt__p_OpenTURNS__Uncertainty__StatTest__FittingTest, 0, 0, 0},{0, 0, 0, 0}};
16369
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__StatTest__HypothesisTest[] = { {&_swigt__p_OpenTURNS__Uncertainty__StatTest__HypothesisTest, 0, 0, 0},{0, 0, 0, 0}};
16370
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__StatTest__LinearModelTest[] = { {&_swigt__p_OpenTURNS__Uncertainty__StatTest__LinearModelTest, 0, 0, 0},{0, 0, 0, 0}};
16371
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__StatTest__NormalityTest[] = { {&_swigt__p_OpenTURNS__Uncertainty__StatTest__NormalityTest, 0, 0, 0},{0, 0, 0, 0}};
16372
static swig_cast_info _swigc__p_OpenTURNS__Uncertainty__StatTest__VisualTest[] = { {&_swigt__p_OpenTURNS__Uncertainty__StatTest__VisualTest, 0, 0, 0},{0, 0, 0, 0}};
16373
static swig_cast_info _swigc__p_OptimizationProblem[] = { {&_swigt__p_OptimizationProblem, 0, 0, 0},{0, 0, 0, 0}};
16374
static swig_cast_info _swigc__p_OutOfBoundException[] = { {&_swigt__p_OutOfBoundException, 0, 0, 0},{0, 0, 0, 0}};
16375
static swig_cast_info _swigc__p_Pair[] = { {&_swigt__p_Pair, 0, 0, 0},{0, 0, 0, 0}};
16376
static swig_cast_info _swigc__p_PairCollection[] = { {&_swigt__p_PairCollection, 0, 0, 0},{0, 0, 0, 0}};
16377
static swig_cast_info _swigc__p_PersistentObject[] = { {&_swigt__p_PersistentObject, 0, 0, 0},{0, 0, 0, 0}};
16378
static swig_cast_info _swigc__p_PolynomialCollection[] = { {&_swigt__p_PolynomialCollection, 0, 0, 0},{0, 0, 0, 0}};
16379
static swig_cast_info _swigc__p_PolynomialPersistentCollection[] = { {&_swigt__p_PolynomialPersistentCollection, 0, 0, 0},{0, 0, 0, 0}};
16380
static swig_cast_info _swigc__p_Result[] = { {&_swigt__p_Result, 0, 0, 0},{0, 0, 0, 0}};
16381
static swig_cast_info _swigc__p_Severity[] = { {&_swigt__p_Severity, 0, 0, 0},{0, 0, 0, 0}};
16382
static swig_cast_info _swigc__p_SobolIndiceParameters[] = { {&_swigt__p_SobolIndiceParameters, 0, 0, 0},{0, 0, 0, 0}};
16383
static swig_cast_info _swigc__p_SobolIndiceResult[] = { {&_swigt__p_SobolIndiceResult, 0, 0, 0},{0, 0, 0, 0}};
16384
static swig_cast_info _swigc__p_SpecificParameters[] = { {&_swigt__p_SpecificParameters, 0, 0, 0},{0, 0, 0, 0}};
16385
static swig_cast_info _swigc__p_SquareMatrix[] = { {&_swigt__p_SquareMatrix, 0, 0, 0},{0, 0, 0, 0}};
16386
static swig_cast_info _swigc__p_State[] = { {&_swigt__p_State, 0, 0, 0},{0, 0, 0, 0}};
16387
static swig_cast_info _swigc__p_StorageManager[] = { {&_swigt__p_StorageManager, 0, 0, 0},{0, 0, 0, 0}};
16388
static swig_cast_info _swigc__p_StorageManagerImplementation[] = { {&_swigt__p_StorageManagerImplementation, 0, 0, 0},{0, 0, 0, 0}};
16389
static swig_cast_info _swigc__p_SymmetricMatrix[] = { {&_swigt__p_SymmetricMatrix, 0, 0, 0},{0, 0, 0, 0}};
16390
static swig_cast_info _swigc__p_SymmetricTensor[] = { {&_swigt__p_SymmetricTensor, 0, 0, 0},{0, 0, 0, 0}};
16391
static swig_cast_info _swigc__p_Tensor[] = { {&_swigt__p_Tensor, 0, 0, 0},{0, 0, 0, 0}};
16392
static swig_cast_info _swigc__p_TestResult[] = { {&_swigt__p_TestResult, 0, 0, 0},{0, 0, 0, 0}};
16393
static swig_cast_info _swigc__p_TestResultCollection[] = { {&_swigt__p_TestResultCollection, 0, 0, 0},{0, 0, 0, 0}};
16394
static swig_cast_info _swigc__p_UnsignedLongCollection[] = { {&_swigt__p_UnsignedLongCollection, 0, 0, 0},{0, 0, 0, 0}};
16395
static swig_cast_info _swigc__p_Value[] = { {&_swigt__p_Value, 0, 0, 0},{0, 0, 0, 0}};
16396
static swig_cast_info _swigc__p_ValueType[] = { {&_swigt__p_ValueType, 0, 0, 0},{0, 0, 0, 0}};
16397
static swig_cast_info _swigc__p_VariableListType[] = { {&_swigt__p_VariableListType, 0, 0, 0},{0, 0, 0, 0}};
16398
static swig_cast_info _swigc__p_WrapperFileParsingException[] = { {&_swigt__p_WrapperFileParsingException, 0, 0, 0},{0, 0, 0, 0}};
16399
static swig_cast_info _swigc__p_WrapperInternalException[] = { {&_swigt__p_WrapperInternalException, 0, 0, 0},{0, 0, 0, 0}};
16400
static swig_cast_info _swigc__p_allocator_type[] = { {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
16401
static swig_cast_info _swigc__p_bool[] = { {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
16402
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
16403
static swig_cast_info _swigc__p_const_iterator[] = { {&_swigt__p_const_iterator, 0, 0, 0},{0, 0, 0, 0}};
16404
static swig_cast_info _swigc__p_const_reverse_iterator[] = { {&_swigt__p_const_reverse_iterator, 0, 0, 0},{0, 0, 0, 0}};
16405
static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
16406
static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
16407
static swig_cast_info _swigc__p_iterator[] = { {&_swigt__p_iterator, 0, 0, 0},{0, 0, 0, 0}};
16408
static swig_cast_info _swigc__p_key_type[] = { {&_swigt__p_key_type, 0, 0, 0},{0, 0, 0, 0}};
16409
static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
16410
static swig_cast_info _swigc__p_mapped_type[] = { {&_swigt__p_mapped_type, 0, 0, 0},{0, 0, 0, 0}};
16411
static swig_cast_info _swigc__p_pointer_type[] = { {&_swigt__p_pointer_type, 0, 0, 0},{0, 0, 0, 0}};
16412
static swig_cast_info _swigc__p_reverse_iterator[] = { {&_swigt__p_reverse_iterator, 0, 0, 0},{0, 0, 0, 0}};
16413
static swig_cast_info _swigc__p_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
16414
static swig_cast_info _swigc__p_std__complexT_double_t[] = { {&_swigt__p_std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
16415
static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
16416
static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
16417
static swig_cast_info _swigc__p_swig__PySwigIterator[] = { {&_swigt__p_swig__PySwigIterator, 0, 0, 0},{0, 0, 0, 0}};
16418
static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
16419
static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
16420
static swig_cast_info _swigc__p_xNumericalSample[] = { {&_swigt__p_xNumericalSample, 0, 0, 0},{0, 0, 0, 0}};
16421
16422
static swig_cast_info *swig_cast_initial[] = {
16423
_swigc__p_Antecedent,
16424
_swigc__p_ArchimedeanCopula,
16425
_swigc__p_BoolCollection,
16426
_swigc__p_BoolPersistentCollection,
16427
_swigc__p_BoundingBox,
16428
_swigc__p_CacheImplementation,
16429
_swigc__p_CacheKeyType,
16430
_swigc__p_CacheType,
16431
_swigc__p_CacheValueType,
16432
_swigc__p_Coefficients,
16433
_swigc__p_ComparisonOperator,
16434
_swigc__p_ConfidenceIntervalCollection,
16435
_swigc__p_ConfidenceIntervalPersistentCollection,
16436
_swigc__p_Copula,
16437
_swigc__p_CopulaCollection,
16438
_swigc__p_CopulaImplementation,
16439
_swigc__p_CopulaPersistentCollection,
16440
_swigc__p_CorrelationMatrix,
16441
_swigc__p_CovarianceMatrix,
16442
_swigc__p_Description,
16443
_swigc__p_DirectoryList,
16444
_swigc__p_DiscreteDistribution,
16445
_swigc__p_Distribution,
16446
_swigc__p_DistributionCollection,
16447
_swigc__p_DistributionFactory,
16448
_swigc__p_DistributionFactoryCollection,
16449
_swigc__p_DistributionImplementation,
16450
_swigc__p_DistributionImplementationFactory,
16451
_swigc__p_DistributionPersistentCollection,
16452
_swigc__p_DrawableCollection,
16453
_swigc__p_DrawablePersistentCollection,
16454
_swigc__p_ElementType,
16455
_swigc__p_EllipticalDistribution,
16456
_swigc__p_EvaluationImplementation,
16457
_swigc__p_Factory,
16458
_swigc__p_FileListType,
16459
_swigc__p_FileNotFoundException,
16460
_swigc__p_Format,
16461
_swigc__p_FunctionalChaosResult,
16462
_swigc__p_GradientImplementation,
16463
_swigc__p_Graph,
16464
_swigc__p_GraphCollection,
16465
_swigc__p_HessianImplementation,
16466
_swigc__p_IdentityMatrix,
16467
_swigc__p_Implementation,
16468
_swigc__p_ImplementationAsPersistentObject,
16469
_swigc__p_ImplementationElementType,
16470
_swigc__p_ImplementationType,
16471
_swigc__p_Indices,
16472
_swigc__p_InternalException,
16473
_swigc__p_InternalFunction,
16474
_swigc__p_InternalGradient,
16475
_swigc__p_InternalHessian,
16476
_swigc__p_InternalType,
16477
_swigc__p_Interval,
16478
_swigc__p_InvalidArgumentException,
16479
_swigc__p_InvalidDimensionException,
16480
_swigc__p_InverseIsoProbabilisticTransformation,
16481
_swigc__p_IsoProbabilisticTransformation,
16482
_swigc__p_KeyType,
16483
_swigc__p_LabelMap,
16484
_swigc__p_LinearModel,
16485
_swigc__p_Map,
16486
_swigc__p_MapElement,
16487
_swigc__p_MappedType,
16488
_swigc__p_Matrix,
16489
_swigc__p_MersenneTwister,
16490
_swigc__p_NoWrapperFileFoundException,
16491
_swigc__p_NonEllipticalDistribution,
16492
_swigc__p_Normal,
16493
_swigc__p_NotDefinedException,
16494
_swigc__p_NotSymmetricDefinitePositiveException,
16495
_swigc__p_NumericalComplexCollection,
16496
_swigc__p_NumericalComplexPersistentCollection,
16497
_swigc__p_NumericalMathFunction,
16498
_swigc__p_NumericalMathFunctionCollection,
16499
_swigc__p_NumericalMathFunctionPersistentCollection,
16500
_swigc__p_NumericalPoint,
16501
_swigc__p_NumericalPointCollection,
16502
_swigc__p_NumericalPointWithDescription,
16503
_swigc__p_NumericalPointWithDescriptionCollection,
16504
_swigc__p_NumericalSample,
16505
_swigc__p_NumericalScalarCollection,
16506
_swigc__p_NumericalScalarPersistentCollection,
16507
_swigc__p_OT__Base__Optim__AbdoRackwitzSpecificParameters,
16508
_swigc__p_OT__Base__Optim__CobylaSpecificParameters,
16509
_swigc__p_OT__Base__Optim__NearestPointAlgorithmImplementation__Result,
16510
_swigc__p_OT__Base__Optim__NearestPointChecker__Result,
16511
_swigc__p_OT__Base__Optim__SQPSpecificParameters,
16512
_swigc__p_OT__Base__Optim__TNCSpecificParameters,
16513
_swigc__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters,
16514
_swigc__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult,
16515
_swigc__p_OT__Base__Stat__RandomGeneratorState,
16516
_swigc__p_OT__Uncertainty__Distribution__HistogramPair,
16517
_swigc__p_OT__Uncertainty__Distribution__UserDefinedPair,
16518
_swigc__p_OpenTURNS__Base__Common__ComparisonOperator,
16519
_swigc__p_OpenTURNS__Base__Common__ComparisonOperatorImplementation,
16520
_swigc__p_OpenTURNS__Base__Common__Equal,
16521
_swigc__p_OpenTURNS__Base__Common__Greater,
16522
_swigc__p_OpenTURNS__Base__Common__GreaterOrEqual,
16523
_swigc__p_OpenTURNS__Base__Common__InterfaceObject,
16524
_swigc__p_OpenTURNS__Base__Common__Less,
16525
_swigc__p_OpenTURNS__Base__Common__LessOrEqual,
16526
_swigc__p_OpenTURNS__Base__Common__Object,
16527
_swigc__p_OpenTURNS__Base__Common__PersistentObject,
16528
_swigc__p_OpenTURNS__Base__Common__StorageManager,
16529
_swigc__p_OpenTURNS__Base__Common__Study,
16530
_swigc__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t,
16531
_swigc__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t,
16532
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Common__ComparisonOperatorImplementation_t,
16533
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__NumericalMathFunctionImplementation_t,
16534
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__UniVariatePolynomialImplementation_t,
16535
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__DrawableImplementation_t,
16536
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Graph__GraphImplementation_t,
16537
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation_t,
16538
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation_t,
16539
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Solver__SolverImplementation_t,
16540
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__HistoryStrategyImplementation_t,
16541
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation_t,
16542
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t,
16543
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t,
16544
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__MatrixImplementation_t,
16545
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__TensorImplementation_t,
16546
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory_t,
16547
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__DistributionImplementation_t,
16548
_swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Uncertainty__Model__RandomVectorImplementation_t,
16549
_swigc__p_OpenTURNS__Base__Common__XMLStorageManager,
16550
_swigc__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient,
16551
_swigc__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian,
16552
_swigc__p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient,
16553
_swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation,
16554
_swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathFunction,
16555
_swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation,
16556
_swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation,
16557
_swigc__p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation,
16558
_swigc__p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation,
16559
_swigc__p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation,
16560
_swigc__p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation,
16561
_swigc__p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation,
16562
_swigc__p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation,
16563
_swigc__p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation,
16564
_swigc__p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation,
16565
_swigc__p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation,
16566
_swigc__p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation,
16567
_swigc__p_OpenTURNS__Base__Func__LinearNumericalMathFunction,
16568
_swigc__p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation,
16569
_swigc__p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation,
16570
_swigc__p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation,
16571
_swigc__p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation,
16572
_swigc__p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation,
16573
_swigc__p_OpenTURNS__Base__Func__NumericalMathFunction,
16574
_swigc__p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation,
16575
_swigc__p_OpenTURNS__Base__Func__NumericalMathGradientImplementation,
16576
_swigc__p_OpenTURNS__Base__Func__NumericalMathHessianImplementation,
16577
_swigc__p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation,
16578
_swigc__p_OpenTURNS__Base__Func__ProductNumericalMathFunction,
16579
_swigc__p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation,
16580
_swigc__p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation,
16581
_swigc__p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation,
16582
_swigc__p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation,
16583
_swigc__p_OpenTURNS__Base__Func__UniVariatePolynomial,
16584
_swigc__p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation,
16585
_swigc__p_OpenTURNS__Base__Func__WrapperData,
16586
_swigc__p_OpenTURNS__Base__Func__WrapperDataFile,
16587
_swigc__p_OpenTURNS__Base__Func__WrapperDataVariable,
16588
_swigc__p_OpenTURNS__Base__Func__WrapperFile,
16589
_swigc__p_OpenTURNS__Base__Func__WrapperFrameworkData,
16590
_swigc__p_OpenTURNS__Base__Func__WrapperFunctionDescription,
16591
_swigc__p_OpenTURNS__Base__Func__WrapperParameter,
16592
_swigc__p_OpenTURNS__Base__Graph__BarPlot,
16593
_swigc__p_OpenTURNS__Base__Graph__Cloud,
16594
_swigc__p_OpenTURNS__Base__Graph__Contour,
16595
_swigc__p_OpenTURNS__Base__Graph__Curve,
16596
_swigc__p_OpenTURNS__Base__Graph__Drawable,
16597
_swigc__p_OpenTURNS__Base__Graph__DrawableImplementation,
16598
_swigc__p_OpenTURNS__Base__Graph__Graph,
16599
_swigc__p_OpenTURNS__Base__Graph__GraphImplementation,
16600
_swigc__p_OpenTURNS__Base__Graph__Pie,
16601
_swigc__p_OpenTURNS__Base__Graph__Staircase,
16602
_swigc__p_OpenTURNS__Base__Optim__AbdoRackwitz,
16603
_swigc__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithm,
16604
_swigc__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementation,
16605
_swigc__p_OpenTURNS__Base__Optim__BoundConstrainedAlgorithmImplementationResult,
16606
_swigc__p_OpenTURNS__Base__Optim__Cobyla,
16607
_swigc__p_OpenTURNS__Base__Optim__NearestPointAlgorithm,
16608
_swigc__p_OpenTURNS__Base__Optim__NearestPointAlgorithmImplementation,
16609
_swigc__p_OpenTURNS__Base__Optim__NearestPointChecker,
16610
_swigc__p_OpenTURNS__Base__Optim__PenalizedLeastSquaresAlgorithm,
16611
_swigc__p_OpenTURNS__Base__Optim__SQP,
16612
_swigc__p_OpenTURNS__Base__Optim__TNC,
16613
_swigc__p_OpenTURNS__Base__Solver__Bisection,
16614
_swigc__p_OpenTURNS__Base__Solver__Brent,
16615
_swigc__p_OpenTURNS__Base__Solver__Secant,
16616
_swigc__p_OpenTURNS__Base__Solver__Solver,
16617
_swigc__p_OpenTURNS__Base__Solver__SolverImplementation,
16618
_swigc__p_OpenTURNS__Base__Stat__Compact,
16619
_swigc__p_OpenTURNS__Base__Stat__ConfidenceInterval,
16620
_swigc__p_OpenTURNS__Base__Stat__CorrelationMatrix,
16621
_swigc__p_OpenTURNS__Base__Stat__CovarianceMatrix,
16622
_swigc__p_OpenTURNS__Base__Stat__Full,
16623
_swigc__p_OpenTURNS__Base__Stat__HaltonSequence,
16624
_swigc__p_OpenTURNS__Base__Stat__HistoryStrategy,
16625
_swigc__p_OpenTURNS__Base__Stat__HistoryStrategyImplementation,
16626
_swigc__p_OpenTURNS__Base__Stat__Last,
16627
_swigc__p_OpenTURNS__Base__Stat__LinearModel,
16628
_swigc__p_OpenTURNS__Base__Stat__LowDiscrepancySequence,
16629
_swigc__p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation,
16630
_swigc__p_OpenTURNS__Base__Stat__Null,
16631
_swigc__p_OpenTURNS__Base__Stat__NumericalSample,
16632
_swigc__p_OpenTURNS__Base__Stat__NumericalSampleImplementation,
16633
_swigc__p_OpenTURNS__Base__Stat__SobolSequence,
16634
_swigc__p_OpenTURNS__Base__Stat__TestResult,
16635
_swigc__p_OpenTURNS__Base__Type__CollectionT_OT__Uncertainty__Distribution__HistogramPair_t,
16636
_swigc__p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Base__Stat__TestResult_t,
16637
_swigc__p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__DistributionFactory_t,
16638
_swigc__p_OpenTURNS__Base__Type__CollectionT_OpenTURNS__Uncertainty__Model__Distribution_t,
16639
_swigc__p_OpenTURNS__Base__Type__Description,
16640
_swigc__p_OpenTURNS__Base__Type__DescriptionImplementation,
16641
_swigc__p_OpenTURNS__Base__Type__IdentityMatrix,
16642
_swigc__p_OpenTURNS__Base__Type__Indices,
16643
_swigc__p_OpenTURNS__Base__Type__Interval,
16644
_swigc__p_OpenTURNS__Base__Type__Matrix,
16645
_swigc__p_OpenTURNS__Base__Type__MatrixImplementation,
16646
_swigc__p_OpenTURNS__Base__Type__NumericalPoint,
16647
_swigc__p_OpenTURNS__Base__Type__NumericalPointWithDescription,
16648
_swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_OT__Uncertainty__Distribution__UserDefinedPair_t,
16649
_swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_t,
16650
_swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_t,
16651
_swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_t,
16652
_swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_double_t,
16653
_swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_t,
16654
_swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_t,
16655
_swigc__p_OpenTURNS__Base__Type__SquareMatrix,
16656
_swigc__p_OpenTURNS__Base__Type__SymmetricMatrix,
16657
_swigc__p_OpenTURNS__Base__Type__SymmetricTensor,
16658
_swigc__p_OpenTURNS__Base__Type__Tensor,
16659
_swigc__p_OpenTURNS__Base__Type__TensorImplementation,
16660
_swigc__p_OpenTURNS__PointInSourceFile,
16661
_swigc__p_OpenTURNS__Uncertainty__Distribution__Beta,
16662
_swigc__p_OpenTURNS__Uncertainty__Distribution__BetaFactory,
16663
_swigc__p_OpenTURNS__Uncertainty__Distribution__ChiSquare,
16664
_swigc__p_OpenTURNS__Uncertainty__Distribution__ChiSquareFactory,
16665
_swigc__p_OpenTURNS__Uncertainty__Distribution__ClaytonCopula,
16666
_swigc__p_OpenTURNS__Uncertainty__Distribution__ClaytonCopulaFactory,
16667
_swigc__p_OpenTURNS__Uncertainty__Distribution__ComposedCopula,
16668
_swigc__p_OpenTURNS__Uncertainty__Distribution__ComposedDistribution,
16669
_swigc__p_OpenTURNS__Uncertainty__Distribution__Epanechnikov,
16670
_swigc__p_OpenTURNS__Uncertainty__Distribution__Exponential,
16671
_swigc__p_OpenTURNS__Uncertainty__Distribution__ExponentialFactory,
16672
_swigc__p_OpenTURNS__Uncertainty__Distribution__FrankCopula,
16673
_swigc__p_OpenTURNS__Uncertainty__Distribution__FrankCopulaFactory,
16674
_swigc__p_OpenTURNS__Uncertainty__Distribution__Gamma,
16675
_swigc__p_OpenTURNS__Uncertainty__Distribution__GammaFactory,
16676
_swigc__p_OpenTURNS__Uncertainty__Distribution__Geometric,
16677
_swigc__p_OpenTURNS__Uncertainty__Distribution__GeometricFactory,
16678
_swigc__p_OpenTURNS__Uncertainty__Distribution__Gumbel,
16679
_swigc__p_OpenTURNS__Uncertainty__Distribution__GumbelCopula,
16680
_swigc__p_OpenTURNS__Uncertainty__Distribution__GumbelCopulaFactory,
16681
_swigc__p_OpenTURNS__Uncertainty__Distribution__GumbelFactory,
16682
_swigc__p_OpenTURNS__Uncertainty__Distribution__Histogram,
16683
_swigc__p_OpenTURNS__Uncertainty__Distribution__HistogramFactory,
16684
_swigc__p_OpenTURNS__Uncertainty__Distribution__IndependentCopula,
16685
_swigc__p_OpenTURNS__Uncertainty__Distribution__KernelMixture,
16686
_swigc__p_OpenTURNS__Uncertainty__Distribution__KernelSmoothing,
16687
_swigc__p_OpenTURNS__Uncertainty__Distribution__Laplace,
16688
_swigc__p_OpenTURNS__Uncertainty__Distribution__LaplaceFactory,
16689
_swigc__p_OpenTURNS__Uncertainty__Distribution__LogNormal,
16690
_swigc__p_OpenTURNS__Uncertainty__Distribution__LogNormalFactory,
16691
_swigc__p_OpenTURNS__Uncertainty__Distribution__Logistic,
16692
_swigc__p_OpenTURNS__Uncertainty__Distribution__LogisticFactory,
16693
_swigc__p_OpenTURNS__Uncertainty__Distribution__Mixture,
16694
_swigc__p_OpenTURNS__Uncertainty__Distribution__MultiNomial,
16695
_swigc__p_OpenTURNS__Uncertainty__Distribution__MultiNomialFactory,
16696
_swigc__p_OpenTURNS__Uncertainty__Distribution__NonCentralStudent,
16697
_swigc__p_OpenTURNS__Uncertainty__Distribution__Normal,
16698
_swigc__p_OpenTURNS__Uncertainty__Distribution__NormalCopula,
16699
_swigc__p_OpenTURNS__Uncertainty__Distribution__NormalCopulaFactory,
16700
_swigc__p_OpenTURNS__Uncertainty__Distribution__NormalFactory,
16701
_swigc__p_OpenTURNS__Uncertainty__Distribution__Poisson,
16702
_swigc__p_OpenTURNS__Uncertainty__Distribution__PoissonFactory,
16703
_swigc__p_OpenTURNS__Uncertainty__Distribution__RandomMixture,
16704
_swigc__p_OpenTURNS__Uncertainty__Distribution__Rayleigh,
16705
_swigc__p_OpenTURNS__Uncertainty__Distribution__RayleighFactory,
16706
_swigc__p_OpenTURNS__Uncertainty__Distribution__Student,
16707
_swigc__p_OpenTURNS__Uncertainty__Distribution__StudentFactory,
16708
_swigc__p_OpenTURNS__Uncertainty__Distribution__Triangular,
16709
_swigc__p_OpenTURNS__Uncertainty__Distribution__TriangularFactory,
16710
_swigc__p_OpenTURNS__Uncertainty__Distribution__TruncatedDistribution,
16711
_swigc__p_OpenTURNS__Uncertainty__Distribution__TruncatedNormal,
16712
_swigc__p_OpenTURNS__Uncertainty__Distribution__TruncatedNormalFactory,
16713
_swigc__p_OpenTURNS__Uncertainty__Distribution__Uniform,
16714
_swigc__p_OpenTURNS__Uncertainty__Distribution__UniformFactory,
16715
_swigc__p_OpenTURNS__Uncertainty__Distribution__UserDefined,
16716
_swigc__p_OpenTURNS__Uncertainty__Distribution__UserDefinedFactory,
16717
_swigc__p_OpenTURNS__Uncertainty__Distribution__Weibull,
16718
_swigc__p_OpenTURNS__Uncertainty__Distribution__WeibullFactory,
16719
_swigc__p_OpenTURNS__Uncertainty__Model__ArchimedeanCopula,
16720
_swigc__p_OpenTURNS__Uncertainty__Model__CompositeRandomVector,
16721
_swigc__p_OpenTURNS__Uncertainty__Model__ConditionalRandomVector,
16722
_swigc__p_OpenTURNS__Uncertainty__Model__ConstantRandomVector,
16723
_swigc__p_OpenTURNS__Uncertainty__Model__ContinuousDistribution,
16724
_swigc__p_OpenTURNS__Uncertainty__Model__Copula,
16725
_swigc__p_OpenTURNS__Uncertainty__Model__CopulaImplementation,
16726
_swigc__p_OpenTURNS__Uncertainty__Model__DiscreteDistribution,
16727
_swigc__p_OpenTURNS__Uncertainty__Model__Distribution,
16728
_swigc__p_OpenTURNS__Uncertainty__Model__DistributionFactory,
16729
_swigc__p_OpenTURNS__Uncertainty__Model__DistributionImplementation,
16730
_swigc__p_OpenTURNS__Uncertainty__Model__DistributionImplementationFactory,
16731
_swigc__p_OpenTURNS__Uncertainty__Model__EllipticalDistribution,
16732
_swigc__p_OpenTURNS__Uncertainty__Model__Event,
16733
_swigc__p_OpenTURNS__Uncertainty__Model__EventRandomVectorImplementation,
16734
_swigc__p_OpenTURNS__Uncertainty__Model__NonEllipticalDistribution,
16735
_swigc__p_OpenTURNS__Uncertainty__Model__RandomVector,
16736
_swigc__p_OpenTURNS__Uncertainty__Model__RandomVectorImplementation,
16737
_swigc__p_OpenTURNS__Uncertainty__Model__SklarCopula,
16738
_swigc__p_OpenTURNS__Uncertainty__Model__StandardEvent,
16739
_swigc__p_OpenTURNS__Uncertainty__Model__UsualDistribution,
16740
_swigc__p_OpenTURNS__Uncertainty__Model__UsualRandomVector,
16741
_swigc__p_OpenTURNS__Uncertainty__StatTest__FittingTest,
16742
_swigc__p_OpenTURNS__Uncertainty__StatTest__HypothesisTest,
16743
_swigc__p_OpenTURNS__Uncertainty__StatTest__LinearModelTest,
16744
_swigc__p_OpenTURNS__Uncertainty__StatTest__NormalityTest,
16745
_swigc__p_OpenTURNS__Uncertainty__StatTest__VisualTest,
16746
_swigc__p_OptimizationProblem,
16747
_swigc__p_OutOfBoundException,
16748
_swigc__p_Pair,
16749
_swigc__p_PairCollection,
16750
_swigc__p_PersistentObject,
16751
_swigc__p_PolynomialCollection,
16752
_swigc__p_PolynomialPersistentCollection,
16753
_swigc__p_Result,
16754
_swigc__p_Severity,
16755
_swigc__p_SobolIndiceParameters,
16756
_swigc__p_SobolIndiceResult,
16757
_swigc__p_SpecificParameters,
16758
_swigc__p_SquareMatrix,
16759
_swigc__p_State,
16760
_swigc__p_StorageManager,
16761
_swigc__p_StorageManagerImplementation,
16762
_swigc__p_SymmetricMatrix,
16763
_swigc__p_SymmetricTensor,
16764
_swigc__p_Tensor,
16765
_swigc__p_TestResult,
16766
_swigc__p_TestResultCollection,
16767
_swigc__p_UnsignedLongCollection,
16768
_swigc__p_Value,
16769
_swigc__p_ValueType,
16770
_swigc__p_VariableListType,
16771
_swigc__p_WrapperFileParsingException,
16772
_swigc__p_WrapperInternalException,
16773
_swigc__p_allocator_type,
16774
_swigc__p_bool,
16775
_swigc__p_char,
16776
_swigc__p_const_iterator,
16777
_swigc__p_const_reverse_iterator,
16778
_swigc__p_difference_type,
16779
_swigc__p_double,
16780
_swigc__p_iterator,
16781
_swigc__p_key_type,
16782
_swigc__p_long,
16783
_swigc__p_mapped_type,
16784
_swigc__p_pointer_type,
16785
_swigc__p_reverse_iterator,
16786
_swigc__p_size_type,
16787
_swigc__p_std__complexT_double_t,
16788
_swigc__p_std__invalid_argument,
16789
_swigc__p_std__string,
16790
_swigc__p_swig__PySwigIterator,
16791
_swigc__p_unsigned_long,
16792
_swigc__p_value_type,
16793
_swigc__p_xNumericalSample,
16794
};
16795
16796
16797
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
16798
16799
static swig_const_info swig_const_table[] = {
16800
{0, 0, 0, 0.0, 0, 0}};
16801
16802
#ifdef __cplusplus
16803
}
16804
#endif
16805
/* -----------------------------------------------------------------------------
16806
* Type initialization:
16807
* This problem is tough by the requirement that no dynamic
16808
* memory is used. Also, since swig_type_info structures store pointers to
16809
* swig_cast_info structures and swig_cast_info structures store pointers back
16810
* to swig_type_info structures, we need some lookup code at initialization.
16811
* The idea is that swig generates all the structures that are needed.
16812
* The runtime then collects these partially filled structures.
16813
* The SWIG_InitializeModule function takes these initial arrays out of
16814
* swig_module, and does all the lookup, filling in the swig_module.types
16815
* array with the correct data and linking the correct swig_cast_info
16816
* structures together.
16817
*
16818
* The generated swig_type_info structures are assigned staticly to an initial
16819
* array. We just loop through that array, and handle each type individually.
16820
* First we lookup if this type has been already loaded, and if so, use the
16821
* loaded structure instead of the generated one. Then we have to fill in the
16822
* cast linked list. The cast data is initially stored in something like a
16823
* two-dimensional array. Each row corresponds to a type (there are the same
16824
* number of rows as there are in the swig_type_initial array). Each entry in
16825
* a column is one of the swig_cast_info structures for that type.
16826
* The cast_initial array is actually an array of arrays, because each row has
16827
* a variable number of columns. So to actually build the cast linked list,
16828
* we find the array of casts associated with the type, and loop through it
16829
* adding the casts to the list. The one last trick we need to do is making
16830
* sure the type pointer in the swig_cast_info struct is correct.
16831
*
16832
* First off, we lookup the cast->type name to see if it is already loaded.
16833
* There are three cases to handle:
16834
* 1) If the cast->type has already been loaded AND the type we are adding
16835
* casting info to has not been loaded (it is in this module), THEN we
16836
* replace the cast->type pointer with the type pointer that has already
16837
* been loaded.
16838
* 2) If BOTH types (the one we are adding casting info to, and the
16839
* cast->type) are loaded, THEN the cast info has already been loaded by
16840
* the previous module so we just ignore it.
16841
* 3) Finally, if cast->type has not already been loaded, then we add that
16842
* swig_cast_info to the linked list (because the cast->type) pointer will
16843
* be correct.
16844
* ----------------------------------------------------------------------------- */
16845
16846
#ifdef __cplusplus
16847
extern "C" {
16848
#if 0
16849
} /* c-mode */
16850
#endif
16851
#endif
16852
16853
#if 0
16854
#define SWIGRUNTIME_DEBUG
16855
#endif
16856
16857
16858
SWIGRUNTIME void
16859
SWIG_InitializeModule(void *clientdata) {
16860
size_t i;
16861
swig_module_info *module_head, *iter;
16862
int found, init;
16863
16864
clientdata = clientdata;
16865
16866
/* check to see if the circular list has been setup, if not, set it up */
16867
if (swig_module.next==0) {
16868
/* Initialize the swig_module */
16869
swig_module.type_initial = swig_type_initial;
16870
swig_module.cast_initial = swig_cast_initial;
16871
swig_module.next = &swig_module;
16872
init = 1;
16873
} else {
16874
init = 0;
16875
}
16876
16877
/* Try and load any already created modules */
16878
module_head = SWIG_GetModule(clientdata);
16879
if (!module_head) {
16880
/* This is the first module loaded for this interpreter */
16881
/* so set the swig module into the interpreter */
16882
SWIG_SetModule(clientdata, &swig_module);
16883
module_head = &swig_module;
16884
} else {
16885
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
16886
found=0;
16887
iter=module_head;
16888
do {
16889
if (iter==&swig_module) {
16890
found=1;
16891
break;
16892
}
16893
iter=iter->next;
16894
} while (iter!= module_head);
16895
16896
/* if the is found in the list, then all is done and we may leave */
16897
if (found) return;
16898
/* otherwise we must add out module into the list */
16899
swig_module.next = module_head->next;
16900
module_head->next = &swig_module;
16901
}
16902
16903
/* When multiple interpeters are used, a module could have already been initialized in
16904
a different interpreter, but not yet have a pointer in this interpreter.
16905
In this case, we do not want to continue adding types... everything should be
16906
set up already */
16907
if (init == 0) return;
16908
16909
/* Now work on filling in swig_module.types */
16910
#ifdef SWIGRUNTIME_DEBUG
16911
printf("SWIG_InitializeModule: size %d\n", swig_module.size);
16912
#endif
16913
for (i = 0; i < swig_module.size; ++i) {
16914
swig_type_info *type = 0;
16915
swig_type_info *ret;
16916
swig_cast_info *cast;
16917
16918
#ifdef SWIGRUNTIME_DEBUG
16919
printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
16920
#endif
16921
16922
/* if there is another module already loaded */
16923
if (swig_module.next != &swig_module) {
16924
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
16925
}
16926
if (type) {
16927
/* Overwrite clientdata field */
16928
#ifdef SWIGRUNTIME_DEBUG
16929
printf("SWIG_InitializeModule: found type %s\n", type->name);
16930
#endif
16931
if (swig_module.type_initial[i]->clientdata) {
16932
type->clientdata = swig_module.type_initial[i]->clientdata;
16933
#ifdef SWIGRUNTIME_DEBUG
16934
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
16935
#endif
16936
}
16937
} else {
16938
type = swig_module.type_initial[i];
16939
}
16940
16941
/* Insert casting types */
16942
cast = swig_module.cast_initial[i];
16943
while (cast->type) {
16944
/* Don't need to add information already in the list */
16945
ret = 0;
16946
#ifdef SWIGRUNTIME_DEBUG
16947
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
16948
#endif
16949
if (swig_module.next != &swig_module) {
16950
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
16951
#ifdef SWIGRUNTIME_DEBUG
16952
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
16953
#endif
16954
}
16955
if (ret) {
16956
if (type == swig_module.type_initial[i]) {
16957
#ifdef SWIGRUNTIME_DEBUG
16958
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
16959
#endif
16960
cast->type = ret;
16961
ret = 0;
16962
} else {
16963
/* Check for casting already in the list */
16964
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
16965
#ifdef SWIGRUNTIME_DEBUG
16966
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
16967
#endif
16968
if (!ocast) ret = 0;
16969
}
16970
}
16971
16972
if (!ret) {
16973
#ifdef SWIGRUNTIME_DEBUG
16974
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
16975
#endif
16976
if (type->cast) {
16977
type->cast->prev = cast;
16978
cast->next = type->cast;
16979
}
16980
type->cast = cast;
16981
}
16982
cast++;
16983
}
16984
/* Set entry in modules->types array equal to the type */
16985
swig_module.types[i] = type;
16986
}
16987
swig_module.types[i] = 0;
16988
16989
#ifdef SWIGRUNTIME_DEBUG
16990
printf("**** SWIG_InitializeModule: Cast List ******\n");
16991
for (i = 0; i < swig_module.size; ++i) {
16992
int j = 0;
16993
swig_cast_info *cast = swig_module.cast_initial[i];
16994
printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
16995
while (cast->type) {
16996
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
16997
cast++;
16998
++j;
16999
}
17000
printf("---- Total casts: %d\n",j);
17001
}
17002
printf("**** SWIG_InitializeModule: Cast List ******\n");
17003
#endif
17004
}
17005
17006
/* This function will propagate the clientdata field of type to
17007
* any new swig_type_info structures that have been added into the list
17008
* of equivalent types. It is like calling
17009
* SWIG_TypeClientData(type, clientdata) a second time.
17010
*/
17011
SWIGRUNTIME void
17012
SWIG_PropagateClientData(void) {
17013
size_t i;
17014
swig_cast_info *equiv;
17015
static int init_run = 0;
17016
17017
if (init_run) return;
17018
init_run = 1;
17019
17020
for (i = 0; i < swig_module.size; i++) {
17021
if (swig_module.types[i]->clientdata) {
17022
equiv = swig_module.types[i]->cast;
17023
while (equiv) {
17024
if (!equiv->converter) {
17025
if (equiv->type && !equiv->type->clientdata)
17026
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
17027
}
17028
equiv = equiv->next;
17029
}
17030
}
17031
}
17032
}
17033
17034
#ifdef __cplusplus
17035
#if 0
17036
{
17037
/* c-mode */
17038
#endif
17039
}
17040
#endif
17041
17042
17043
17044
#ifdef __cplusplus
17045
extern "C" {
17046
#endif
17047
17048
/* Python-specific SWIG API */
17049
#define SWIG_newvarlink() SWIG_Python_newvarlink()
17050
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
17051
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
17052
17053
/* -----------------------------------------------------------------------------
17054
* global variable support code.
17055
* ----------------------------------------------------------------------------- */
17056
17057
typedef struct swig_globalvar {
17058
char *name; /* Name of global variable */
17059
PyObject *(*get_attr)(void); /* Return the current value */
17060
int (*set_attr)(PyObject *); /* Set the value */
17061
struct swig_globalvar *next;
17062
} swig_globalvar;
17063
17064
typedef struct swig_varlinkobject {
17065
PyObject_HEAD
17066
swig_globalvar *vars;
17067
} swig_varlinkobject;
17068
17069
SWIGINTERN PyObject *
17070
swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
17071
return PyString_FromString("<Swig global variables>");
17072
}
17073
17074
SWIGINTERN PyObject *
17075
swig_varlink_str(swig_varlinkobject *v) {
17076
PyObject *str = PyString_FromString("(");
17077
swig_globalvar *var;
17078
for (var = v->vars; var; var=var->next) {
17079
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
17080
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
17081
}
17082
PyString_ConcatAndDel(&str,PyString_FromString(")"));
17083
return str;
17084
}
17085
17086
SWIGINTERN int
17087
swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
17088
PyObject *str = swig_varlink_str(v);
17089
fprintf(fp,"Swig global variables ");
17090
fprintf(fp,"%s\n", PyString_AsString(str));
17091
Py_DECREF(str);
17092
return 0;
17093
}
17094
17095
SWIGINTERN void
17096
swig_varlink_dealloc(swig_varlinkobject *v) {
17097
swig_globalvar *var = v->vars;
17098
while (var) {
17099
swig_globalvar *n = var->next;
17100
free(var->name);
17101
free(var);
17102
var = n;
17103
}
17104
}
17105
17106
SWIGINTERN PyObject *
17107
swig_varlink_getattr(swig_varlinkobject *v, char *n) {
17108
PyObject *res = NULL;
17109
swig_globalvar *var = v->vars;
17110
while (var) {
17111
if (strcmp(var->name,n) == 0) {
17112
res = (*var->get_attr)();
17113
break;
17114
}
17115
var = var->next;
17116
}
17117
if (res == NULL && !PyErr_Occurred()) {
17118
PyErr_SetString(PyExc_NameError,"Unknown C global variable");
17119
}
17120
return res;
17121
}
17122
17123
SWIGINTERN int
17124
swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
17125
int res = 1;
17126
swig_globalvar *var = v->vars;
17127
while (var) {
17128
if (strcmp(var->name,n) == 0) {
17129
res = (*var->set_attr)(p);
17130
break;
17131
}
17132
var = var->next;
17133
}
17134
if (res == 1 && !PyErr_Occurred()) {
17135
PyErr_SetString(PyExc_NameError,"Unknown C global variable");
17136
}
17137
return res;
17138
}
17139
17140
SWIGINTERN PyTypeObject*
17141
swig_varlink_type(void) {
17142
static char varlink__doc__[] = "Swig var link object";
17143
static PyTypeObject varlink_type;
17144
static int type_init = 0;
17145
if (!type_init) {
17146
const PyTypeObject tmp
17147
= {
17148
PyObject_HEAD_INIT(NULL)
17149
0, /* Number of items in variable part (ob_size) */
17150
(char *)"swigvarlink", /* Type name (tp_name) */
17151
sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
17152
0, /* Itemsize (tp_itemsize) */
17153
(destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
17154
(printfunc) swig_varlink_print, /* Print (tp_print) */
17155
(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
17156
(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
17157
0, /* tp_compare */
17158
(reprfunc) swig_varlink_repr, /* tp_repr */
17159
0, /* tp_as_number */
17160
0, /* tp_as_sequence */
17161
0, /* tp_as_mapping */
17162
0, /* tp_hash */
17163
0, /* tp_call */
17164
(reprfunc)swig_varlink_str, /* tp_str */
17165
0, /* tp_getattro */
17166
0, /* tp_setattro */
17167
0, /* tp_as_buffer */
17168
0, /* tp_flags */
17169
varlink__doc__, /* tp_doc */
17170
0, /* tp_traverse */
17171
0, /* tp_clear */
17172
0, /* tp_richcompare */
17173
0, /* tp_weaklistoffset */
17174
#if PY_VERSION_HEX >= 0x02020000
17175
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
17176
#endif
17177
#if PY_VERSION_HEX >= 0x02030000
17178
0, /* tp_del */
17179
#endif
17180
#ifdef COUNT_ALLOCS
17181
0,0,0,0 /* tp_alloc -> tp_next */
17182
#endif
17183
};
17184
varlink_type = tmp;
17185
varlink_type.ob_type = &PyType_Type;
17186
type_init = 1;
17187
}
17188
return &varlink_type;
17189
}
17190
17191
/* Create a variable linking object for use later */
17192
SWIGINTERN PyObject *
17193
SWIG_Python_newvarlink(void) {
17194
swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
17195
if (result) {
17196
result->vars = 0;
17197
}
17198
return ((PyObject*) result);
17199
}
17200
17201
SWIGINTERN void
17202
SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
17203
swig_varlinkobject *v = (swig_varlinkobject *) p;
17204
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
17205
if (gv) {
17206
size_t size = strlen(name)+1;
17207
gv->name = (char *)malloc(size);
17208
if (gv->name) {
17209
strncpy(gv->name,name,size);
17210
gv->get_attr = get_attr;
17211
gv->set_attr = set_attr;
17212
gv->next = v->vars;
17213
}
17214
}
17215
v->vars = gv;
17216
}
17217
17218
SWIGINTERN PyObject *
17219
SWIG_globals(void) {
17220
static PyObject *_SWIG_globals = 0;
17221
if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
17222
return _SWIG_globals;
17223
}
17224
17225
/* -----------------------------------------------------------------------------
17226
* constants/methods manipulation
17227
* ----------------------------------------------------------------------------- */
17228
17229
/* Install Constants */
17230
SWIGINTERN void
17231
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
17232
PyObject *obj = 0;
17233
size_t i;
17234
for (i = 0; constants[i].type; ++i) {
17235
switch(constants[i].type) {
17236
case SWIG_PY_POINTER:
17237
obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
17238
break;
17239
case SWIG_PY_BINARY:
17240
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
17241
break;
17242
default:
17243
obj = 0;
17244
break;
17245
}
17246
if (obj) {
17247
PyDict_SetItemString(d, constants[i].name, obj);
17248
Py_DECREF(obj);
17249
}
17250
}
17251
}
17252
17253
/* -----------------------------------------------------------------------------*/
17254
/* Fix SwigMethods to carry the callback ptrs when needed */
17255
/* -----------------------------------------------------------------------------*/
17256
17257
SWIGINTERN void
17258
SWIG_Python_FixMethods(PyMethodDef *methods,
17259
swig_const_info *const_table,
17260
swig_type_info **types,
17261
swig_type_info **types_initial) {
17262
size_t i;
17263
for (i = 0; methods[i].ml_name; ++i) {
17264
const char *c = methods[i].ml_doc;
17265
if (c && (c = strstr(c, "swig_ptr: "))) {
17266
int j;
17267
swig_const_info *ci = 0;
17268
const char *name = c + 10;
17269
for (j = 0; const_table[j].type; ++j) {
17270
if (strncmp(const_table[j].name, name,
17271
strlen(const_table[j].name)) == 0) {
17272
ci = &(const_table[j]);
17273
break;
17274
}
17275
}
17276
if (ci) {
17277
size_t shift = (ci->ptype) - types;
17278
swig_type_info *ty = types_initial[shift];
17279
size_t ldoc = (c - methods[i].ml_doc);
17280
size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
17281
char *ndoc = (char*)malloc(ldoc + lptr + 10);
17282
if (ndoc) {
17283
char *buff = ndoc;
17284
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
17285
if (ptr) {
17286
strncpy(buff, methods[i].ml_doc, ldoc);
17287
buff += ldoc;
17288
strncpy(buff, "swig_ptr: ", 10);
17289
buff += 10;
17290
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
17291
methods[i].ml_doc = ndoc;
17292
}
17293
}
17294
}
17295
}
17296
}
17297
}
17298
17299
#ifdef __cplusplus
17300
}
17301
#endif
17302
17303
/* -----------------------------------------------------------------------------*
17304
* Partial Init method
17305
* -----------------------------------------------------------------------------*/
17306
17307
#ifdef __cplusplus
17308
extern "C"
17309
#endif
17310
SWIGEXPORT void SWIG_init(void) {
17311
PyObject *m, *d;
17312
17313
/* Fix SwigMethods to carry the callback ptrs when needed */
17314
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
17315
17316
m = Py_InitModule((char *) SWIG_name, SwigMethods);
17317
d = PyModule_GetDict(m);
17318
17319
SWIG_InitializeModule(0);
17320
SWIG_InstallConstants(d,swig_const_table);
17321
17322
17323
}
17324
Loggerhead is a web-based interface for Breezy
Version: 2.0.1