← Back to branch summary

~ubuntu-branches/ubuntu/maverick/openturns/maverick

« back to all changes in this revision

Viewing changes to python/src/base_diff_wrap.cpp

  • 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.

Show diffs side-by-side

added added

removed removed

Lines of Context:
python/src/base_diff_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_BoolCollection swig_types[0]
 
2508
#define SWIGTYPE_p_BoolPersistentCollection swig_types[1]
 
2509
#define SWIGTYPE_p_CacheImplementation swig_types[2]
 
2510
#define SWIGTYPE_p_CacheKeyType swig_types[3]
 
2511
#define SWIGTYPE_p_CacheType swig_types[4]
 
2512
#define SWIGTYPE_p_CacheValueType swig_types[5]
 
2513
#define SWIGTYPE_p_Coefficients swig_types[6]
 
2514
#define SWIGTYPE_p_ComparisonOperator swig_types[7]
 
2515
#define SWIGTYPE_p_ConfidenceIntervalCollection swig_types[8]
 
2516
#define SWIGTYPE_p_ConfidenceIntervalPersistentCollection swig_types[9]
 
2517
#define SWIGTYPE_p_CorrelationMatrix swig_types[10]
 
2518
#define SWIGTYPE_p_CovarianceMatrix swig_types[11]
 
2519
#define SWIGTYPE_p_Description swig_types[12]
 
2520
#define SWIGTYPE_p_DirectoryList swig_types[13]
 
2521
#define SWIGTYPE_p_ElementType swig_types[14]
 
2522
#define SWIGTYPE_p_EvaluationImplementation swig_types[15]
 
2523
#define SWIGTYPE_p_FileListType swig_types[16]
 
2524
#define SWIGTYPE_p_FileNotFoundException swig_types[17]
 
2525
#define SWIGTYPE_p_GradientImplementation swig_types[18]
 
2526
#define SWIGTYPE_p_Graph swig_types[19]
 
2527
#define SWIGTYPE_p_HessianImplementation swig_types[20]
 
2528
#define SWIGTYPE_p_IdentityMatrix swig_types[21]
 
2529
#define SWIGTYPE_p_Implementation swig_types[22]
 
2530
#define SWIGTYPE_p_ImplementationAsPersistentObject swig_types[23]
 
2531
#define SWIGTYPE_p_ImplementationElementType swig_types[24]
 
2532
#define SWIGTYPE_p_ImplementationType swig_types[25]
 
2533
#define SWIGTYPE_p_Indices swig_types[26]
 
2534
#define SWIGTYPE_p_InternalException swig_types[27]
 
2535
#define SWIGTYPE_p_InternalFunction swig_types[28]
 
2536
#define SWIGTYPE_p_InternalGradient swig_types[29]
 
2537
#define SWIGTYPE_p_InternalHessian swig_types[30]
 
2538
#define SWIGTYPE_p_InternalType swig_types[31]
 
2539
#define SWIGTYPE_p_Interval swig_types[32]
 
2540
#define SWIGTYPE_p_InvalidArgumentException swig_types[33]
 
2541
#define SWIGTYPE_p_InvalidDimensionException swig_types[34]
 
2542
#define SWIGTYPE_p_KeyType swig_types[35]
 
2543
#define SWIGTYPE_p_LabelMap swig_types[36]
 
2544
#define SWIGTYPE_p_Map swig_types[37]
 
2545
#define SWIGTYPE_p_MapElement swig_types[38]
 
2546
#define SWIGTYPE_p_MappedType swig_types[39]
 
2547
#define SWIGTYPE_p_Matrix swig_types[40]
 
2548
#define SWIGTYPE_p_MersenneTwister swig_types[41]
 
2549
#define SWIGTYPE_p_NoWrapperFileFoundException swig_types[42]
 
2550
#define SWIGTYPE_p_NumericalComplexCollection swig_types[43]
 
2551
#define SWIGTYPE_p_NumericalMathFunction swig_types[44]
 
2552
#define SWIGTYPE_p_NumericalMathFunctionCollection swig_types[45]
 
2553
#define SWIGTYPE_p_NumericalMathFunctionPersistentCollection swig_types[46]
 
2554
#define SWIGTYPE_p_NumericalPoint swig_types[47]
 
2555
#define SWIGTYPE_p_NumericalPointWithDescription swig_types[48]
 
2556
#define SWIGTYPE_p_NumericalSample swig_types[49]
 
2557
#define SWIGTYPE_p_NumericalScalarCollection swig_types[50]
 
2558
#define SWIGTYPE_p_NumericalScalarPersistentCollection swig_types[51]
 
2559
#define SWIGTYPE_p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters swig_types[52]
 
2560
#define SWIGTYPE_p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult swig_types[53]
 
2561
#define SWIGTYPE_p_OT__Base__Stat__RandomGeneratorState swig_types[54]
 
2562
#define SWIGTYPE_p_OpenTURNS__Advocate swig_types[55]
 
2563
#define SWIGTYPE_p_OpenTURNS__Base__Common__ComparisonOperator swig_types[56]
 
2564
#define SWIGTYPE_p_OpenTURNS__Base__Common__ComparisonOperatorImplementation swig_types[57]
 
2565
#define SWIGTYPE_p_OpenTURNS__Base__Common__Equal swig_types[58]
 
2566
#define SWIGTYPE_p_OpenTURNS__Base__Common__Greater swig_types[59]
 
2567
#define SWIGTYPE_p_OpenTURNS__Base__Common__GreaterOrEqual swig_types[60]
 
2568
#define SWIGTYPE_p_OpenTURNS__Base__Common__InterfaceObject swig_types[61]
 
2569
#define SWIGTYPE_p_OpenTURNS__Base__Common__Less swig_types[62]
 
2570
#define SWIGTYPE_p_OpenTURNS__Base__Common__LessOrEqual swig_types[63]
 
2571
#define SWIGTYPE_p_OpenTURNS__Base__Common__Object swig_types[64]
 
2572
#define SWIGTYPE_p_OpenTURNS__Base__Common__PersistentObject swig_types[65]
 
2573
#define SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t swig_types[66]
 
2574
#define SWIGTYPE_p_OpenTURNS__Base__Common__StorageManager swig_types[67]
 
2575
#define SWIGTYPE_p_OpenTURNS__Base__Common__Study swig_types[68]
 
2576
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t swig_types[69]
 
2577
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t swig_types[70]
 
2578
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Common__ComparisonOperatorImplementation_t swig_types[71]
 
2579
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__NumericalMathFunctionImplementation_t swig_types[72]
 
2580
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__UniVariatePolynomialImplementation_t swig_types[73]
 
2581
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__HistoryStrategyImplementation_t swig_types[74]
 
2582
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation_t swig_types[75]
 
2583
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t swig_types[76]
 
2584
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t swig_types[77]
 
2585
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__MatrixImplementation_t swig_types[78]
 
2586
#define SWIGTYPE_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__TensorImplementation_t swig_types[79]
 
2587
#define SWIGTYPE_p_OpenTURNS__Base__Common__XMLStorageManager swig_types[80]
 
2588
#define SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient swig_types[81]
 
2589
#define SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian swig_types[82]
 
2590
#define SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient swig_types[83]
 
2591
#define SWIGTYPE_p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation swig_types[84]
 
2592
#define SWIGTYPE_p_OpenTURNS__Base__Func__ComposedNumericalMathFunction swig_types[85]
 
2593
#define SWIGTYPE_p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation swig_types[86]
 
2594
#define SWIGTYPE_p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation swig_types[87]
 
2595
#define SWIGTYPE_p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation swig_types[88]
 
2596
#define SWIGTYPE_p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation swig_types[89]
 
2597
#define SWIGTYPE_p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation swig_types[90]
 
2598
#define SWIGTYPE_p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation swig_types[91]
 
2599
#define SWIGTYPE_p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation swig_types[92]
 
2600
#define SWIGTYPE_p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation swig_types[93]
 
2601
#define SWIGTYPE_p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation swig_types[94]
 
2602
#define SWIGTYPE_p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation swig_types[95]
 
2603
#define SWIGTYPE_p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation swig_types[96]
 
2604
#define SWIGTYPE_p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation swig_types[97]
 
2605
#define SWIGTYPE_p_OpenTURNS__Base__Func__LinearNumericalMathFunction swig_types[98]
 
2606
#define SWIGTYPE_p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation swig_types[99]
 
2607
#define SWIGTYPE_p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation swig_types[100]
 
2608
#define SWIGTYPE_p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation swig_types[101]
 
2609
#define SWIGTYPE_p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation swig_types[102]
 
2610
#define SWIGTYPE_p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation swig_types[103]
 
2611
#define SWIGTYPE_p_OpenTURNS__Base__Func__NumericalMathFunction swig_types[104]
 
2612
#define SWIGTYPE_p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation swig_types[105]
 
2613
#define SWIGTYPE_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation swig_types[106]
 
2614
#define SWIGTYPE_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation swig_types[107]
 
2615
#define SWIGTYPE_p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation swig_types[108]
 
2616
#define SWIGTYPE_p_OpenTURNS__Base__Func__ProductNumericalMathFunction swig_types[109]
 
2617
#define SWIGTYPE_p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation swig_types[110]
 
2618
#define SWIGTYPE_p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation swig_types[111]
 
2619
#define SWIGTYPE_p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation swig_types[112]
 
2620
#define SWIGTYPE_p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation swig_types[113]
 
2621
#define SWIGTYPE_p_OpenTURNS__Base__Func__UniVariatePolynomial swig_types[114]
 
2622
#define SWIGTYPE_p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation swig_types[115]
 
2623
#define SWIGTYPE_p_OpenTURNS__Base__Func__WrapperData swig_types[116]
 
2624
#define SWIGTYPE_p_OpenTURNS__Base__Func__WrapperDataFile swig_types[117]
 
2625
#define SWIGTYPE_p_OpenTURNS__Base__Func__WrapperDataVariable swig_types[118]
 
2626
#define SWIGTYPE_p_OpenTURNS__Base__Func__WrapperFile swig_types[119]
 
2627
#define SWIGTYPE_p_OpenTURNS__Base__Func__WrapperFrameworkData swig_types[120]
 
2628
#define SWIGTYPE_p_OpenTURNS__Base__Func__WrapperFunctionDescription swig_types[121]
 
2629
#define SWIGTYPE_p_OpenTURNS__Base__Func__WrapperParameter swig_types[122]
 
2630
#define SWIGTYPE_p_OpenTURNS__Base__Stat__Compact swig_types[123]
 
2631
#define SWIGTYPE_p_OpenTURNS__Base__Stat__ConfidenceInterval swig_types[124]
 
2632
#define SWIGTYPE_p_OpenTURNS__Base__Stat__CorrelationMatrix swig_types[125]
 
2633
#define SWIGTYPE_p_OpenTURNS__Base__Stat__CovarianceMatrix swig_types[126]
 
2634
#define SWIGTYPE_p_OpenTURNS__Base__Stat__Full swig_types[127]
 
2635
#define SWIGTYPE_p_OpenTURNS__Base__Stat__HaltonSequence swig_types[128]
 
2636
#define SWIGTYPE_p_OpenTURNS__Base__Stat__HistoryStrategy swig_types[129]
 
2637
#define SWIGTYPE_p_OpenTURNS__Base__Stat__HistoryStrategyImplementation swig_types[130]
 
2638
#define SWIGTYPE_p_OpenTURNS__Base__Stat__Last swig_types[131]
 
2639
#define SWIGTYPE_p_OpenTURNS__Base__Stat__LinearModel swig_types[132]
 
2640
#define SWIGTYPE_p_OpenTURNS__Base__Stat__LowDiscrepancySequence swig_types[133]
 
2641
#define SWIGTYPE_p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation swig_types[134]
 
2642
#define SWIGTYPE_p_OpenTURNS__Base__Stat__Null swig_types[135]
 
2643
#define SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSample swig_types[136]
 
2644
#define SWIGTYPE_p_OpenTURNS__Base__Stat__NumericalSampleImplementation swig_types[137]
 
2645
#define SWIGTYPE_p_OpenTURNS__Base__Stat__SobolSequence swig_types[138]
 
2646
#define SWIGTYPE_p_OpenTURNS__Base__Stat__TestResult swig_types[139]
 
2647
#define SWIGTYPE_p_OpenTURNS__Base__Type__Description swig_types[140]
 
2648
#define SWIGTYPE_p_OpenTURNS__Base__Type__DescriptionImplementation swig_types[141]
 
2649
#define SWIGTYPE_p_OpenTURNS__Base__Type__IdentityMatrix swig_types[142]
 
2650
#define SWIGTYPE_p_OpenTURNS__Base__Type__Indices swig_types[143]
 
2651
#define SWIGTYPE_p_OpenTURNS__Base__Type__Interval swig_types[144]
 
2652
#define SWIGTYPE_p_OpenTURNS__Base__Type__Matrix swig_types[145]
 
2653
#define SWIGTYPE_p_OpenTURNS__Base__Type__MatrixImplementation swig_types[146]
 
2654
#define SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPoint swig_types[147]
 
2655
#define SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPointWithDescription swig_types[148]
 
2656
#define SWIGTYPE_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_t swig_types[149]
 
2657
#define SWIGTYPE_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_t swig_types[150]
 
2658
#define SWIGTYPE_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_t swig_types[151]
 
2659
#define SWIGTYPE_p_OpenTURNS__Base__Type__PersistentCollectionT_double_t swig_types[152]
 
2660
#define SWIGTYPE_p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_t swig_types[153]
 
2661
#define SWIGTYPE_p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_t swig_types[154]
 
2662
#define SWIGTYPE_p_OpenTURNS__Base__Type__SquareMatrix swig_types[155]
 
2663
#define SWIGTYPE_p_OpenTURNS__Base__Type__SymmetricMatrix swig_types[156]
 
2664
#define SWIGTYPE_p_OpenTURNS__Base__Type__SymmetricTensor swig_types[157]
 
2665
#define SWIGTYPE_p_OpenTURNS__Base__Type__Tensor swig_types[158]
 
2666
#define SWIGTYPE_p_OpenTURNS__Base__Type__TensorImplementation swig_types[159]
 
2667
#define SWIGTYPE_p_OpenTURNS__PointInSourceFile swig_types[160]
 
2668
#define SWIGTYPE_p_OutOfBoundException swig_types[161]
 
2669
#define SWIGTYPE_p_PersistentObject swig_types[162]
 
2670
#define SWIGTYPE_p_PolynomialCollection swig_types[163]
 
2671
#define SWIGTYPE_p_PolynomialPersistentCollection swig_types[164]
 
2672
#define SWIGTYPE_p_Severity swig_types[165]
 
2673
#define SWIGTYPE_p_SobolIndiceParameters swig_types[166]
 
2674
#define SWIGTYPE_p_SobolIndiceResult swig_types[167]
 
2675
#define SWIGTYPE_p_SquareMatrix swig_types[168]
 
2676
#define SWIGTYPE_p_State swig_types[169]
 
2677
#define SWIGTYPE_p_StorageManager swig_types[170]
 
2678
#define SWIGTYPE_p_StorageManagerImplementation swig_types[171]
 
2679
#define SWIGTYPE_p_SymmetricTensor swig_types[172]
 
2680
#define SWIGTYPE_p_Tensor swig_types[173]
 
2681
#define SWIGTYPE_p_UnsignedLongCollection swig_types[174]
 
2682
#define SWIGTYPE_p_Value swig_types[175]
 
2683
#define SWIGTYPE_p_ValueType swig_types[176]
 
2684
#define SWIGTYPE_p_VariableListType swig_types[177]
 
2685
#define SWIGTYPE_p_WrapperFileParsingException swig_types[178]
 
2686
#define SWIGTYPE_p_WrapperInternalException swig_types[179]
 
2687
#define SWIGTYPE_p_allocator_type swig_types[180]
 
2688
#define SWIGTYPE_p_bool swig_types[181]
 
2689
#define SWIGTYPE_p_char swig_types[182]
 
2690
#define SWIGTYPE_p_const_iterator swig_types[183]
 
2691
#define SWIGTYPE_p_const_reverse_iterator swig_types[184]
 
2692
#define SWIGTYPE_p_difference_type swig_types[185]
 
2693
#define SWIGTYPE_p_double swig_types[186]
 
2694
#define SWIGTYPE_p_iterator swig_types[187]
 
2695
#define SWIGTYPE_p_key_type swig_types[188]
 
2696
#define SWIGTYPE_p_long swig_types[189]
 
2697
#define SWIGTYPE_p_mapped_type swig_types[190]
 
2698
#define SWIGTYPE_p_pointer_type swig_types[191]
 
2699
#define SWIGTYPE_p_reverse_iterator swig_types[192]
 
2700
#define SWIGTYPE_p_size_type swig_types[193]
 
2701
#define SWIGTYPE_p_std__complexT_double_t swig_types[194]
 
2702
#define SWIGTYPE_p_std__invalid_argument swig_types[195]
 
2703
#define SWIGTYPE_p_std__string swig_types[196]
 
2704
#define SWIGTYPE_p_swig__PySwigIterator swig_types[197]
 
2705
#define SWIGTYPE_p_unsigned_long swig_types[198]
 
2706
#define SWIGTYPE_p_value_type swig_types[199]
 
2707
static swig_type_info *swig_types[201];
 
2708
static swig_module_info swig_module = {swig_types, 200, 0, 0, 0, 0};
 
2709
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 
2710
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
2711
 
 
2712
/* -------- TYPES TABLE (END) -------- */
 
2713
 
 
2714
#if (PY_VERSION_HEX <= 0x02000000)
 
2715
# if !defined(SWIG_PYTHON_CLASSIC)
 
2716
#  error "This python version requires swig to be run with the '-classic' option"
 
2717
# endif
 
2718
#endif
 
2719
 
 
2720
/*-----------------------------------------------
 
2721
              @(target):= _diff.so
 
2722
  ------------------------------------------------*/
 
2723
#define SWIG_init    init_diff
 
2724
 
 
2725
#define SWIG_name    "_diff"
 
2726
 
 
2727
#define SWIGVERSION 0x010336 
 
2728
#define SWIG_VERSION SWIGVERSION
 
2729
 
 
2730
 
 
2731
#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
 
2732
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
 
2733
 
 
2734
 
 
2735
#include <stdexcept>
 
2736
 
 
2737
 
 
2738
namespace swig {
 
2739
  class PyObject_ptr {
 
2740
  protected:
 
2741
    PyObject *_obj;
 
2742
 
 
2743
  public:
 
2744
    PyObject_ptr() :_obj(0)
 
2745
    {
 
2746
    }
 
2747
 
 
2748
    PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
 
2749
    {
 
2750
      Py_XINCREF(_obj);      
 
2751
    }
 
2752
    
 
2753
    PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
 
2754
    {
 
2755
      if (initial_ref) {
 
2756
        Py_XINCREF(_obj);
 
2757
      }
 
2758
    }
 
2759
    
 
2760
    PyObject_ptr & operator=(const PyObject_ptr& item) 
 
2761
    {
 
2762
      Py_XINCREF(item._obj);
 
2763
      Py_XDECREF(_obj);
 
2764
      _obj = item._obj;
 
2765
      return *this;      
 
2766
    }
 
2767
    
 
2768
    ~PyObject_ptr() 
 
2769
    {
 
2770
      Py_XDECREF(_obj);
 
2771
    }
 
2772
    
 
2773
    operator PyObject *() const
 
2774
    {
 
2775
      return _obj;
 
2776
    }
 
2777
 
 
2778
    PyObject *operator->() const
 
2779
    {
 
2780
      return _obj;
 
2781
    }
 
2782
  };
 
2783
}
 
2784
 
 
2785
 
 
2786
namespace swig {
 
2787
  struct PyObject_var : PyObject_ptr {
 
2788
    PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
 
2789
    
 
2790
    PyObject_var & operator = (PyObject* obj)
 
2791
    {
 
2792
      Py_XDECREF(_obj);
 
2793
      _obj = obj;
 
2794
      return *this;      
 
2795
    }
 
2796
  };
 
2797
}
 
2798
 
 
2799
 
 
2800
#include "OTCommon.hxx"
 
2801
#include "OTType.hxx"
 
2802
#include "OTStat.hxx"
 
2803
#include "OTGraph.hxx"
 
2804
#include "OTFunc.hxx"
 
2805
#include "OTDiff.hxx"
 
2806
 
 
2807
 
 
2808
#include <string>
 
2809
 
 
2810
 
 
2811
#include <stdexcept>
 
2812
 
 
2813
 
 
2814
#if defined(__GNUC__)
 
2815
#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
 
2816
#     define SWIG_STD_NOMODERN_STL
 
2817
#  endif
 
2818
#endif
 
2819
 
 
2820
 
 
2821
#include <string>
 
2822
#include <stdexcept>
 
2823
 
 
2824
 
 
2825
#include <utility>
 
2826
 
 
2827
 
 
2828
#include <iostream>
 
2829
 
 
2830
  
 
2831
namespace swig {
 
2832
  struct stop_iteration {
 
2833
  };
 
2834
 
 
2835
  struct PySwigIterator {
 
2836
  private:
 
2837
    PyObject_ptr _seq;
 
2838
 
 
2839
  protected:
 
2840
    PySwigIterator(PyObject *seq) : _seq(seq)
 
2841
    {
 
2842
    }
 
2843
      
 
2844
  public:
 
2845
    virtual ~PySwigIterator() {}
 
2846
 
 
2847
    // Access iterator method, required by Python
 
2848
    virtual PyObject *value() const = 0;
 
2849
 
 
2850
    // Forward iterator method, required by Python
 
2851
    virtual PySwigIterator *incr(size_t n = 1) = 0;
 
2852
    
 
2853
    // Backward iterator method, very common in C++, but not required in Python
 
2854
    virtual PySwigIterator *decr(size_t /*n*/ = 1)
 
2855
    {
 
2856
      throw stop_iteration();
 
2857
    }
 
2858
 
 
2859
    // Random access iterator methods, but not required in Python
 
2860
    virtual ptrdiff_t distance(const PySwigIterator &/*x*/) const
 
2861
    {
 
2862
      throw std::invalid_argument("operation not supported");
 
2863
    }
 
2864
 
 
2865
    virtual bool equal (const PySwigIterator &/*x*/) const
 
2866
    {
 
2867
      throw std::invalid_argument("operation not supported");
 
2868
    }
 
2869
    
 
2870
    // C++ common/needed methods
 
2871
    virtual PySwigIterator *copy() const = 0;
 
2872
 
 
2873
    PyObject *next()     
 
2874
    {
 
2875
      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
 
2876
      PyObject *obj = value();
 
2877
      incr();       
 
2878
      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
 
2879
      return obj;     
 
2880
    }
 
2881
 
 
2882
    PyObject *previous()
 
2883
    {
 
2884
      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
 
2885
      decr();
 
2886
      PyObject *obj = value();
 
2887
      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads       
 
2888
      return obj;
 
2889
    }
 
2890
 
 
2891
    PySwigIterator *advance(ptrdiff_t n)
 
2892
    {
 
2893
      return  (n > 0) ?  incr(n) : decr(-n);
 
2894
    }
 
2895
      
 
2896
    bool operator == (const PySwigIterator& x)  const
 
2897
    {
 
2898
      return equal(x);
 
2899
    }
 
2900
      
 
2901
    bool operator != (const PySwigIterator& x) const
 
2902
    {
 
2903
      return ! operator==(x);
 
2904
    }
 
2905
      
 
2906
    PySwigIterator& operator += (ptrdiff_t n)
 
2907
    {
 
2908
      return *advance(n);
 
2909
    }
 
2910
 
 
2911
    PySwigIterator& operator -= (ptrdiff_t n)
 
2912
    {
 
2913
      return *advance(-n);
 
2914
    }
 
2915
      
 
2916
    PySwigIterator* operator + (ptrdiff_t n) const
 
2917
    {
 
2918
      return copy()->advance(n);
 
2919
    }
 
2920
 
 
2921
    PySwigIterator* operator - (ptrdiff_t n) const
 
2922
    {
 
2923
      return copy()->advance(-n);
 
2924
    }
 
2925
      
 
2926
    ptrdiff_t operator - (const PySwigIterator& x) const
 
2927
    {
 
2928
      return x.distance(*this);
 
2929
    }
 
2930
      
 
2931
    static swig_type_info* descriptor() {
 
2932
      static int init = 0;
 
2933
      static swig_type_info* desc = 0;
 
2934
      if (!init) {
 
2935
        desc = SWIG_TypeQuery("swig::PySwigIterator *");
 
2936
        init = 1;
 
2937
      } 
 
2938
      return desc;
 
2939
    }    
 
2940
  };
 
2941
}
 
2942
 
 
2943
 
 
2944
SWIGINTERN int
 
2945
SWIG_AsVal_double (PyObject *obj, double *val)
 
2946
{
 
2947
  int res = SWIG_TypeError;
 
2948
  if (PyFloat_Check(obj)) {
 
2949
    if (val) *val = PyFloat_AsDouble(obj);
 
2950
    return SWIG_OK;
 
2951
  } else if (PyInt_Check(obj)) {
 
2952
    if (val) *val = PyInt_AsLong(obj);
 
2953
    return SWIG_OK;
 
2954
  } else if (PyLong_Check(obj)) {
 
2955
    double v = PyLong_AsDouble(obj);
 
2956
    if (!PyErr_Occurred()) {
 
2957
      if (val) *val = v;
 
2958
      return SWIG_OK;
 
2959
    } else {
 
2960
      PyErr_Clear();
 
2961
    }
 
2962
  }
 
2963
#ifdef SWIG_PYTHON_CAST_MODE
 
2964
  {
 
2965
    int dispatch = 0;
 
2966
    double d = PyFloat_AsDouble(obj);
 
2967
    if (!PyErr_Occurred()) {
 
2968
      if (val) *val = d;
 
2969
      return SWIG_AddCast(SWIG_OK);
 
2970
    } else {
 
2971
      PyErr_Clear();
 
2972
    }
 
2973
    if (!dispatch) {
 
2974
      long v = PyLong_AsLong(obj);
 
2975
      if (!PyErr_Occurred()) {
 
2976
        if (val) *val = v;
 
2977
        return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
 
2978
      } else {
 
2979
        PyErr_Clear();
 
2980
      }
 
2981
    }
 
2982
  }
 
2983
#endif
 
2984
  return res;
 
2985
}
 
2986
 
 
2987
 
 
2988
#include <float.h>
 
2989
 
 
2990
 
 
2991
#include <math.h>
 
2992
 
 
2993
 
 
2994
SWIGINTERNINLINE int
 
2995
SWIG_CanCastAsInteger(double *d, double min, double max) {
 
2996
  double x = *d;
 
2997
  if ((min <= x && x <= max)) {
 
2998
   double fx = floor(x);
 
2999
   double cx = ceil(x);
 
3000
   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
 
3001
   if ((errno == EDOM) || (errno == ERANGE)) {
 
3002
     errno = 0;
 
3003
   } else {
 
3004
     double summ, reps, diff;
 
3005
     if (rd < x) {
 
3006
       diff = x - rd;
 
3007
     } else if (rd > x) {
 
3008
       diff = rd - x;
 
3009
     } else {
 
3010
       return 1;
 
3011
     }
 
3012
     summ = rd + x;
 
3013
     reps = diff/summ;
 
3014
     if (reps < 8*DBL_EPSILON) {
 
3015
       *d = rd;
 
3016
       return 1;
 
3017
     }
 
3018
   }
 
3019
  }
 
3020
  return 0;
 
3021
}
 
3022
 
 
3023
 
 
3024
SWIGINTERN int
 
3025
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
 
3026
{
 
3027
  if (PyInt_Check(obj)) {
 
3028
    long v = PyInt_AsLong(obj);
 
3029
    if (v >= 0) {
 
3030
      if (val) *val = v;
 
3031
      return SWIG_OK;
 
3032
    } else {
 
3033
      return SWIG_OverflowError;
 
3034
    }
 
3035
  } else if (PyLong_Check(obj)) {
 
3036
    unsigned long v = PyLong_AsUnsignedLong(obj);
 
3037
    if (!PyErr_Occurred()) {
 
3038
      if (val) *val = v;
 
3039
      return SWIG_OK;
 
3040
    } else {
 
3041
      PyErr_Clear();
 
3042
    }
 
3043
  }
 
3044
#ifdef SWIG_PYTHON_CAST_MODE
 
3045
  {
 
3046
    int dispatch = 0;
 
3047
    unsigned long v = PyLong_AsUnsignedLong(obj);
 
3048
    if (!PyErr_Occurred()) {
 
3049
      if (val) *val = v;
 
3050
      return SWIG_AddCast(SWIG_OK);
 
3051
    } else {
 
3052
      PyErr_Clear();
 
3053
    }
 
3054
    if (!dispatch) {
 
3055
      double d;
 
3056
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
 
3057
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
 
3058
        if (val) *val = (unsigned long)(d);
 
3059
        return res;
 
3060
      }
 
3061
    }
 
3062
  }
 
3063
#endif
 
3064
  return SWIG_TypeError;
 
3065
}
 
3066
 
 
3067
 
 
3068
SWIGINTERNINLINE int
 
3069
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
 
3070
{
 
3071
  unsigned long v;
 
3072
  int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
 
3073
  if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
 
3074
  return res;
 
3075
}
 
3076
 
 
3077
 
 
3078
  #define SWIG_From_long   PyInt_FromLong 
 
3079
 
 
3080
 
 
3081
SWIGINTERNINLINE PyObject *
 
3082
SWIG_From_ptrdiff_t  (ptrdiff_t value)
 
3083
{    
 
3084
  return SWIG_From_long  (static_cast< long >(value));
 
3085
}
 
3086
 
 
3087
 
 
3088
SWIGINTERNINLINE PyObject*
 
3089
  SWIG_From_bool  (bool value)
 
3090
{
 
3091
  return PyBool_FromLong(value ? 1 : 0);
 
3092
}
 
3093
 
 
3094
 
 
3095
SWIGINTERN int
 
3096
SWIG_AsVal_long (PyObject *obj, long* val)
 
3097
{
 
3098
  if (PyInt_Check(obj)) {
 
3099
    if (val) *val = PyInt_AsLong(obj);
 
3100
    return SWIG_OK;
 
3101
  } else if (PyLong_Check(obj)) {
 
3102
    long v = PyLong_AsLong(obj);
 
3103
    if (!PyErr_Occurred()) {
 
3104
      if (val) *val = v;
 
3105
      return SWIG_OK;
 
3106
    } else {
 
3107
      PyErr_Clear();
 
3108
    }
 
3109
  }
 
3110
#ifdef SWIG_PYTHON_CAST_MODE
 
3111
  {
 
3112
    int dispatch = 0;
 
3113
    long v = PyInt_AsLong(obj);
 
3114
    if (!PyErr_Occurred()) {
 
3115
      if (val) *val = v;
 
3116
      return SWIG_AddCast(SWIG_OK);
 
3117
    } else {
 
3118
      PyErr_Clear();
 
3119
    }
 
3120
    if (!dispatch) {
 
3121
      double d;
 
3122
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
 
3123
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
 
3124
        if (val) *val = (long)(d);
 
3125
        return res;
 
3126
      }
 
3127
    }
 
3128
  }
 
3129
#endif
 
3130
  return SWIG_TypeError;
 
3131
}
 
3132
 
 
3133
 
 
3134
SWIGINTERNINLINE int
 
3135
SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
 
3136
{
 
3137
  long v;
 
3138
  int res = SWIG_AsVal_long (obj, val ? &v : 0);
 
3139
  if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
 
3140
  return res;
 
3141
}
 
3142
 
 
3143
 
 
3144
#include <stdexcept>
 
3145
 
 
3146
 
 
3147
#include <algorithm>
 
3148
 
 
3149
 
 
3150
#include <map>
 
3151
#include <algorithm>
 
3152
#include <stdexcept>
 
3153
 
 
3154
 
 
3155
#include <complex> 
 
3156
 
 
3157
 
 
3158
#include "OT.hxx"
 
3159
#include "PythonWrappingFunctions.hxx"
 
3160
 
 
3161
 
 
3162
namespace OpenTURNS { 
 
3163
 
 
3164
 
 
3165
 
 
3166
  template <>
 
3167
  struct traitsPythonType<OpenTURNS::Base::Type::NumericalPoint>
 
3168
  {
 
3169
    typedef _PySequence_ Type;
 
3170
  };
 
3171
 
 
3172
  template <>
 
3173
  inline
 
3174
  OpenTURNS::Base::Type::NumericalPoint
 
3175
  convert<_PySequence_,OpenTURNS::Base::Type::NumericalPoint>(PyObject * pyObj)
 
3176
  {
 
3177
    OpenTURNS::Base::Common::Pointer<OpenTURNS::Base::Type::Collection<OpenTURNS::NumericalScalar> > ptr = buildCollectionFromPySequence<OpenTURNS::NumericalScalar>( pyObj );
 
3178
    return OpenTURNS::Base::Type::NumericalPoint( *ptr );
 
3179
  }
 
3180
 
 
3181
 
 
3182
 
 
3183
  template <>
 
3184
  struct traitsPythonType<OpenTURNS::Base::Type::Indices>
 
3185
  {
 
3186
    typedef _PySequence_ Type;
 
3187
  };
 
3188
 
 
3189
  template <>
 
3190
  inline
 
3191
  OpenTURNS::Base::Type::Indices
 
3192
  convert<_PySequence_,OpenTURNS::Base::Type::Indices>(PyObject * pyObj)
 
3193
  {
 
3194
    OpenTURNS::Base::Common::Pointer<OpenTURNS::Base::Type::Collection<OpenTURNS::UnsignedLong> > ptr = buildCollectionFromPySequence<OpenTURNS::UnsignedLong>( pyObj );
 
3195
    return OpenTURNS::Base::Type::Indices( ptr->begin(), ptr->end() );
 
3196
  }
 
3197
 
 
3198
 
 
3199
 
 
3200
 
 
3201
  template <>
 
3202
  struct traitsPythonType<OpenTURNS::Base::Func::WrapperDataFile>
 
3203
  {
 
3204
    typedef _PySequence_ Type;
 
3205
  };
 
3206
 
 
3207
  template <>
 
3208
  inline
 
3209
  OpenTURNS::Base::Func::WrapperDataFile
 
3210
  convert<_PySequence_,OpenTURNS::Base::Func::WrapperDataFile>(PyObject * pyObj)
 
3211
  {
 
3212
    return OpenTURNS::Base::Func::WrapperDataFile();
 
3213
  }
 
3214
 
 
3215
 
 
3216
 
 
3217
  template <>
 
3218
  struct traitsPythonType<OpenTURNS::Base::Func::WrapperDataVariable>
 
3219
  {
 
3220
    typedef _PySequence_ Type;
 
3221
  };
 
3222
 
 
3223
  template <>
 
3224
  inline
 
3225
  OpenTURNS::Base::Func::WrapperDataVariable
 
3226
  convert<_PySequence_,OpenTURNS::Base::Func::WrapperDataVariable>(PyObject * pyObj)
 
3227
  {
 
3228
    return OpenTURNS::Base::Func::WrapperDataVariable();
 
3229
  }
 
3230
 
 
3231
 
 
3232
} /* namespace OpenTURNS */
 
3233
 
 
3234
 
 
3235
 
 
3236
#include "Exception.hxx"
 
3237
 
 
3238
 
 
3239
#include <vector>
 
3240
 
 
3241
 
 
3242
namespace swig {  
 
3243
  template <class Type>
 
3244
  struct noconst_traits {
 
3245
    typedef Type noconst_type;
 
3246
  };
 
3247
 
 
3248
  template <class Type>
 
3249
  struct noconst_traits<const Type> {
 
3250
    typedef Type noconst_type;
 
3251
  };
 
3252
 
 
3253
  /*
 
3254
    type categories
 
3255
  */
 
3256
  struct pointer_category { };  
 
3257
  struct value_category { };
 
3258
 
 
3259
  /*
 
3260
    General traits that provides type_name and type_info
 
3261
  */
 
3262
  template <class Type> struct traits { };
 
3263
 
 
3264
  template <class Type>
 
3265
  inline const char* type_name() {
 
3266
    return traits<typename noconst_traits<Type >::noconst_type >::type_name();
 
3267
  }
 
3268
 
 
3269
  template <class Type> 
 
3270
  struct traits_info {
 
3271
    static swig_type_info *type_query(std::string name) {
 
3272
      name += " *";
 
3273
      return SWIG_TypeQuery(name.c_str());
 
3274
    }    
 
3275
    static swig_type_info *type_info() {
 
3276
      static swig_type_info *info = type_query(type_name<Type>());
 
3277
      return info;
 
3278
    }
 
3279
  };
 
3280
 
 
3281
  template <class Type>
 
3282
  inline swig_type_info *type_info() {
 
3283
    return traits_info<Type>::type_info();
 
3284
  }
 
3285
 
 
3286
  /*
 
3287
    Partial specialization for pointers
 
3288
  */
 
3289
  template <class Type> struct traits <Type *> {
 
3290
    typedef pointer_category category;
 
3291
    static std::string make_ptr_name(const char* name) {
 
3292
      std::string ptrname = name;
 
3293
      ptrname += " *";
 
3294
      return ptrname;
 
3295
    }    
 
3296
    static const char* type_name() {
 
3297
      static std::string name = make_ptr_name(swig::type_name<Type>());
 
3298
      return name.c_str();
 
3299
    }
 
3300
  };
 
3301
 
 
3302
  template <class Type, class Category> 
 
3303
  struct traits_as { };
 
3304
 
 
3305
  template <class Type, class Category> 
 
3306
  struct traits_check { };
 
3307
 
 
3308
}
 
3309
 
 
3310
 
 
3311
namespace swig {  
 
3312
  /*
 
3313
    Traits that provides the from method
 
3314
  */
 
3315
  template <class Type> struct traits_from_ptr {
 
3316
    static PyObject *from(Type *val, int owner = 0) {
 
3317
      return SWIG_NewPointerObj(val, type_info<Type>(), owner);
 
3318
    }
 
3319
  };
 
3320
 
 
3321
  template <class Type> struct traits_from {
 
3322
    static PyObject *from(const Type& val) {
 
3323
      return traits_from_ptr<Type>::from(new Type(val), 1);
 
3324
    }
 
3325
  };
 
3326
 
 
3327
  template <class Type> struct traits_from<Type *> {
 
3328
    static PyObject *from(Type* val) {
 
3329
      return traits_from_ptr<Type>::from(val, 0);
 
3330
    }
 
3331
  };
 
3332
 
 
3333
  template <class Type> struct traits_from<const Type *> {
 
3334
    static PyObject *from(const Type* val) {
 
3335
      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
 
3336
    }
 
3337
  };
 
3338
 
 
3339
 
 
3340
  template <class Type>
 
3341
  inline PyObject *from(const Type& val) {
 
3342
    return traits_from<Type>::from(val);
 
3343
  }
 
3344
 
 
3345
  template <class Type>
 
3346
  inline PyObject *from_ptr(Type* val, int owner) {
 
3347
    return traits_from_ptr<Type>::from(val, owner);
 
3348
  }
 
3349
 
 
3350
  /*
 
3351
    Traits that provides the asval/as/check method
 
3352
  */
 
3353
  template <class Type>
 
3354
  struct traits_asptr {   
 
3355
    static int asptr(PyObject *obj, Type **val) {
 
3356
      Type *p;
 
3357
      int res = (SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0) == SWIG_OK) ? SWIG_OLDOBJ : 0;
 
3358
      if (SWIG_IsOK(res)) {
 
3359
        if (val) *val = p;
 
3360
      }
 
3361
      return res;
 
3362
    }
 
3363
  }; 
 
3364
 
 
3365
  template <class Type>
 
3366
  inline int asptr(PyObject *obj, Type **vptr) {
 
3367
    return traits_asptr<Type>::asptr(obj, vptr);
 
3368
  }
 
3369
 
 
3370
  template <class Type> 
 
3371
  struct traits_asval {
 
3372
    static int asval(PyObject *obj, Type *val) {
 
3373
      if (val) {
 
3374
        Type *p = 0;
 
3375
        int res = traits_asptr<Type>::asptr(obj, &p);
 
3376
        if (!SWIG_IsOK(res)) return res;        
 
3377
        if (p) {
 
3378
          typedef typename noconst_traits<Type>::noconst_type noconst_type;
 
3379
          *(const_cast<noconst_type*>(val)) = *p;
 
3380
          if (SWIG_IsNewObj(res)){
 
3381
            delete p;
 
3382
            res = SWIG_DelNewMask(res);
 
3383
          }
 
3384
          return res;
 
3385
        } else {
 
3386
          return SWIG_ERROR;
 
3387
        }
 
3388
      } else {
 
3389
        return traits_asptr<Type>::asptr(obj, (Type **)(0));
 
3390
      }
 
3391
    }
 
3392
  };
 
3393
 
 
3394
  template <class Type> struct traits_asval<Type*> {
 
3395
    static int asval(PyObject *obj, Type **val) {
 
3396
      if (val) {
 
3397
        typedef typename noconst_traits<Type>::noconst_type noconst_type;
 
3398
        noconst_type *p = 0;
 
3399
        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
 
3400
        if (SWIG_IsOK(res)) {
 
3401
          *(const_cast<noconst_type**>(val)) = p;
 
3402
        }
 
3403
        return res;
 
3404
      } else {
 
3405
        return traits_asptr<Type>::asptr(obj, (Type **)(0));
 
3406
      }
 
3407
    }
 
3408
  };
 
3409
  
 
3410
  template <class Type>
 
3411
  inline int asval(PyObject *obj, Type *val) {
 
3412
    return traits_asval<Type>::asval(obj, val);
 
3413
  }
 
3414
 
 
3415
  template <class Type> 
 
3416
  struct traits_as<Type, value_category> {
 
3417
    static Type as(PyObject *obj, bool throw_error) {
 
3418
      Type v;
 
3419
      int res = asval(obj, &v);
 
3420
      if (!obj || !SWIG_IsOK(res)) {
 
3421
        if (!PyErr_Occurred()) {
 
3422
          ::SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
 
3423
        }
 
3424
        if (throw_error) throw std::invalid_argument("bad type");
 
3425
      }
 
3426
      return v;
 
3427
    }
 
3428
  };
 
3429
 
 
3430
  template <class Type> 
 
3431
  struct traits_as<Type, pointer_category> {
 
3432
    static Type as(PyObject *obj, bool throw_error) {
 
3433
      Type *v = 0;      
 
3434
      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
 
3435
      if (SWIG_IsOK(res) && v) {
 
3436
        if (SWIG_IsNewObj(res)) {
 
3437
          Type r(*v);
 
3438
          delete v;
 
3439
          return r;
 
3440
        } else {
 
3441
          return *v;
 
3442
        }
 
3443
      } else {
 
3444
        // Uninitialized return value, no Type() constructor required.
 
3445
        static Type *v_def = (Type*) malloc(sizeof(Type));
 
3446
        if (!PyErr_Occurred()) {
 
3447
          SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
 
3448
        }
 
3449
        if (throw_error) throw std::invalid_argument("bad type");
 
3450
        memset(v_def,0,sizeof(Type));
 
3451
        return *v_def;
 
3452
      }
 
3453
    }
 
3454
  };
 
3455
 
 
3456
  template <class Type> 
 
3457
  struct traits_as<Type*, pointer_category> {
 
3458
    static Type* as(PyObject *obj, bool throw_error) {
 
3459
      Type *v = 0;      
 
3460
      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
 
3461
      if (SWIG_IsOK(res)) {
 
3462
        return v;
 
3463
      } else {
 
3464
        if (!PyErr_Occurred()) {
 
3465
          SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
 
3466
        }
 
3467
        if (throw_error) throw std::invalid_argument("bad type");
 
3468
        return 0;
 
3469
      }
 
3470
    }
 
3471
  };
 
3472
    
 
3473
  template <class Type>
 
3474
  inline Type as(PyObject *obj, bool te = false) {
 
3475
    return traits_as<Type, typename traits<Type>::category>::as(obj, te);
 
3476
  }
 
3477
 
 
3478
  template <class Type> 
 
3479
  struct traits_check<Type, value_category> {
 
3480
    static bool check(PyObject *obj) {
 
3481
      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
 
3482
      return SWIG_IsOK(res) ? true : false;
 
3483
    }
 
3484
  };
 
3485
 
 
3486
  template <class Type> 
 
3487
  struct traits_check<Type, pointer_category> {
 
3488
    static bool check(PyObject *obj) {
 
3489
      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
 
3490
      return SWIG_IsOK(res) ? true : false;
 
3491
    }
 
3492
  };
 
3493
 
 
3494
  template <class Type>
 
3495
  inline bool check(PyObject *obj) {
 
3496
    return traits_check<Type, typename traits<Type>::category>::check(obj);
 
3497
  }
 
3498
}
 
3499
 
 
3500
 
 
3501
#include <functional>
 
3502
 
 
3503
namespace std {
 
3504
  template <>
 
3505
  struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
 
3506
  {
 
3507
    bool
 
3508
    operator()(PyObject * v, PyObject *w) const
 
3509
    { 
 
3510
      bool res;
 
3511
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
 
3512
      res = PyObject_Compare(v, w) < 0;
 
3513
      SWIG_PYTHON_THREAD_END_BLOCK;
 
3514
      return res;
 
3515
    }
 
3516
  };
 
3517
 
 
3518
  template <>
 
3519
  struct less <swig::PyObject_ptr>: public binary_function<swig::PyObject_ptr, swig::PyObject_ptr, bool>
 
3520
  {
 
3521
    bool
 
3522
    operator()(const swig::PyObject_ptr& v, const swig::PyObject_ptr& w) const
 
3523
    {
 
3524
      return std::less<PyObject *>()(v, w);
 
3525
    }
 
3526
  };
 
3527
 
 
3528
  template <>
 
3529
  struct less <swig::PyObject_var>: public binary_function<swig::PyObject_var, swig::PyObject_var, bool>
 
3530
  {
 
3531
    bool
 
3532
    operator()(const swig::PyObject_var& v, const swig::PyObject_var& w) const
 
3533
    {
 
3534
      return std::less<PyObject *>()(v, w);
 
3535
    }
 
3536
  };
 
3537
 
 
3538
}
 
3539
 
 
3540
namespace swig {
 
3541
  template <> struct traits<PyObject *> {
 
3542
    typedef value_category category;
 
3543
    static const char* type_name() { return "PyObject *"; }
 
3544
  };  
 
3545
 
 
3546
  template <>  struct traits_asval<PyObject * > {   
 
3547
    typedef PyObject * value_type;
 
3548
    static int asval(PyObject *obj, value_type *val) {
 
3549
      if (val) *val = obj;
 
3550
      return SWIG_OK;
 
3551
    }
 
3552
  };
 
3553
 
 
3554
  template <> 
 
3555
  struct traits_check<PyObject *, value_category> {
 
3556
    static bool check(PyObject *) {
 
3557
      return true;
 
3558
    }
 
3559
  };
 
3560
 
 
3561
  template <>  struct traits_from<PyObject *> {
 
3562
    typedef PyObject * value_type;
 
3563
    static PyObject *from(const value_type& val) {
 
3564
      Py_XINCREF(val);
 
3565
      return val;
 
3566
    }
 
3567
  };
 
3568
  
 
3569
}
 
3570
 
 
3571
namespace swig {
 
3572
  inline size_t
 
3573
  check_index(ptrdiff_t i, size_t size, bool insert = false) {
 
3574
    if ( i < 0 ) {
 
3575
      if ((size_t) (-i) <= size)
 
3576
        return (size_t) (i + size);
 
3577
    } else if ( (size_t) i < size ) {
 
3578
      return (size_t) i;
 
3579
    } else if (insert && ((size_t) i == size)) {
 
3580
      return size;
 
3581
    }
 
3582
    
 
3583
    throw std::out_of_range("index out of range");
 
3584
  }
 
3585
 
 
3586
  inline size_t
 
3587
  slice_index(ptrdiff_t i, size_t size) {
 
3588
    if ( i < 0 ) {
 
3589
      if ((size_t) (-i) <= size) {
 
3590
        return (size_t) (i + size);
 
3591
      } else {
 
3592
        throw std::out_of_range("index out of range");
 
3593
      }
 
3594
    } else {
 
3595
      return ( (size_t) i < size ) ? ((size_t) i) : size;
 
3596
    }
 
3597
  }
 
3598
 
 
3599
  template <class Sequence, class Difference>
 
3600
  inline typename Sequence::iterator
 
3601
  getpos(Sequence* self, Difference i)  {
 
3602
    typename Sequence::iterator pos = self->begin();
 
3603
    std::advance(pos, check_index(i,self->size()));
 
3604
    return pos;
 
3605
  }
 
3606
 
 
3607
  template <class Sequence, class Difference>
 
3608
  inline typename Sequence::const_iterator
 
3609
  cgetpos(const Sequence* self, Difference i)  {
 
3610
    typename Sequence::const_iterator pos = self->begin();
 
3611
    std::advance(pos, check_index(i,self->size()));
 
3612
    return pos;
 
3613
  }
 
3614
 
 
3615
  template <class Sequence, class Difference>
 
3616
  inline Sequence*
 
3617
  getslice(const Sequence* self, Difference i, Difference j) {
 
3618
    typename Sequence::size_type size = self->size();
 
3619
    typename Sequence::size_type ii = swig::check_index(i, size);
 
3620
    typename Sequence::size_type jj = swig::slice_index(j, size);
 
3621
 
 
3622
    if (jj > ii) {
 
3623
      typename Sequence::const_iterator vb = self->begin();
 
3624
      typename Sequence::const_iterator ve = self->begin();
 
3625
      std::advance(vb,ii);
 
3626
      std::advance(ve,jj);
 
3627
      return new Sequence(vb, ve);
 
3628
    } else {
 
3629
      return new Sequence();
 
3630
    }
 
3631
  }
 
3632
 
 
3633
  template <class Sequence, class Difference, class InputSeq>
 
3634
  inline void
 
3635
  setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
 
3636
    typename Sequence::size_type size = self->size();
 
3637
    typename Sequence::size_type ii = swig::check_index(i, size, true);
 
3638
    typename Sequence::size_type jj = swig::slice_index(j, size);
 
3639
    if (jj < ii) jj = ii;
 
3640
    size_t ssize = jj - ii;
 
3641
    if (ssize <= v.size()) {
 
3642
      typename Sequence::iterator sb = self->begin();
 
3643
      typename InputSeq::const_iterator vmid = v.begin();
 
3644
      std::advance(sb,ii);
 
3645
      std::advance(vmid, jj - ii);
 
3646
      self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
 
3647
    } else {
 
3648
      typename Sequence::iterator sb = self->begin();
 
3649
      typename Sequence::iterator se = self->begin();
 
3650
      std::advance(sb,ii);
 
3651
      std::advance(se,jj);
 
3652
      self->erase(sb,se);
 
3653
      self->insert(sb, v.begin(), v.end());
 
3654
    }
 
3655
  }
 
3656
 
 
3657
  template <class Sequence, class Difference>
 
3658
  inline void
 
3659
  delslice(Sequence* self, Difference i, Difference j) {
 
3660
    typename Sequence::size_type size = self->size();
 
3661
    typename Sequence::size_type ii = swig::check_index(i, size, true);
 
3662
    typename Sequence::size_type jj = swig::slice_index(j, size);
 
3663
    if (jj > ii) {
 
3664
      typename Sequence::iterator sb = self->begin();
 
3665
      typename Sequence::iterator se = self->begin();
 
3666
      std::advance(sb,ii);
 
3667
      std::advance(se,jj);
 
3668
      self->erase(sb,se);
 
3669
    }
 
3670
  }
 
3671
}
 
3672
 
 
3673
 
 
3674
#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
 
3675
#  if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
 
3676
#    define SWIG_STD_NOITERATOR_TRAITS_STL
 
3677
#  endif
 
3678
#endif
 
3679
 
 
3680
#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
 
3681
#include <iterator>
 
3682
#else
 
3683
namespace std {
 
3684
  template <class Iterator>
 
3685
  struct iterator_traits {
 
3686
    typedef ptrdiff_t difference_type;
 
3687
    typedef typename Iterator::value_type value_type;
 
3688
  };
 
3689
 
 
3690
  template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
 
3691
  struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
 
3692
    typedef Distance difference_type;
 
3693
    typedef T value_type;
 
3694
  };
 
3695
 
 
3696
  template <class T>
 
3697
  struct iterator_traits<T*> {
 
3698
    typedef T value_type;
 
3699
    typedef ptrdiff_t difference_type;
 
3700
  };
 
3701
 
 
3702
  template<typename _InputIterator>
 
3703
  inline typename iterator_traits<_InputIterator>::difference_type
 
3704
  distance(_InputIterator __first, _InputIterator __last)
 
3705
  {
 
3706
    typename iterator_traits<_InputIterator>::difference_type __n = 0;
 
3707
    while (__first != __last) {
 
3708
      ++__first; ++__n;
 
3709
    }
 
3710
    return __n;
 
3711
  }
 
3712
}
 
3713
#endif
 
3714
 
 
3715
 
 
3716
namespace swig {
 
3717
  template<typename OutIterator>
 
3718
  class PySwigIterator_T :  public PySwigIterator
 
3719
  {
 
3720
  public:
 
3721
    typedef OutIterator out_iterator;
 
3722
    typedef typename std::iterator_traits<out_iterator>::value_type value_type;    
 
3723
    typedef PySwigIterator_T<out_iterator> self_type;
 
3724
 
 
3725
    PySwigIterator_T(out_iterator curr, PyObject *seq)
 
3726
      : PySwigIterator(seq), current(curr)
 
3727
    {
 
3728
    }
 
3729
 
 
3730
    const out_iterator& get_current() const
 
3731
    {
 
3732
      return current;
 
3733
    }
 
3734
 
 
3735
    
 
3736
    bool equal (const PySwigIterator &iter) const
 
3737
    {
 
3738
      const self_type *iters = dynamic_cast<const self_type *>(&iter);
 
3739
      if (iters) {
 
3740
        return (current == iters->get_current());
 
3741
      } else {
 
3742
        throw std::invalid_argument("bad iterator type");
 
3743
      }
 
3744
    }
 
3745
    
 
3746
    ptrdiff_t distance(const PySwigIterator &iter) const
 
3747
    {
 
3748
      const self_type *iters = dynamic_cast<const self_type *>(&iter);
 
3749
      if (iters) {
 
3750
        return std::distance(current, iters->get_current());
 
3751
      } else {
 
3752
        throw std::invalid_argument("bad iterator type");
 
3753
      }
 
3754
    }    
 
3755
    
 
3756
  protected:
 
3757
    out_iterator current;
 
3758
  };
 
3759
  
 
3760
  template <class ValueType>
 
3761
  struct from_oper 
 
3762
  {
 
3763
    typedef const ValueType& argument_type;
 
3764
    typedef PyObject *result_type;
 
3765
    result_type operator()(argument_type v) const
 
3766
    {
 
3767
      return swig::from(v);
 
3768
    }
 
3769
  };
 
3770
 
 
3771
  template<typename OutIterator, 
 
3772
           typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
 
3773
           typename FromOper = from_oper<ValueType> >
 
3774
  class PySwigIteratorOpen_T :  public PySwigIterator_T<OutIterator>
 
3775
  {
 
3776
  public:
 
3777
    FromOper from;
 
3778
    typedef OutIterator out_iterator;
 
3779
    typedef ValueType value_type;
 
3780
    typedef PySwigIterator_T<out_iterator>  base;
 
3781
    typedef PySwigIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
 
3782
    
 
3783
    PySwigIteratorOpen_T(out_iterator curr, PyObject *seq)
 
3784
      : PySwigIterator_T<OutIterator>(curr, seq)
 
3785
    {
 
3786
    }
 
3787
    
 
3788
    PyObject *value() const {
 
3789
      return from(static_cast<const value_type&>(*(base::current)));
 
3790
    }
 
3791
    
 
3792
    PySwigIterator *copy() const
 
3793
    {
 
3794
      return new self_type(*this);
 
3795
    }
 
3796
 
 
3797
    PySwigIterator *incr(size_t n = 1)
 
3798
    {
 
3799
      while (n--) {
 
3800
        ++base::current;
 
3801
      }
 
3802
      return this;
 
3803
    }
 
3804
 
 
3805
    PySwigIterator *decr(size_t n = 1)
 
3806
    {
 
3807
      while (n--) {
 
3808
        --base::current;
 
3809
      }
 
3810
      return this;
 
3811
    }
 
3812
  };
 
3813
 
 
3814
  template<typename OutIterator, 
 
3815
           typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
 
3816
           typename FromOper = from_oper<ValueType> >
 
3817
  class PySwigIteratorClosed_T :  public PySwigIterator_T<OutIterator>
 
3818
  {
 
3819
  public:
 
3820
    FromOper from;
 
3821
    typedef OutIterator out_iterator;
 
3822
    typedef ValueType value_type;
 
3823
    typedef PySwigIterator_T<out_iterator>  base;    
 
3824
    typedef PySwigIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
 
3825
    
 
3826
    PySwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
 
3827
      : PySwigIterator_T<OutIterator>(curr, seq), begin(first), end(last)
 
3828
    {
 
3829
    }
 
3830
    
 
3831
    PyObject *value() const {
 
3832
      if (base::current == end) {
 
3833
        throw stop_iteration();
 
3834
      } else {
 
3835
        return from(static_cast<const value_type&>(*(base::current)));
 
3836
      }
 
3837
    }
 
3838
    
 
3839
    PySwigIterator *copy() const
 
3840
    {
 
3841
      return new self_type(*this);
 
3842
    }
 
3843
 
 
3844
    PySwigIterator *incr(size_t n = 1)
 
3845
    {
 
3846
      while (n--) {
 
3847
        if (base::current == end) {
 
3848
          throw stop_iteration();
 
3849
        } else {
 
3850
          ++base::current;
 
3851
        }
 
3852
      }
 
3853
      return this;
 
3854
    }
 
3855
 
 
3856
    PySwigIterator *decr(size_t n = 1)
 
3857
    {
 
3858
      while (n--) {
 
3859
        if (base::current == begin) {
 
3860
          throw stop_iteration();
 
3861
        } else {
 
3862
          --base::current;
 
3863
        }
 
3864
      }
 
3865
      return this;
 
3866
    }
 
3867
 
 
3868
  private:
 
3869
    out_iterator begin;
 
3870
    out_iterator end;
 
3871
  };
 
3872
 
 
3873
  template<typename OutIter>
 
3874
  inline PySwigIterator*
 
3875
  make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
 
3876
  {
 
3877
    return new PySwigIteratorClosed_T<OutIter>(current, begin, end, seq);
 
3878
  }
 
3879
 
 
3880
  template<typename OutIter>
 
3881
  inline PySwigIterator*
 
3882
  make_output_iterator(const OutIter& current, PyObject *seq = 0)
 
3883
  {
 
3884
    return new PySwigIteratorOpen_T<OutIter>(current, seq);
 
3885
  }
 
3886
}
 
3887
 
 
3888
 
 
3889
namespace swig
 
3890
{
 
3891
  template <class T>
 
3892
  struct PySequence_Ref
 
3893
  {
 
3894
    PySequence_Ref(PyObject* seq, int index)
 
3895
      : _seq(seq), _index(index)
 
3896
    {
 
3897
    }
 
3898
    
 
3899
    operator T () const
 
3900
    {
 
3901
      swig::PyObject_var item = PySequence_GetItem(_seq, _index);
 
3902
      try {
 
3903
        return swig::as<T>(item, true);
 
3904
      } catch (std::exception& e) {
 
3905
        char msg[1024];
 
3906
        sprintf(msg, "in sequence element %d ", _index);
 
3907
        if (!PyErr_Occurred()) {
 
3908
          ::SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
 
3909
        }
 
3910
        SWIG_Python_AddErrorMsg(msg);
 
3911
        SWIG_Python_AddErrorMsg(e.what());
 
3912
        throw;
 
3913
      }
 
3914
    }
 
3915
 
 
3916
    PySequence_Ref& operator=(const T& v)
 
3917
    {
 
3918
      PySequence_SetItem(_seq, _index, swig::from<T>(v));
 
3919
      return *this;
 
3920
    }
 
3921
 
 
3922
  private:
 
3923
    PyObject* _seq;
 
3924
    int _index;
 
3925
  };
 
3926
 
 
3927
  template <class T>
 
3928
  struct PySequence_ArrowProxy
 
3929
  {
 
3930
    PySequence_ArrowProxy(const T& x): m_value(x) {}
 
3931
    const T* operator->() const { return &m_value; }
 
3932
    operator const T*() const { return &m_value; }
 
3933
    T m_value;
 
3934
  };
 
3935
 
 
3936
  template <class T, class Reference >
 
3937
  struct PySequence_InputIterator
 
3938
  {
 
3939
    typedef PySequence_InputIterator<T, Reference > self;
 
3940
 
 
3941
    typedef std::random_access_iterator_tag iterator_category;
 
3942
    typedef Reference reference;
 
3943
    typedef T value_type;
 
3944
    typedef T* pointer;
 
3945
    typedef int difference_type;
 
3946
 
 
3947
    PySequence_InputIterator()
 
3948
    {
 
3949
    }
 
3950
 
 
3951
    PySequence_InputIterator(PyObject* seq, int index)
 
3952
      : _seq(seq), _index(index)
 
3953
    {
 
3954
    }
 
3955
 
 
3956
    reference operator*() const
 
3957
    {
 
3958
      return reference(_seq, _index);
 
3959
    }
 
3960
 
 
3961
    PySequence_ArrowProxy<T>
 
3962
    operator->() const {
 
3963
      return PySequence_ArrowProxy<T>(operator*());
 
3964
    }
 
3965
 
 
3966
    bool operator==(const self& ri) const
 
3967
    {
 
3968
      return (_index == ri._index) && (_seq == ri._seq);
 
3969
    }
 
3970
 
 
3971
    bool operator!=(const self& ri) const
 
3972
    {
 
3973
      return !(operator==(ri));
 
3974
    }
 
3975
 
 
3976
    self& operator ++ ()
 
3977
    {
 
3978
      ++_index;
 
3979
      return *this;
 
3980
    }
 
3981
 
 
3982
    self& operator -- ()
 
3983
    {
 
3984
      --_index;
 
3985
      return *this;
 
3986
    }
 
3987
 
 
3988
    self& operator += (difference_type n)
 
3989
    {
 
3990
      _index += n;
 
3991
      return *this;
 
3992
    }
 
3993
 
 
3994
    self operator +(difference_type n) const
 
3995
    {
 
3996
      return self(_seq, _index + n);
 
3997
    }
 
3998
 
 
3999
    self& operator -= (difference_type n)
 
4000
    {
 
4001
      _index -= n;
 
4002
      return *this;
 
4003
    }
 
4004
 
 
4005
    self operator -(difference_type n) const
 
4006
    {
 
4007
      return self(_seq, _index - n);
 
4008
    }
 
4009
 
 
4010
    difference_type operator - (const self& ri) const
 
4011
    {
 
4012
      return _index - ri._index;
 
4013
    }
 
4014
 
 
4015
    bool operator < (const self& ri) const
 
4016
    {
 
4017
      return _index < ri._index;
 
4018
    }
 
4019
 
 
4020
    reference
 
4021
    operator[](difference_type n) const
 
4022
    {
 
4023
      return reference(_seq, _index + n);
 
4024
    }
 
4025
 
 
4026
  private:
 
4027
    PyObject* _seq;
 
4028
    difference_type _index;
 
4029
  };
 
4030
 
 
4031
  template <class T>
 
4032
  struct PySequence_Cont
 
4033
  {
 
4034
    typedef PySequence_Ref<T> reference;
 
4035
    typedef const PySequence_Ref<T> const_reference;
 
4036
    typedef T value_type;
 
4037
    typedef T* pointer;
 
4038
    typedef int difference_type;
 
4039
    typedef int size_type;
 
4040
    typedef const pointer const_pointer;
 
4041
    typedef PySequence_InputIterator<T, reference> iterator;
 
4042
    typedef PySequence_InputIterator<T, const_reference> const_iterator;
 
4043
 
 
4044
    PySequence_Cont(PyObject* seq) : _seq(0)
 
4045
    {
 
4046
      if (!PySequence_Check(seq)) {
 
4047
        throw std::invalid_argument("a sequence is expected");
 
4048
      }
 
4049
      _seq = seq;
 
4050
      Py_INCREF(_seq);
 
4051
    }
 
4052
 
 
4053
    ~PySequence_Cont()
 
4054
    {
 
4055
      Py_XDECREF(_seq);
 
4056
    }
 
4057
 
 
4058
    size_type size() const
 
4059
    {
 
4060
      return static_cast<size_type>(PySequence_Size(_seq));
 
4061
    }
 
4062
 
 
4063
    bool empty() const
 
4064
    {
 
4065
      return size() == 0;
 
4066
    }
 
4067
 
 
4068
    iterator begin()
 
4069
    {
 
4070
      return iterator(_seq, 0);
 
4071
    }
 
4072
 
 
4073
    const_iterator begin() const
 
4074
    {
 
4075
      return const_iterator(_seq, 0);
 
4076
    }
 
4077
 
 
4078
    iterator end()
 
4079
    {
 
4080
      return iterator(_seq, size());
 
4081
    }
 
4082
 
 
4083
    const_iterator end() const
 
4084
    {
 
4085
      return const_iterator(_seq, size());
 
4086
    }
 
4087
 
 
4088
    reference operator[](difference_type n)
 
4089
    {
 
4090
      return reference(_seq, n);
 
4091
    }
 
4092
 
 
4093
    const_reference operator[](difference_type n)  const
 
4094
    {
 
4095
      return const_reference(_seq, n);
 
4096
    }
 
4097
 
 
4098
    bool check(bool set_err = true) const
 
4099
    {
 
4100
      int s = size();
 
4101
      for (int i = 0; i < s; ++i) {
 
4102
        swig::PyObject_var item = PySequence_GetItem(_seq, i);
 
4103
        if (!swig::check<value_type>(item)) {
 
4104
          if (set_err) {
 
4105
            char msg[1024];
 
4106
            sprintf(msg, "in sequence element %d", i);
 
4107
            SWIG_Error(SWIG_RuntimeError, msg);
 
4108
          }
 
4109
          return false;
 
4110
        }
 
4111
      }
 
4112
      return true;
 
4113
    }
 
4114
 
 
4115
  private:
 
4116
    PyObject* _seq;
 
4117
  };
 
4118
 
 
4119
}
 
4120
 
 
4121
 
 
4122
#include "CenteredFiniteDifferenceGradient.hxx"
 
4123
 
 
4124
 
 
4125
SWIGINTERN swig_type_info*
 
4126
SWIG_pchar_descriptor(void)
 
4127
{
 
4128
  static int init = 0;
 
4129
  static swig_type_info* info = 0;
 
4130
  if (!init) {
 
4131
    info = SWIG_TypeQuery("_p_char");
 
4132
    init = 1;
 
4133
  }
 
4134
  return info;
 
4135
}
 
4136
 
 
4137
 
 
4138
SWIGINTERNINLINE PyObject *
 
4139
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
 
4140
{
 
4141
  if (carray) {
 
4142
    if (size > INT_MAX) {
 
4143
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
 
4144
      return pchar_descriptor ? 
 
4145
        SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
 
4146
    } else {
 
4147
      return PyString_FromStringAndSize(carray, static_cast< int >(size));
 
4148
    }
 
4149
  } else {
 
4150
    return SWIG_Py_Void();
 
4151
  }
 
4152
}
 
4153
 
 
4154
 
 
4155
SWIGINTERNINLINE PyObject *
 
4156
SWIG_From_std_string  (const std::string& s)
 
4157
{
 
4158
  if (s.size()) {
 
4159
    return SWIG_FromCharPtrAndSize(s.data(), s.size());
 
4160
  } else {
 
4161
    return SWIG_FromCharPtrAndSize(s.c_str(), 0);
 
4162
  }
 
4163
}
 
4164
 
 
4165
 
 
4166
  #define SWIG_From_double   PyFloat_FromDouble 
 
4167
 
 
4168
 
 
4169
SWIGINTERNINLINE PyObject* 
 
4170
SWIG_From_unsigned_SS_long  (unsigned long value)
 
4171
{
 
4172
  return (value > LONG_MAX) ?
 
4173
    PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value)); 
 
4174
}
 
4175
 
 
4176
SWIGINTERN OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *new_OpenTURNS_Base_Diff_CenteredFiniteDifferenceGradient__SWIG_3(OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const &other){ return new OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient(other); }
 
4177
 
 
4178
#include "CenteredFiniteDifferenceHessian.hxx"
 
4179
 
 
4180
SWIGINTERN OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *new_OpenTURNS_Base_Diff_CenteredFiniteDifferenceHessian__SWIG_3(OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const &other){ return new OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian(other); }
 
4181
 
 
4182
#include "NonCenteredFiniteDifferenceGradient.hxx"
 
4183
 
 
4184
SWIGINTERN OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *new_OpenTURNS_Base_Diff_NonCenteredFiniteDifferenceGradient__SWIG_3(OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const &other){ return new OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient(other); }
 
4185
#ifdef __cplusplus
 
4186
extern "C" {
 
4187
#endif
 
4188
SWIGINTERN PyObject *_wrap_delete_PySwigIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4189
  PyObject *resultobj = 0;
 
4190
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4191
  void *argp1 = 0 ;
 
4192
  int res1 = 0 ;
 
4193
  PyObject * obj0 = 0 ;
 
4194
  
 
4195
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PySwigIterator",&obj0)) SWIG_fail;
 
4196
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
 
4197
  if (!SWIG_IsOK(res1)) {
 
4198
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySwigIterator" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
 
4199
  }
 
4200
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4201
  delete arg1;
 
4202
  resultobj = SWIG_Py_Void();
 
4203
  return resultobj;
 
4204
fail:
 
4205
  return NULL;
 
4206
}
 
4207
 
 
4208
 
 
4209
SWIGINTERN PyObject *_wrap_PySwigIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4210
  PyObject *resultobj = 0;
 
4211
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4212
  void *argp1 = 0 ;
 
4213
  int res1 = 0 ;
 
4214
  PyObject * obj0 = 0 ;
 
4215
  PyObject *result = 0 ;
 
4216
  
 
4217
  if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_value",&obj0)) SWIG_fail;
 
4218
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4219
  if (!SWIG_IsOK(res1)) {
 
4220
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_value" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
 
4221
  }
 
4222
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4223
  try {
 
4224
    result = (PyObject *)((swig::PySwigIterator const *)arg1)->value();
 
4225
  }
 
4226
  catch(swig::stop_iteration &_e) {
 
4227
    {
 
4228
      (void)_e;
 
4229
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
 
4230
      SWIG_fail;
 
4231
    }
 
4232
  }
 
4233
  
 
4234
  resultobj = result;
 
4235
  return resultobj;
 
4236
fail:
 
4237
  return NULL;
 
4238
}
 
4239
 
 
4240
 
 
4241
SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4242
  PyObject *resultobj = 0;
 
4243
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4244
  size_t arg2 ;
 
4245
  void *argp1 = 0 ;
 
4246
  int res1 = 0 ;
 
4247
  size_t val2 ;
 
4248
  int ecode2 = 0 ;
 
4249
  PyObject * obj0 = 0 ;
 
4250
  PyObject * obj1 = 0 ;
 
4251
  swig::PySwigIterator *result = 0 ;
 
4252
  
 
4253
  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_incr",&obj0,&obj1)) SWIG_fail;
 
4254
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4255
  if (!SWIG_IsOK(res1)) {
 
4256
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
 
4257
  }
 
4258
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4259
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
 
4260
  if (!SWIG_IsOK(ecode2)) {
 
4261
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
 
4262
  } 
 
4263
  arg2 = static_cast< size_t >(val2);
 
4264
  try {
 
4265
    result = (swig::PySwigIterator *)(arg1)->incr(arg2);
 
4266
  }
 
4267
  catch(swig::stop_iteration &_e) {
 
4268
    {
 
4269
      (void)_e;
 
4270
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
 
4271
      SWIG_fail;
 
4272
    }
 
4273
  }
 
4274
  
 
4275
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4276
  return resultobj;
 
4277
fail:
 
4278
  return NULL;
 
4279
}
 
4280
 
 
4281
 
 
4282
SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4283
  PyObject *resultobj = 0;
 
4284
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4285
  void *argp1 = 0 ;
 
4286
  int res1 = 0 ;
 
4287
  PyObject * obj0 = 0 ;
 
4288
  swig::PySwigIterator *result = 0 ;
 
4289
  
 
4290
  if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_incr",&obj0)) SWIG_fail;
 
4291
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4292
  if (!SWIG_IsOK(res1)) {
 
4293
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
 
4294
  }
 
4295
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4296
  try {
 
4297
    result = (swig::PySwigIterator *)(arg1)->incr();
 
4298
  }
 
4299
  catch(swig::stop_iteration &_e) {
 
4300
    {
 
4301
      (void)_e;
 
4302
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
 
4303
      SWIG_fail;
 
4304
    }
 
4305
  }
 
4306
  
 
4307
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4308
  return resultobj;
 
4309
fail:
 
4310
  return NULL;
 
4311
}
 
4312
 
 
4313
 
 
4314
SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
 
4315
  int argc;
 
4316
  PyObject *argv[3];
 
4317
  int ii;
 
4318
  
 
4319
  if (!PyTuple_Check(args)) SWIG_fail;
 
4320
  argc = (int)PyObject_Length(args);
 
4321
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
 
4322
    argv[ii] = PyTuple_GET_ITEM(args,ii);
 
4323
  }
 
4324
  if (argc == 1) {
 
4325
    int _v;
 
4326
    void *vptr = 0;
 
4327
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
 
4328
    _v = SWIG_CheckState(res);
 
4329
    if (_v) {
 
4330
      return _wrap_PySwigIterator_incr__SWIG_1(self, args);
 
4331
    }
 
4332
  }
 
4333
  if (argc == 2) {
 
4334
    int _v;
 
4335
    void *vptr = 0;
 
4336
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
 
4337
    _v = SWIG_CheckState(res);
 
4338
    if (_v) {
 
4339
      {
 
4340
        int res = SWIG_AsVal_size_t(argv[1], NULL);
 
4341
        _v = SWIG_CheckState(res);
 
4342
      }
 
4343
      if (_v) {
 
4344
        return _wrap_PySwigIterator_incr__SWIG_0(self, args);
 
4345
      }
 
4346
    }
 
4347
  }
 
4348
  
 
4349
fail:
 
4350
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_incr'.\n"
 
4351
    "  Possible C/C++ prototypes are:\n"
 
4352
    "    incr(swig::PySwigIterator *,size_t)\n"
 
4353
    "    incr(swig::PySwigIterator *)\n");
 
4354
  return NULL;
 
4355
}
 
4356
 
 
4357
 
 
4358
SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4359
  PyObject *resultobj = 0;
 
4360
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4361
  size_t arg2 ;
 
4362
  void *argp1 = 0 ;
 
4363
  int res1 = 0 ;
 
4364
  size_t val2 ;
 
4365
  int ecode2 = 0 ;
 
4366
  PyObject * obj0 = 0 ;
 
4367
  PyObject * obj1 = 0 ;
 
4368
  swig::PySwigIterator *result = 0 ;
 
4369
  
 
4370
  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_decr",&obj0,&obj1)) SWIG_fail;
 
4371
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4372
  if (!SWIG_IsOK(res1)) {
 
4373
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
 
4374
  }
 
4375
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4376
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
 
4377
  if (!SWIG_IsOK(ecode2)) {
 
4378
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_decr" "', argument " "2"" of type '" "size_t""'");
 
4379
  } 
 
4380
  arg2 = static_cast< size_t >(val2);
 
4381
  try {
 
4382
    result = (swig::PySwigIterator *)(arg1)->decr(arg2);
 
4383
  }
 
4384
  catch(swig::stop_iteration &_e) {
 
4385
    {
 
4386
      (void)_e;
 
4387
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
 
4388
      SWIG_fail;
 
4389
    }
 
4390
  }
 
4391
  
 
4392
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4393
  return resultobj;
 
4394
fail:
 
4395
  return NULL;
 
4396
}
 
4397
 
 
4398
 
 
4399
SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4400
  PyObject *resultobj = 0;
 
4401
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4402
  void *argp1 = 0 ;
 
4403
  int res1 = 0 ;
 
4404
  PyObject * obj0 = 0 ;
 
4405
  swig::PySwigIterator *result = 0 ;
 
4406
  
 
4407
  if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_decr",&obj0)) SWIG_fail;
 
4408
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4409
  if (!SWIG_IsOK(res1)) {
 
4410
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
 
4411
  }
 
4412
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4413
  try {
 
4414
    result = (swig::PySwigIterator *)(arg1)->decr();
 
4415
  }
 
4416
  catch(swig::stop_iteration &_e) {
 
4417
    {
 
4418
      (void)_e;
 
4419
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
 
4420
      SWIG_fail;
 
4421
    }
 
4422
  }
 
4423
  
 
4424
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4425
  return resultobj;
 
4426
fail:
 
4427
  return NULL;
 
4428
}
 
4429
 
 
4430
 
 
4431
SWIGINTERN PyObject *_wrap_PySwigIterator_decr(PyObject *self, PyObject *args) {
 
4432
  int argc;
 
4433
  PyObject *argv[3];
 
4434
  int ii;
 
4435
  
 
4436
  if (!PyTuple_Check(args)) SWIG_fail;
 
4437
  argc = (int)PyObject_Length(args);
 
4438
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
 
4439
    argv[ii] = PyTuple_GET_ITEM(args,ii);
 
4440
  }
 
4441
  if (argc == 1) {
 
4442
    int _v;
 
4443
    void *vptr = 0;
 
4444
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
 
4445
    _v = SWIG_CheckState(res);
 
4446
    if (_v) {
 
4447
      return _wrap_PySwigIterator_decr__SWIG_1(self, args);
 
4448
    }
 
4449
  }
 
4450
  if (argc == 2) {
 
4451
    int _v;
 
4452
    void *vptr = 0;
 
4453
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
 
4454
    _v = SWIG_CheckState(res);
 
4455
    if (_v) {
 
4456
      {
 
4457
        int res = SWIG_AsVal_size_t(argv[1], NULL);
 
4458
        _v = SWIG_CheckState(res);
 
4459
      }
 
4460
      if (_v) {
 
4461
        return _wrap_PySwigIterator_decr__SWIG_0(self, args);
 
4462
      }
 
4463
    }
 
4464
  }
 
4465
  
 
4466
fail:
 
4467
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_decr'.\n"
 
4468
    "  Possible C/C++ prototypes are:\n"
 
4469
    "    decr(swig::PySwigIterator *,size_t)\n"
 
4470
    "    decr(swig::PySwigIterator *)\n");
 
4471
  return NULL;
 
4472
}
 
4473
 
 
4474
 
 
4475
SWIGINTERN PyObject *_wrap_PySwigIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4476
  PyObject *resultobj = 0;
 
4477
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4478
  swig::PySwigIterator *arg2 = 0 ;
 
4479
  void *argp1 = 0 ;
 
4480
  int res1 = 0 ;
 
4481
  void *argp2 = 0 ;
 
4482
  int res2 = 0 ;
 
4483
  PyObject * obj0 = 0 ;
 
4484
  PyObject * obj1 = 0 ;
 
4485
  ptrdiff_t result;
 
4486
  
 
4487
  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_distance",&obj0,&obj1)) SWIG_fail;
 
4488
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4489
  if (!SWIG_IsOK(res1)) {
 
4490
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_distance" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
 
4491
  }
 
4492
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4493
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
 
4494
  if (!SWIG_IsOK(res2)) {
 
4495
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
 
4496
  }
 
4497
  if (!argp2) {
 
4498
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
 
4499
  }
 
4500
  arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
 
4501
  try {
 
4502
    result = ((swig::PySwigIterator const *)arg1)->distance((swig::PySwigIterator const &)*arg2);
 
4503
  }
 
4504
  catch(std::invalid_argument &_e) {
 
4505
    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;
 
4506
  }
 
4507
  
 
4508
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
 
4509
  return resultobj;
 
4510
fail:
 
4511
  return NULL;
 
4512
}
 
4513
 
 
4514
 
 
4515
SWIGINTERN PyObject *_wrap_PySwigIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4516
  PyObject *resultobj = 0;
 
4517
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4518
  swig::PySwigIterator *arg2 = 0 ;
 
4519
  void *argp1 = 0 ;
 
4520
  int res1 = 0 ;
 
4521
  void *argp2 = 0 ;
 
4522
  int res2 = 0 ;
 
4523
  PyObject * obj0 = 0 ;
 
4524
  PyObject * obj1 = 0 ;
 
4525
  bool result;
 
4526
  
 
4527
  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_equal",&obj0,&obj1)) SWIG_fail;
 
4528
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4529
  if (!SWIG_IsOK(res1)) {
 
4530
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_equal" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
 
4531
  }
 
4532
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4533
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
 
4534
  if (!SWIG_IsOK(res2)) {
 
4535
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
 
4536
  }
 
4537
  if (!argp2) {
 
4538
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
 
4539
  }
 
4540
  arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
 
4541
  try {
 
4542
    result = (bool)((swig::PySwigIterator const *)arg1)->equal((swig::PySwigIterator const &)*arg2);
 
4543
  }
 
4544
  catch(std::invalid_argument &_e) {
 
4545
    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;
 
4546
  }
 
4547
  
 
4548
  resultobj = SWIG_From_bool(static_cast< bool >(result));
 
4549
  return resultobj;
 
4550
fail:
 
4551
  return NULL;
 
4552
}
 
4553
 
 
4554
 
 
4555
SWIGINTERN PyObject *_wrap_PySwigIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4556
  PyObject *resultobj = 0;
 
4557
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4558
  void *argp1 = 0 ;
 
4559
  int res1 = 0 ;
 
4560
  PyObject * obj0 = 0 ;
 
4561
  swig::PySwigIterator *result = 0 ;
 
4562
  
 
4563
  if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_copy",&obj0)) SWIG_fail;
 
4564
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4565
  if (!SWIG_IsOK(res1)) {
 
4566
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_copy" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
 
4567
  }
 
4568
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4569
  result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->copy();
 
4570
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
 
4571
  return resultobj;
 
4572
fail:
 
4573
  return NULL;
 
4574
}
 
4575
 
 
4576
 
 
4577
SWIGINTERN PyObject *_wrap_PySwigIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4578
  PyObject *resultobj = 0;
 
4579
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4580
  void *argp1 = 0 ;
 
4581
  int res1 = 0 ;
 
4582
  PyObject * obj0 = 0 ;
 
4583
  PyObject *result = 0 ;
 
4584
  
 
4585
  if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_next",&obj0)) SWIG_fail;
 
4586
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4587
  if (!SWIG_IsOK(res1)) {
 
4588
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_next" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
 
4589
  }
 
4590
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4591
  try {
 
4592
    result = (PyObject *)(arg1)->next();
 
4593
  }
 
4594
  catch(swig::stop_iteration &_e) {
 
4595
    {
 
4596
      (void)_e;
 
4597
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
 
4598
      SWIG_fail;
 
4599
    }
 
4600
  }
 
4601
  
 
4602
  resultobj = result;
 
4603
  return resultobj;
 
4604
fail:
 
4605
  return NULL;
 
4606
}
 
4607
 
 
4608
 
 
4609
SWIGINTERN PyObject *_wrap_PySwigIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4610
  PyObject *resultobj = 0;
 
4611
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4612
  void *argp1 = 0 ;
 
4613
  int res1 = 0 ;
 
4614
  PyObject * obj0 = 0 ;
 
4615
  PyObject *result = 0 ;
 
4616
  
 
4617
  if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_previous",&obj0)) SWIG_fail;
 
4618
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4619
  if (!SWIG_IsOK(res1)) {
 
4620
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_previous" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
 
4621
  }
 
4622
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4623
  try {
 
4624
    result = (PyObject *)(arg1)->previous();
 
4625
  }
 
4626
  catch(swig::stop_iteration &_e) {
 
4627
    {
 
4628
      (void)_e;
 
4629
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
 
4630
      SWIG_fail;
 
4631
    }
 
4632
  }
 
4633
  
 
4634
  resultobj = result;
 
4635
  return resultobj;
 
4636
fail:
 
4637
  return NULL;
 
4638
}
 
4639
 
 
4640
 
 
4641
SWIGINTERN PyObject *_wrap_PySwigIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4642
  PyObject *resultobj = 0;
 
4643
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4644
  ptrdiff_t arg2 ;
 
4645
  void *argp1 = 0 ;
 
4646
  int res1 = 0 ;
 
4647
  ptrdiff_t val2 ;
 
4648
  int ecode2 = 0 ;
 
4649
  PyObject * obj0 = 0 ;
 
4650
  PyObject * obj1 = 0 ;
 
4651
  swig::PySwigIterator *result = 0 ;
 
4652
  
 
4653
  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_advance",&obj0,&obj1)) SWIG_fail;
 
4654
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4655
  if (!SWIG_IsOK(res1)) {
 
4656
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_advance" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
 
4657
  }
 
4658
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4659
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
 
4660
  if (!SWIG_IsOK(ecode2)) {
 
4661
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
 
4662
  } 
 
4663
  arg2 = static_cast< ptrdiff_t >(val2);
 
4664
  try {
 
4665
    result = (swig::PySwigIterator *)(arg1)->advance(arg2);
 
4666
  }
 
4667
  catch(swig::stop_iteration &_e) {
 
4668
    {
 
4669
      (void)_e;
 
4670
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
 
4671
      SWIG_fail;
 
4672
    }
 
4673
  }
 
4674
  
 
4675
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4676
  return resultobj;
 
4677
fail:
 
4678
  return NULL;
 
4679
}
 
4680
 
 
4681
 
 
4682
SWIGINTERN PyObject *_wrap_PySwigIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4683
  PyObject *resultobj = 0;
 
4684
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4685
  swig::PySwigIterator *arg2 = 0 ;
 
4686
  void *argp1 = 0 ;
 
4687
  int res1 = 0 ;
 
4688
  void *argp2 = 0 ;
 
4689
  int res2 = 0 ;
 
4690
  PyObject * obj0 = 0 ;
 
4691
  PyObject * obj1 = 0 ;
 
4692
  bool result;
 
4693
  
 
4694
  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___eq__",&obj0,&obj1)) SWIG_fail;
 
4695
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4696
  if (!SWIG_IsOK(res1)) {
 
4697
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___eq__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
 
4698
  }
 
4699
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4700
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
 
4701
  if (!SWIG_IsOK(res2)) {
 
4702
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
 
4703
  }
 
4704
  if (!argp2) {
 
4705
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
 
4706
  }
 
4707
  arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
 
4708
  result = (bool)((swig::PySwigIterator const *)arg1)->operator ==((swig::PySwigIterator const &)*arg2);
 
4709
  resultobj = SWIG_From_bool(static_cast< bool >(result));
 
4710
  return resultobj;
 
4711
fail:
 
4712
  return NULL;
 
4713
}
 
4714
 
 
4715
 
 
4716
SWIGINTERN PyObject *_wrap_PySwigIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4717
  PyObject *resultobj = 0;
 
4718
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4719
  swig::PySwigIterator *arg2 = 0 ;
 
4720
  void *argp1 = 0 ;
 
4721
  int res1 = 0 ;
 
4722
  void *argp2 = 0 ;
 
4723
  int res2 = 0 ;
 
4724
  PyObject * obj0 = 0 ;
 
4725
  PyObject * obj1 = 0 ;
 
4726
  bool result;
 
4727
  
 
4728
  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___ne__",&obj0,&obj1)) SWIG_fail;
 
4729
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4730
  if (!SWIG_IsOK(res1)) {
 
4731
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___ne__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
 
4732
  }
 
4733
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4734
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
 
4735
  if (!SWIG_IsOK(res2)) {
 
4736
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
 
4737
  }
 
4738
  if (!argp2) {
 
4739
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
 
4740
  }
 
4741
  arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
 
4742
  result = (bool)((swig::PySwigIterator const *)arg1)->operator !=((swig::PySwigIterator const &)*arg2);
 
4743
  resultobj = SWIG_From_bool(static_cast< bool >(result));
 
4744
  return resultobj;
 
4745
fail:
 
4746
  return NULL;
 
4747
}
 
4748
 
 
4749
 
 
4750
SWIGINTERN PyObject *_wrap_PySwigIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4751
  PyObject *resultobj = 0;
 
4752
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4753
  ptrdiff_t arg2 ;
 
4754
  void *argp1 = 0 ;
 
4755
  int res1 = 0 ;
 
4756
  ptrdiff_t val2 ;
 
4757
  int ecode2 = 0 ;
 
4758
  PyObject * obj0 = 0 ;
 
4759
  PyObject * obj1 = 0 ;
 
4760
  swig::PySwigIterator *result = 0 ;
 
4761
  
 
4762
  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___iadd__",&obj0,&obj1)) SWIG_fail;
 
4763
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
 
4764
  if (!SWIG_IsOK(res1)) {
 
4765
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___iadd__" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
 
4766
  }
 
4767
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4768
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
 
4769
  if (!SWIG_IsOK(ecode2)) {
 
4770
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
 
4771
  } 
 
4772
  arg2 = static_cast< ptrdiff_t >(val2);
 
4773
  try {
 
4774
    {
 
4775
      swig::PySwigIterator &_result_ref = (arg1)->operator +=(arg2);
 
4776
      result = (swig::PySwigIterator *) &_result_ref;
 
4777
    }
 
4778
  }
 
4779
  catch(swig::stop_iteration &_e) {
 
4780
    {
 
4781
      (void)_e;
 
4782
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
 
4783
      SWIG_fail;
 
4784
    }
 
4785
  }
 
4786
  
 
4787
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
 
4788
  return resultobj;
 
4789
fail:
 
4790
  return NULL;
 
4791
}
 
4792
 
 
4793
 
 
4794
SWIGINTERN PyObject *_wrap_PySwigIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4795
  PyObject *resultobj = 0;
 
4796
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4797
  ptrdiff_t arg2 ;
 
4798
  void *argp1 = 0 ;
 
4799
  int res1 = 0 ;
 
4800
  ptrdiff_t val2 ;
 
4801
  int ecode2 = 0 ;
 
4802
  PyObject * obj0 = 0 ;
 
4803
  PyObject * obj1 = 0 ;
 
4804
  swig::PySwigIterator *result = 0 ;
 
4805
  
 
4806
  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___isub__",&obj0,&obj1)) SWIG_fail;
 
4807
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
 
4808
  if (!SWIG_IsOK(res1)) {
 
4809
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___isub__" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
 
4810
  }
 
4811
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4812
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
 
4813
  if (!SWIG_IsOK(ecode2)) {
 
4814
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
 
4815
  } 
 
4816
  arg2 = static_cast< ptrdiff_t >(val2);
 
4817
  try {
 
4818
    {
 
4819
      swig::PySwigIterator &_result_ref = (arg1)->operator -=(arg2);
 
4820
      result = (swig::PySwigIterator *) &_result_ref;
 
4821
    }
 
4822
  }
 
4823
  catch(swig::stop_iteration &_e) {
 
4824
    {
 
4825
      (void)_e;
 
4826
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
 
4827
      SWIG_fail;
 
4828
    }
 
4829
  }
 
4830
  
 
4831
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
 
4832
  return resultobj;
 
4833
fail:
 
4834
  return NULL;
 
4835
}
 
4836
 
 
4837
 
 
4838
SWIGINTERN PyObject *_wrap_PySwigIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4839
  PyObject *resultobj = 0;
 
4840
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4841
  ptrdiff_t arg2 ;
 
4842
  void *argp1 = 0 ;
 
4843
  int res1 = 0 ;
 
4844
  ptrdiff_t val2 ;
 
4845
  int ecode2 = 0 ;
 
4846
  PyObject * obj0 = 0 ;
 
4847
  PyObject * obj1 = 0 ;
 
4848
  swig::PySwigIterator *result = 0 ;
 
4849
  
 
4850
  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___add__",&obj0,&obj1)) SWIG_fail;
 
4851
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4852
  if (!SWIG_IsOK(res1)) {
 
4853
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___add__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
 
4854
  }
 
4855
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4856
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
 
4857
  if (!SWIG_IsOK(ecode2)) {
 
4858
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
 
4859
  } 
 
4860
  arg2 = static_cast< ptrdiff_t >(val2);
 
4861
  try {
 
4862
    result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator +(arg2);
 
4863
  }
 
4864
  catch(swig::stop_iteration &_e) {
 
4865
    {
 
4866
      (void)_e;
 
4867
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
 
4868
      SWIG_fail;
 
4869
    }
 
4870
  }
 
4871
  
 
4872
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
 
4873
  return resultobj;
 
4874
fail:
 
4875
  return NULL;
 
4876
}
 
4877
 
 
4878
 
 
4879
SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4880
  PyObject *resultobj = 0;
 
4881
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4882
  ptrdiff_t arg2 ;
 
4883
  void *argp1 = 0 ;
 
4884
  int res1 = 0 ;
 
4885
  ptrdiff_t val2 ;
 
4886
  int ecode2 = 0 ;
 
4887
  PyObject * obj0 = 0 ;
 
4888
  PyObject * obj1 = 0 ;
 
4889
  swig::PySwigIterator *result = 0 ;
 
4890
  
 
4891
  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
 
4892
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4893
  if (!SWIG_IsOK(res1)) {
 
4894
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
 
4895
  }
 
4896
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4897
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
 
4898
  if (!SWIG_IsOK(ecode2)) {
 
4899
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
 
4900
  } 
 
4901
  arg2 = static_cast< ptrdiff_t >(val2);
 
4902
  try {
 
4903
    result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator -(arg2);
 
4904
  }
 
4905
  catch(swig::stop_iteration &_e) {
 
4906
    {
 
4907
      (void)_e;
 
4908
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
 
4909
      SWIG_fail;
 
4910
    }
 
4911
  }
 
4912
  
 
4913
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
 
4914
  return resultobj;
 
4915
fail:
 
4916
  return NULL;
 
4917
}
 
4918
 
 
4919
 
 
4920
SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4921
  PyObject *resultobj = 0;
 
4922
  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
 
4923
  swig::PySwigIterator *arg2 = 0 ;
 
4924
  void *argp1 = 0 ;
 
4925
  int res1 = 0 ;
 
4926
  void *argp2 = 0 ;
 
4927
  int res2 = 0 ;
 
4928
  PyObject * obj0 = 0 ;
 
4929
  PyObject * obj1 = 0 ;
 
4930
  ptrdiff_t result;
 
4931
  
 
4932
  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
 
4933
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
 
4934
  if (!SWIG_IsOK(res1)) {
 
4935
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
 
4936
  }
 
4937
  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
 
4938
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
 
4939
  if (!SWIG_IsOK(res2)) {
 
4940
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
 
4941
  }
 
4942
  if (!argp2) {
 
4943
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
 
4944
  }
 
4945
  arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
 
4946
  result = ((swig::PySwigIterator const *)arg1)->operator -((swig::PySwigIterator const &)*arg2);
 
4947
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
 
4948
  return resultobj;
 
4949
fail:
 
4950
  return NULL;
 
4951
}
 
4952
 
 
4953
 
 
4954
SWIGINTERN PyObject *_wrap_PySwigIterator___sub__(PyObject *self, PyObject *args) {
 
4955
  int argc;
 
4956
  PyObject *argv[3];
 
4957
  int ii;
 
4958
  
 
4959
  if (!PyTuple_Check(args)) SWIG_fail;
 
4960
  argc = (int)PyObject_Length(args);
 
4961
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
 
4962
    argv[ii] = PyTuple_GET_ITEM(args,ii);
 
4963
  }
 
4964
  if (argc == 2) {
 
4965
    int _v;
 
4966
    void *vptr = 0;
 
4967
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
 
4968
    _v = SWIG_CheckState(res);
 
4969
    if (_v) {
 
4970
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__PySwigIterator, 0);
 
4971
      _v = SWIG_CheckState(res);
 
4972
      if (_v) {
 
4973
        return _wrap_PySwigIterator___sub____SWIG_1(self, args);
 
4974
      }
 
4975
    }
 
4976
  }
 
4977
  if (argc == 2) {
 
4978
    int _v;
 
4979
    void *vptr = 0;
 
4980
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
 
4981
    _v = SWIG_CheckState(res);
 
4982
    if (_v) {
 
4983
      {
 
4984
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
 
4985
        _v = SWIG_CheckState(res);
 
4986
      }
 
4987
      if (_v) {
 
4988
        return _wrap_PySwigIterator___sub____SWIG_0(self, args);
 
4989
      }
 
4990
    }
 
4991
  }
 
4992
  
 
4993
fail:
 
4994
  Py_INCREF(Py_NotImplemented);
 
4995
  return Py_NotImplemented;
 
4996
}
 
4997
 
 
4998
 
 
4999
SWIGINTERN PyObject *PySwigIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5000
  PyObject *obj;
 
5001
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
 
5002
  SWIG_TypeNewClientData(SWIGTYPE_p_swig__PySwigIterator, SWIG_NewClientData(obj));
 
5003
  return SWIG_Py_Void();
 
5004
}
 
5005
 
 
5006
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceGradient_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5007
  PyObject *resultobj = 0;
 
5008
  OT::String *result = 0 ;
 
5009
  
 
5010
  if (!PyArg_ParseTuple(args,(char *)":CenteredFiniteDifferenceGradient_GetClassName")) SWIG_fail;
 
5011
  {
 
5012
    try {
 
5013
      {
 
5014
        OT::String const &_result_ref = OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::GetClassName();
 
5015
        result = (OT::String *) &_result_ref;
 
5016
      }
 
5017
    }
 
5018
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5019
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5020
    }
 
5021
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5022
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5023
    }
 
5024
    catch (OT::Base::Common::Exception & ex) {
 
5025
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5026
    }
 
5027
    catch (std::out_of_range & ex) {
 
5028
      SWIG_exception(SWIG_IndexError,ex.what());
 
5029
    }
 
5030
    catch (std::exception & ex) {
 
5031
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5032
    }
 
5033
  }
 
5034
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
 
5035
  return resultobj;
 
5036
fail:
 
5037
  return NULL;
 
5038
}
 
5039
 
 
5040
 
 
5041
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceGradient_getClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5042
  PyObject *resultobj = 0;
 
5043
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) 0 ;
 
5044
  void *argp1 = 0 ;
 
5045
  int res1 = 0 ;
 
5046
  PyObject * obj0 = 0 ;
 
5047
  OT::String *result = 0 ;
 
5048
  
 
5049
  if (!PyArg_ParseTuple(args,(char *)"O:CenteredFiniteDifferenceGradient_getClassName",&obj0)) SWIG_fail;
 
5050
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, 0 |  0 );
 
5051
  if (!SWIG_IsOK(res1)) {
 
5052
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceGradient_getClassName" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *""'"); 
 
5053
  }
 
5054
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient * >(argp1);
 
5055
  {
 
5056
    try {
 
5057
      {
 
5058
        OT::String const &_result_ref = ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *)arg1)->getClassName();
 
5059
        result = (OT::String *) &_result_ref;
 
5060
      }
 
5061
    }
 
5062
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5063
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5064
    }
 
5065
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5066
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5067
    }
 
5068
    catch (OT::Base::Common::Exception & ex) {
 
5069
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5070
    }
 
5071
    catch (std::out_of_range & ex) {
 
5072
      SWIG_exception(SWIG_IndexError,ex.what());
 
5073
    }
 
5074
    catch (std::exception & ex) {
 
5075
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5076
    }
 
5077
  }
 
5078
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
 
5079
  return resultobj;
 
5080
fail:
 
5081
  return NULL;
 
5082
}
 
5083
 
 
5084
 
 
5085
SWIGINTERN int Swig_var_CenteredFiniteDifferenceGradient_DefaultEpsilon_set(PyObject *) {
 
5086
  SWIG_Error(SWIG_AttributeError,"Variable CenteredFiniteDifferenceGradient_DefaultEpsilon is read-only.");
 
5087
  return 1;
 
5088
}
 
5089
 
 
5090
 
 
5091
SWIGINTERN PyObject *Swig_var_CenteredFiniteDifferenceGradient_DefaultEpsilon_get(void) {
 
5092
  PyObject *pyobj = 0;
 
5093
  
 
5094
  pyobj = SWIG_From_double(static_cast< double >(OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::DefaultEpsilon));
 
5095
  return pyobj;
 
5096
}
 
5097
 
 
5098
 
 
5099
SWIGINTERN PyObject *_wrap_new_CenteredFiniteDifferenceGradient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5100
  PyObject *resultobj = 0;
 
5101
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *result = 0 ;
 
5102
  
 
5103
  if (!PyArg_ParseTuple(args,(char *)":new_CenteredFiniteDifferenceGradient")) SWIG_fail;
 
5104
  {
 
5105
    try {
 
5106
      result = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *)new OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient();
 
5107
    }
 
5108
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5109
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5110
    }
 
5111
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5112
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5113
    }
 
5114
    catch (OT::Base::Common::Exception & ex) {
 
5115
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5116
    }
 
5117
    catch (std::out_of_range & ex) {
 
5118
      SWIG_exception(SWIG_IndexError,ex.what());
 
5119
    }
 
5120
    catch (std::exception & ex) {
 
5121
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5122
    }
 
5123
  }
 
5124
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, SWIG_POINTER_NEW |  0 );
 
5125
  return resultobj;
 
5126
fail:
 
5127
  return NULL;
 
5128
}
 
5129
 
 
5130
 
 
5131
SWIGINTERN PyObject *_wrap_new_CenteredFiniteDifferenceGradient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5132
  PyObject *resultobj = 0;
 
5133
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::NumericalPoint *arg1 = 0 ;
 
5134
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation *arg2 = 0 ;
 
5135
  void *argp1 = 0 ;
 
5136
  int res1 = 0 ;
 
5137
  void *argp2 = 0 ;
 
5138
  int res2 = 0 ;
 
5139
  PyObject * obj0 = 0 ;
 
5140
  PyObject * obj1 = 0 ;
 
5141
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *result = 0 ;
 
5142
  
 
5143
  if (!PyArg_ParseTuple(args,(char *)"OO:new_CenteredFiniteDifferenceGradient",&obj0,&obj1)) SWIG_fail;
 
5144
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPoint,  0  | 0);
 
5145
  if (!SWIG_IsOK(res1)) {
 
5146
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CenteredFiniteDifferenceGradient" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::NumericalPoint const &""'"); 
 
5147
  }
 
5148
  if (!argp1) {
 
5149
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CenteredFiniteDifferenceGradient" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::NumericalPoint const &""'"); 
 
5150
  }
 
5151
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::NumericalPoint * >(argp1);
 
5152
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t,  0  | 0);
 
5153
  if (!SWIG_IsOK(res2)) {
 
5154
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CenteredFiniteDifferenceGradient" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation const &""'"); 
 
5155
  }
 
5156
  if (!argp2) {
 
5157
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CenteredFiniteDifferenceGradient" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation const &""'"); 
 
5158
  }
 
5159
  arg2 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation * >(argp2);
 
5160
  {
 
5161
    try {
 
5162
      result = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *)new OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::NumericalPoint const &)*arg1,(OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation const &)*arg2);
 
5163
    }
 
5164
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5165
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5166
    }
 
5167
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5168
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5169
    }
 
5170
    catch (OT::Base::Common::Exception & ex) {
 
5171
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5172
    }
 
5173
    catch (std::out_of_range & ex) {
 
5174
      SWIG_exception(SWIG_IndexError,ex.what());
 
5175
    }
 
5176
    catch (std::exception & ex) {
 
5177
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5178
    }
 
5179
  }
 
5180
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, SWIG_POINTER_NEW |  0 );
 
5181
  return resultobj;
 
5182
fail:
 
5183
  return NULL;
 
5184
}
 
5185
 
 
5186
 
 
5187
SWIGINTERN PyObject *_wrap_new_CenteredFiniteDifferenceGradient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5188
  PyObject *resultobj = 0;
 
5189
  OpenTURNS::NumericalScalar arg1 ;
 
5190
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation *arg2 = 0 ;
 
5191
  double val1 ;
 
5192
  int ecode1 = 0 ;
 
5193
  void *argp2 = 0 ;
 
5194
  int res2 = 0 ;
 
5195
  PyObject * obj0 = 0 ;
 
5196
  PyObject * obj1 = 0 ;
 
5197
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *result = 0 ;
 
5198
  
 
5199
  if (!PyArg_ParseTuple(args,(char *)"OO:new_CenteredFiniteDifferenceGradient",&obj0,&obj1)) SWIG_fail;
 
5200
  ecode1 = SWIG_AsVal_double(obj0, &val1);
 
5201
  if (!SWIG_IsOK(ecode1)) {
 
5202
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CenteredFiniteDifferenceGradient" "', argument " "1"" of type '" "OpenTURNS::NumericalScalar""'");
 
5203
  } 
 
5204
  arg1 = static_cast< OpenTURNS::NumericalScalar >(val1);
 
5205
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t,  0  | 0);
 
5206
  if (!SWIG_IsOK(res2)) {
 
5207
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CenteredFiniteDifferenceGradient" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation const &""'"); 
 
5208
  }
 
5209
  if (!argp2) {
 
5210
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CenteredFiniteDifferenceGradient" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation const &""'"); 
 
5211
  }
 
5212
  arg2 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation * >(argp2);
 
5213
  {
 
5214
    try {
 
5215
      result = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *)new OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient(arg1,(OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation const &)*arg2);
 
5216
    }
 
5217
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5218
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5219
    }
 
5220
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5221
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5222
    }
 
5223
    catch (OT::Base::Common::Exception & ex) {
 
5224
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5225
    }
 
5226
    catch (std::out_of_range & ex) {
 
5227
      SWIG_exception(SWIG_IndexError,ex.what());
 
5228
    }
 
5229
    catch (std::exception & ex) {
 
5230
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5231
    }
 
5232
  }
 
5233
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, SWIG_POINTER_NEW |  0 );
 
5234
  return resultobj;
 
5235
fail:
 
5236
  return NULL;
 
5237
}
 
5238
 
 
5239
 
 
5240
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceGradient_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5241
  PyObject *resultobj = 0;
 
5242
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) 0 ;
 
5243
  void *argp1 = 0 ;
 
5244
  int res1 = 0 ;
 
5245
  PyObject * obj0 = 0 ;
 
5246
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *result = 0 ;
 
5247
  
 
5248
  if (!PyArg_ParseTuple(args,(char *)"O:CenteredFiniteDifferenceGradient_clone",&obj0)) SWIG_fail;
 
5249
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, 0 |  0 );
 
5250
  if (!SWIG_IsOK(res1)) {
 
5251
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceGradient_clone" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *""'"); 
 
5252
  }
 
5253
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient * >(argp1);
 
5254
  {
 
5255
    try {
 
5256
      result = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *)((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *)arg1)->clone();
 
5257
    }
 
5258
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5259
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5260
    }
 
5261
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5262
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5263
    }
 
5264
    catch (OT::Base::Common::Exception & ex) {
 
5265
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5266
    }
 
5267
    catch (std::out_of_range & ex) {
 
5268
      SWIG_exception(SWIG_IndexError,ex.what());
 
5269
    }
 
5270
    catch (std::exception & ex) {
 
5271
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5272
    }
 
5273
  }
 
5274
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, 0 |  0 );
 
5275
  return resultobj;
 
5276
fail:
 
5277
  return NULL;
 
5278
}
 
5279
 
 
5280
 
 
5281
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceGradient___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5282
  PyObject *resultobj = 0;
 
5283
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) 0 ;
 
5284
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *arg2 = 0 ;
 
5285
  void *argp1 = 0 ;
 
5286
  int res1 = 0 ;
 
5287
  void *argp2 = 0 ;
 
5288
  int res2 = 0 ;
 
5289
  PyObject * obj0 = 0 ;
 
5290
  PyObject * obj1 = 0 ;
 
5291
  OpenTURNS::Bool result;
 
5292
  
 
5293
  if (!PyArg_ParseTuple(args,(char *)"OO:CenteredFiniteDifferenceGradient___eq__",&obj0,&obj1)) SWIG_fail;
 
5294
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, 0 |  0 );
 
5295
  if (!SWIG_IsOK(res1)) {
 
5296
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceGradient___eq__" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *""'"); 
 
5297
  }
 
5298
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient * >(argp1);
 
5299
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient,  0  | 0);
 
5300
  if (!SWIG_IsOK(res2)) {
 
5301
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CenteredFiniteDifferenceGradient___eq__" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const &""'"); 
 
5302
  }
 
5303
  if (!argp2) {
 
5304
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CenteredFiniteDifferenceGradient___eq__" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const &""'"); 
 
5305
  }
 
5306
  arg2 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient * >(argp2);
 
5307
  {
 
5308
    try {
 
5309
      result = (OpenTURNS::Bool)((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *)arg1)->operator ==((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const &)*arg2);
 
5310
    }
 
5311
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5312
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5313
    }
 
5314
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5315
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5316
    }
 
5317
    catch (OT::Base::Common::Exception & ex) {
 
5318
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5319
    }
 
5320
    catch (std::out_of_range & ex) {
 
5321
      SWIG_exception(SWIG_IndexError,ex.what());
 
5322
    }
 
5323
    catch (std::exception & ex) {
 
5324
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5325
    }
 
5326
  }
 
5327
  resultobj = SWIG_From_bool(static_cast< bool >(result));
 
5328
  return resultobj;
 
5329
fail:
 
5330
  return NULL;
 
5331
}
 
5332
 
 
5333
 
 
5334
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceGradient___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5335
  PyObject *resultobj = 0;
 
5336
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) 0 ;
 
5337
  void *argp1 = 0 ;
 
5338
  int res1 = 0 ;
 
5339
  PyObject * obj0 = 0 ;
 
5340
  OpenTURNS::String result;
 
5341
  
 
5342
  if (!PyArg_ParseTuple(args,(char *)"O:CenteredFiniteDifferenceGradient___repr__",&obj0)) SWIG_fail;
 
5343
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, 0 |  0 );
 
5344
  if (!SWIG_IsOK(res1)) {
 
5345
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceGradient___repr__" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *""'"); 
 
5346
  }
 
5347
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient * >(argp1);
 
5348
  {
 
5349
    try {
 
5350
      result = ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *)arg1)->__repr__();
 
5351
    }
 
5352
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5353
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5354
    }
 
5355
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5356
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5357
    }
 
5358
    catch (OT::Base::Common::Exception & ex) {
 
5359
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5360
    }
 
5361
    catch (std::out_of_range & ex) {
 
5362
      SWIG_exception(SWIG_IndexError,ex.what());
 
5363
    }
 
5364
    catch (std::exception & ex) {
 
5365
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5366
    }
 
5367
  }
 
5368
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
 
5369
  return resultobj;
 
5370
fail:
 
5371
  return NULL;
 
5372
}
 
5373
 
 
5374
 
 
5375
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceGradient_gradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5376
  PyObject *resultobj = 0;
 
5377
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) 0 ;
 
5378
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::NumericalPoint *arg2 = 0 ;
 
5379
  void *argp1 = 0 ;
 
5380
  int res1 = 0 ;
 
5381
  void *argp2 = 0 ;
 
5382
  int res2 = 0 ;
 
5383
  PyObject * obj0 = 0 ;
 
5384
  PyObject * obj1 = 0 ;
 
5385
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::Matrix result;
 
5386
  
 
5387
  if (!PyArg_ParseTuple(args,(char *)"OO:CenteredFiniteDifferenceGradient_gradient",&obj0,&obj1)) SWIG_fail;
 
5388
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, 0 |  0 );
 
5389
  if (!SWIG_IsOK(res1)) {
 
5390
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceGradient_gradient" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *""'"); 
 
5391
  }
 
5392
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient * >(argp1);
 
5393
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPoint,  0  | 0);
 
5394
  if (!SWIG_IsOK(res2)) {
 
5395
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CenteredFiniteDifferenceGradient_gradient" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::NumericalPoint const &""'"); 
 
5396
  }
 
5397
  if (!argp2) {
 
5398
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CenteredFiniteDifferenceGradient_gradient" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::NumericalPoint const &""'"); 
 
5399
  }
 
5400
  arg2 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::NumericalPoint * >(argp2);
 
5401
  {
 
5402
    try {
 
5403
      result = ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *)arg1)->gradient((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::NumericalPoint const &)*arg2);
 
5404
    }
 
5405
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5406
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5407
    }
 
5408
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5409
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5410
    }
 
5411
    catch (OT::Base::Common::Exception & ex) {
 
5412
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5413
    }
 
5414
    catch (std::out_of_range & ex) {
 
5415
      SWIG_exception(SWIG_IndexError,ex.what());
 
5416
    }
 
5417
    catch (std::exception & ex) {
 
5418
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5419
    }
 
5420
  }
 
5421
  resultobj = SWIG_NewPointerObj((new OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::Matrix(static_cast< const OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::Matrix& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__Matrix, SWIG_POINTER_OWN |  0 );
 
5422
  return resultobj;
 
5423
fail:
 
5424
  return NULL;
 
5425
}
 
5426
 
 
5427
 
 
5428
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceGradient_getInputDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5429
  PyObject *resultobj = 0;
 
5430
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) 0 ;
 
5431
  void *argp1 = 0 ;
 
5432
  int res1 = 0 ;
 
5433
  PyObject * obj0 = 0 ;
 
5434
  OpenTURNS::UnsignedLong result;
 
5435
  
 
5436
  if (!PyArg_ParseTuple(args,(char *)"O:CenteredFiniteDifferenceGradient_getInputDimension",&obj0)) SWIG_fail;
 
5437
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, 0 |  0 );
 
5438
  if (!SWIG_IsOK(res1)) {
 
5439
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceGradient_getInputDimension" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *""'"); 
 
5440
  }
 
5441
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient * >(argp1);
 
5442
  {
 
5443
    try {
 
5444
      result = (OpenTURNS::UnsignedLong)((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *)arg1)->getInputDimension();
 
5445
    }
 
5446
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5447
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5448
    }
 
5449
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5450
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5451
    }
 
5452
    catch (OT::Base::Common::Exception & ex) {
 
5453
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5454
    }
 
5455
    catch (std::out_of_range & ex) {
 
5456
      SWIG_exception(SWIG_IndexError,ex.what());
 
5457
    }
 
5458
    catch (std::exception & ex) {
 
5459
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5460
    }
 
5461
  }
 
5462
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
 
5463
  return resultobj;
 
5464
fail:
 
5465
  return NULL;
 
5466
}
 
5467
 
 
5468
 
 
5469
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceGradient_getOutputDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5470
  PyObject *resultobj = 0;
 
5471
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) 0 ;
 
5472
  void *argp1 = 0 ;
 
5473
  int res1 = 0 ;
 
5474
  PyObject * obj0 = 0 ;
 
5475
  OpenTURNS::UnsignedLong result;
 
5476
  
 
5477
  if (!PyArg_ParseTuple(args,(char *)"O:CenteredFiniteDifferenceGradient_getOutputDimension",&obj0)) SWIG_fail;
 
5478
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, 0 |  0 );
 
5479
  if (!SWIG_IsOK(res1)) {
 
5480
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceGradient_getOutputDimension" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *""'"); 
 
5481
  }
 
5482
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient * >(argp1);
 
5483
  {
 
5484
    try {
 
5485
      result = (OpenTURNS::UnsignedLong)((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *)arg1)->getOutputDimension();
 
5486
    }
 
5487
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5488
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5489
    }
 
5490
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5491
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5492
    }
 
5493
    catch (OT::Base::Common::Exception & ex) {
 
5494
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5495
    }
 
5496
    catch (std::out_of_range & ex) {
 
5497
      SWIG_exception(SWIG_IndexError,ex.what());
 
5498
    }
 
5499
    catch (std::exception & ex) {
 
5500
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5501
    }
 
5502
  }
 
5503
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
 
5504
  return resultobj;
 
5505
fail:
 
5506
  return NULL;
 
5507
}
 
5508
 
 
5509
 
 
5510
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceGradient_getEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5511
  PyObject *resultobj = 0;
 
5512
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) 0 ;
 
5513
  void *argp1 = 0 ;
 
5514
  int res1 = 0 ;
 
5515
  PyObject * obj0 = 0 ;
 
5516
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::NumericalPoint result;
 
5517
  
 
5518
  if (!PyArg_ParseTuple(args,(char *)"O:CenteredFiniteDifferenceGradient_getEpsilon",&obj0)) SWIG_fail;
 
5519
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, 0 |  0 );
 
5520
  if (!SWIG_IsOK(res1)) {
 
5521
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceGradient_getEpsilon" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *""'"); 
 
5522
  }
 
5523
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient * >(argp1);
 
5524
  {
 
5525
    try {
 
5526
      result = ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *)arg1)->getEpsilon();
 
5527
    }
 
5528
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5529
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5530
    }
 
5531
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5532
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5533
    }
 
5534
    catch (OT::Base::Common::Exception & ex) {
 
5535
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5536
    }
 
5537
    catch (std::out_of_range & ex) {
 
5538
      SWIG_exception(SWIG_IndexError,ex.what());
 
5539
    }
 
5540
    catch (std::exception & ex) {
 
5541
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5542
    }
 
5543
  }
 
5544
  resultobj = SWIG_NewPointerObj((new OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::NumericalPoint(static_cast< const OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::NumericalPoint& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPoint, SWIG_POINTER_OWN |  0 );
 
5545
  return resultobj;
 
5546
fail:
 
5547
  return NULL;
 
5548
}
 
5549
 
 
5550
 
 
5551
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceGradient_getEvaluation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5552
  PyObject *resultobj = 0;
 
5553
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) 0 ;
 
5554
  void *argp1 = 0 ;
 
5555
  int res1 = 0 ;
 
5556
  PyObject * obj0 = 0 ;
 
5557
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation result;
 
5558
  
 
5559
  if (!PyArg_ParseTuple(args,(char *)"O:CenteredFiniteDifferenceGradient_getEvaluation",&obj0)) SWIG_fail;
 
5560
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, 0 |  0 );
 
5561
  if (!SWIG_IsOK(res1)) {
 
5562
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceGradient_getEvaluation" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *""'"); 
 
5563
  }
 
5564
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient * >(argp1);
 
5565
  {
 
5566
    try {
 
5567
      result = ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *)arg1)->getEvaluation();
 
5568
    }
 
5569
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5570
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5571
    }
 
5572
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5573
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5574
    }
 
5575
    catch (OT::Base::Common::Exception & ex) {
 
5576
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5577
    }
 
5578
    catch (std::out_of_range & ex) {
 
5579
      SWIG_exception(SWIG_IndexError,ex.what());
 
5580
    }
 
5581
    catch (std::exception & ex) {
 
5582
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5583
    }
 
5584
  }
 
5585
  resultobj = SWIG_NewPointerObj((new OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation(static_cast< const OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation& >(result))), SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t, SWIG_POINTER_OWN |  0 );
 
5586
  return resultobj;
 
5587
fail:
 
5588
  return NULL;
 
5589
}
 
5590
 
 
5591
 
 
5592
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceGradient_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5593
  PyObject *resultobj = 0;
 
5594
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) 0 ;
 
5595
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::StorageManager::Advocate *arg2 = 0 ;
 
5596
  void *argp1 = 0 ;
 
5597
  int res1 = 0 ;
 
5598
  void *argp2 = 0 ;
 
5599
  int res2 = 0 ;
 
5600
  PyObject * obj0 = 0 ;
 
5601
  PyObject * obj1 = 0 ;
 
5602
  
 
5603
  if (!PyArg_ParseTuple(args,(char *)"OO:CenteredFiniteDifferenceGradient_save",&obj0,&obj1)) SWIG_fail;
 
5604
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, 0 |  0 );
 
5605
  if (!SWIG_IsOK(res1)) {
 
5606
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceGradient_save" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *""'"); 
 
5607
  }
 
5608
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient * >(argp1);
 
5609
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Advocate,  0 );
 
5610
  if (!SWIG_IsOK(res2)) {
 
5611
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CenteredFiniteDifferenceGradient_save" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::StorageManager::Advocate &""'"); 
 
5612
  }
 
5613
  if (!argp2) {
 
5614
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CenteredFiniteDifferenceGradient_save" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::StorageManager::Advocate &""'"); 
 
5615
  }
 
5616
  arg2 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::StorageManager::Advocate * >(argp2);
 
5617
  {
 
5618
    try {
 
5619
      ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const *)arg1)->save(*arg2);
 
5620
    }
 
5621
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5622
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5623
    }
 
5624
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5625
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5626
    }
 
5627
    catch (OT::Base::Common::Exception & ex) {
 
5628
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5629
    }
 
5630
    catch (std::out_of_range & ex) {
 
5631
      SWIG_exception(SWIG_IndexError,ex.what());
 
5632
    }
 
5633
    catch (std::exception & ex) {
 
5634
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5635
    }
 
5636
  }
 
5637
  resultobj = SWIG_Py_Void();
 
5638
  return resultobj;
 
5639
fail:
 
5640
  return NULL;
 
5641
}
 
5642
 
 
5643
 
 
5644
SWIGINTERN PyObject *_wrap_new_CenteredFiniteDifferenceGradient__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5645
  PyObject *resultobj = 0;
 
5646
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *arg1 = 0 ;
 
5647
  void *argp1 = 0 ;
 
5648
  int res1 = 0 ;
 
5649
  PyObject * obj0 = 0 ;
 
5650
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *result = 0 ;
 
5651
  
 
5652
  if (!PyArg_ParseTuple(args,(char *)"O:new_CenteredFiniteDifferenceGradient",&obj0)) SWIG_fail;
 
5653
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient,  0  | 0);
 
5654
  if (!SWIG_IsOK(res1)) {
 
5655
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CenteredFiniteDifferenceGradient" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const &""'"); 
 
5656
  }
 
5657
  if (!argp1) {
 
5658
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CenteredFiniteDifferenceGradient" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const &""'"); 
 
5659
  }
 
5660
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient * >(argp1);
 
5661
  {
 
5662
    try {
 
5663
      result = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *)new_OpenTURNS_Base_Diff_CenteredFiniteDifferenceGradient__SWIG_3((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const &)*arg1);
 
5664
    }
 
5665
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5666
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5667
    }
 
5668
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5669
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5670
    }
 
5671
    catch (OT::Base::Common::Exception & ex) {
 
5672
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5673
    }
 
5674
    catch (std::out_of_range & ex) {
 
5675
      SWIG_exception(SWIG_IndexError,ex.what());
 
5676
    }
 
5677
    catch (std::exception & ex) {
 
5678
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5679
    }
 
5680
  }
 
5681
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, SWIG_POINTER_NEW |  0 );
 
5682
  return resultobj;
 
5683
fail:
 
5684
  return NULL;
 
5685
}
 
5686
 
 
5687
 
 
5688
SWIGINTERN PyObject *_wrap_new_CenteredFiniteDifferenceGradient(PyObject *self, PyObject *args) {
 
5689
  int argc;
 
5690
  PyObject *argv[3];
 
5691
  int ii;
 
5692
  
 
5693
  if (!PyTuple_Check(args)) SWIG_fail;
 
5694
  argc = (int)PyObject_Length(args);
 
5695
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
 
5696
    argv[ii] = PyTuple_GET_ITEM(args,ii);
 
5697
  }
 
5698
  if (argc == 0) {
 
5699
    return _wrap_new_CenteredFiniteDifferenceGradient__SWIG_0(self, args);
 
5700
  }
 
5701
  if (argc == 1) {
 
5702
    int _v;
 
5703
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, 0);
 
5704
    _v = SWIG_CheckState(res);
 
5705
    if (_v) {
 
5706
      return _wrap_new_CenteredFiniteDifferenceGradient__SWIG_3(self, args);
 
5707
    }
 
5708
  }
 
5709
  if (argc == 2) {
 
5710
    int _v;
 
5711
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPoint, 0);
 
5712
    _v = SWIG_CheckState(res);
 
5713
    if (_v) {
 
5714
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t, 0);
 
5715
      _v = SWIG_CheckState(res);
 
5716
      if (_v) {
 
5717
        return _wrap_new_CenteredFiniteDifferenceGradient__SWIG_1(self, args);
 
5718
      }
 
5719
    }
 
5720
  }
 
5721
  if (argc == 2) {
 
5722
    int _v;
 
5723
    {
 
5724
      int res = SWIG_AsVal_double(argv[0], NULL);
 
5725
      _v = SWIG_CheckState(res);
 
5726
    }
 
5727
    if (_v) {
 
5728
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t, 0);
 
5729
      _v = SWIG_CheckState(res);
 
5730
      if (_v) {
 
5731
        return _wrap_new_CenteredFiniteDifferenceGradient__SWIG_2(self, args);
 
5732
      }
 
5733
    }
 
5734
  }
 
5735
  
 
5736
fail:
 
5737
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CenteredFiniteDifferenceGradient'.\n"
 
5738
    "  Possible C/C++ prototypes are:\n"
 
5739
    "    OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient()\n"
 
5740
    "    OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient(OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::NumericalPoint const &,OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation const &)\n"
 
5741
    "    OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient(OpenTURNS::NumericalScalar const,OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation const &)\n"
 
5742
    "    OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient(OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient const &)\n");
 
5743
  return NULL;
 
5744
}
 
5745
 
 
5746
 
 
5747
SWIGINTERN PyObject *_wrap_delete_CenteredFiniteDifferenceGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5748
  PyObject *resultobj = 0;
 
5749
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) 0 ;
 
5750
  void *argp1 = 0 ;
 
5751
  int res1 = 0 ;
 
5752
  PyObject * obj0 = 0 ;
 
5753
  
 
5754
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CenteredFiniteDifferenceGradient",&obj0)) SWIG_fail;
 
5755
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, SWIG_POINTER_DISOWN |  0 );
 
5756
  if (!SWIG_IsOK(res1)) {
 
5757
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CenteredFiniteDifferenceGradient" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *""'"); 
 
5758
  }
 
5759
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient * >(argp1);
 
5760
  {
 
5761
    try {
 
5762
      delete arg1;
 
5763
    }
 
5764
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5765
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5766
    }
 
5767
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5768
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5769
    }
 
5770
    catch (OT::Base::Common::Exception & ex) {
 
5771
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5772
    }
 
5773
    catch (std::out_of_range & ex) {
 
5774
      SWIG_exception(SWIG_IndexError,ex.what());
 
5775
    }
 
5776
    catch (std::exception & ex) {
 
5777
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5778
    }
 
5779
  }
 
5780
  resultobj = SWIG_Py_Void();
 
5781
  return resultobj;
 
5782
fail:
 
5783
  return NULL;
 
5784
}
 
5785
 
 
5786
 
 
5787
SWIGINTERN PyObject *CenteredFiniteDifferenceGradient_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5788
  PyObject *obj;
 
5789
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
 
5790
  SWIG_TypeNewClientData(SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, SWIG_NewClientData(obj));
 
5791
  return SWIG_Py_Void();
 
5792
}
 
5793
 
 
5794
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceHessian_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5795
  PyObject *resultobj = 0;
 
5796
  OT::String *result = 0 ;
 
5797
  
 
5798
  if (!PyArg_ParseTuple(args,(char *)":CenteredFiniteDifferenceHessian_GetClassName")) SWIG_fail;
 
5799
  {
 
5800
    try {
 
5801
      {
 
5802
        OT::String const &_result_ref = OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::GetClassName();
 
5803
        result = (OT::String *) &_result_ref;
 
5804
      }
 
5805
    }
 
5806
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5807
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5808
    }
 
5809
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5810
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5811
    }
 
5812
    catch (OT::Base::Common::Exception & ex) {
 
5813
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5814
    }
 
5815
    catch (std::out_of_range & ex) {
 
5816
      SWIG_exception(SWIG_IndexError,ex.what());
 
5817
    }
 
5818
    catch (std::exception & ex) {
 
5819
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5820
    }
 
5821
  }
 
5822
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
 
5823
  return resultobj;
 
5824
fail:
 
5825
  return NULL;
 
5826
}
 
5827
 
 
5828
 
 
5829
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceHessian_getClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5830
  PyObject *resultobj = 0;
 
5831
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) 0 ;
 
5832
  void *argp1 = 0 ;
 
5833
  int res1 = 0 ;
 
5834
  PyObject * obj0 = 0 ;
 
5835
  OT::String *result = 0 ;
 
5836
  
 
5837
  if (!PyArg_ParseTuple(args,(char *)"O:CenteredFiniteDifferenceHessian_getClassName",&obj0)) SWIG_fail;
 
5838
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, 0 |  0 );
 
5839
  if (!SWIG_IsOK(res1)) {
 
5840
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceHessian_getClassName" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *""'"); 
 
5841
  }
 
5842
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian * >(argp1);
 
5843
  {
 
5844
    try {
 
5845
      {
 
5846
        OT::String const &_result_ref = ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *)arg1)->getClassName();
 
5847
        result = (OT::String *) &_result_ref;
 
5848
      }
 
5849
    }
 
5850
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5851
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5852
    }
 
5853
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5854
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5855
    }
 
5856
    catch (OT::Base::Common::Exception & ex) {
 
5857
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5858
    }
 
5859
    catch (std::out_of_range & ex) {
 
5860
      SWIG_exception(SWIG_IndexError,ex.what());
 
5861
    }
 
5862
    catch (std::exception & ex) {
 
5863
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5864
    }
 
5865
  }
 
5866
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
 
5867
  return resultobj;
 
5868
fail:
 
5869
  return NULL;
 
5870
}
 
5871
 
 
5872
 
 
5873
SWIGINTERN int Swig_var_CenteredFiniteDifferenceHessian_DefaultEpsilon_set(PyObject *) {
 
5874
  SWIG_Error(SWIG_AttributeError,"Variable CenteredFiniteDifferenceHessian_DefaultEpsilon is read-only.");
 
5875
  return 1;
 
5876
}
 
5877
 
 
5878
 
 
5879
SWIGINTERN PyObject *Swig_var_CenteredFiniteDifferenceHessian_DefaultEpsilon_get(void) {
 
5880
  PyObject *pyobj = 0;
 
5881
  
 
5882
  pyobj = SWIG_From_double(static_cast< double >(OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::DefaultEpsilon));
 
5883
  return pyobj;
 
5884
}
 
5885
 
 
5886
 
 
5887
SWIGINTERN PyObject *_wrap_new_CenteredFiniteDifferenceHessian__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5888
  PyObject *resultobj = 0;
 
5889
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *result = 0 ;
 
5890
  
 
5891
  if (!PyArg_ParseTuple(args,(char *)":new_CenteredFiniteDifferenceHessian")) SWIG_fail;
 
5892
  {
 
5893
    try {
 
5894
      result = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *)new OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian();
 
5895
    }
 
5896
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5897
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5898
    }
 
5899
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5900
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5901
    }
 
5902
    catch (OT::Base::Common::Exception & ex) {
 
5903
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5904
    }
 
5905
    catch (std::out_of_range & ex) {
 
5906
      SWIG_exception(SWIG_IndexError,ex.what());
 
5907
    }
 
5908
    catch (std::exception & ex) {
 
5909
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5910
    }
 
5911
  }
 
5912
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, SWIG_POINTER_NEW |  0 );
 
5913
  return resultobj;
 
5914
fail:
 
5915
  return NULL;
 
5916
}
 
5917
 
 
5918
 
 
5919
SWIGINTERN PyObject *_wrap_new_CenteredFiniteDifferenceHessian__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5920
  PyObject *resultobj = 0;
 
5921
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::NumericalPoint *arg1 = 0 ;
 
5922
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation *arg2 = 0 ;
 
5923
  void *argp1 = 0 ;
 
5924
  int res1 = 0 ;
 
5925
  void *argp2 = 0 ;
 
5926
  int res2 = 0 ;
 
5927
  PyObject * obj0 = 0 ;
 
5928
  PyObject * obj1 = 0 ;
 
5929
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *result = 0 ;
 
5930
  
 
5931
  if (!PyArg_ParseTuple(args,(char *)"OO:new_CenteredFiniteDifferenceHessian",&obj0,&obj1)) SWIG_fail;
 
5932
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPoint,  0  | 0);
 
5933
  if (!SWIG_IsOK(res1)) {
 
5934
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CenteredFiniteDifferenceHessian" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::NumericalPoint const &""'"); 
 
5935
  }
 
5936
  if (!argp1) {
 
5937
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CenteredFiniteDifferenceHessian" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::NumericalPoint const &""'"); 
 
5938
  }
 
5939
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::NumericalPoint * >(argp1);
 
5940
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t,  0  | 0);
 
5941
  if (!SWIG_IsOK(res2)) {
 
5942
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CenteredFiniteDifferenceHessian" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation const &""'"); 
 
5943
  }
 
5944
  if (!argp2) {
 
5945
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CenteredFiniteDifferenceHessian" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation const &""'"); 
 
5946
  }
 
5947
  arg2 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation * >(argp2);
 
5948
  {
 
5949
    try {
 
5950
      result = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *)new OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::NumericalPoint const &)*arg1,(OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation const &)*arg2);
 
5951
    }
 
5952
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
5953
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
5954
    }
 
5955
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
5956
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
5957
    }
 
5958
    catch (OT::Base::Common::Exception & ex) {
 
5959
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
5960
    }
 
5961
    catch (std::out_of_range & ex) {
 
5962
      SWIG_exception(SWIG_IndexError,ex.what());
 
5963
    }
 
5964
    catch (std::exception & ex) {
 
5965
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
5966
    }
 
5967
  }
 
5968
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, SWIG_POINTER_NEW |  0 );
 
5969
  return resultobj;
 
5970
fail:
 
5971
  return NULL;
 
5972
}
 
5973
 
 
5974
 
 
5975
SWIGINTERN PyObject *_wrap_new_CenteredFiniteDifferenceHessian__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5976
  PyObject *resultobj = 0;
 
5977
  OpenTURNS::NumericalScalar arg1 ;
 
5978
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation *arg2 = 0 ;
 
5979
  double val1 ;
 
5980
  int ecode1 = 0 ;
 
5981
  void *argp2 = 0 ;
 
5982
  int res2 = 0 ;
 
5983
  PyObject * obj0 = 0 ;
 
5984
  PyObject * obj1 = 0 ;
 
5985
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *result = 0 ;
 
5986
  
 
5987
  if (!PyArg_ParseTuple(args,(char *)"OO:new_CenteredFiniteDifferenceHessian",&obj0,&obj1)) SWIG_fail;
 
5988
  ecode1 = SWIG_AsVal_double(obj0, &val1);
 
5989
  if (!SWIG_IsOK(ecode1)) {
 
5990
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CenteredFiniteDifferenceHessian" "', argument " "1"" of type '" "OpenTURNS::NumericalScalar""'");
 
5991
  } 
 
5992
  arg1 = static_cast< OpenTURNS::NumericalScalar >(val1);
 
5993
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t,  0  | 0);
 
5994
  if (!SWIG_IsOK(res2)) {
 
5995
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CenteredFiniteDifferenceHessian" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation const &""'"); 
 
5996
  }
 
5997
  if (!argp2) {
 
5998
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CenteredFiniteDifferenceHessian" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation const &""'"); 
 
5999
  }
 
6000
  arg2 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation * >(argp2);
 
6001
  {
 
6002
    try {
 
6003
      result = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *)new OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian(arg1,(OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation const &)*arg2);
 
6004
    }
 
6005
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6006
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6007
    }
 
6008
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6009
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6010
    }
 
6011
    catch (OT::Base::Common::Exception & ex) {
 
6012
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6013
    }
 
6014
    catch (std::out_of_range & ex) {
 
6015
      SWIG_exception(SWIG_IndexError,ex.what());
 
6016
    }
 
6017
    catch (std::exception & ex) {
 
6018
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6019
    }
 
6020
  }
 
6021
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, SWIG_POINTER_NEW |  0 );
 
6022
  return resultobj;
 
6023
fail:
 
6024
  return NULL;
 
6025
}
 
6026
 
 
6027
 
 
6028
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceHessian_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6029
  PyObject *resultobj = 0;
 
6030
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) 0 ;
 
6031
  void *argp1 = 0 ;
 
6032
  int res1 = 0 ;
 
6033
  PyObject * obj0 = 0 ;
 
6034
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *result = 0 ;
 
6035
  
 
6036
  if (!PyArg_ParseTuple(args,(char *)"O:CenteredFiniteDifferenceHessian_clone",&obj0)) SWIG_fail;
 
6037
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, 0 |  0 );
 
6038
  if (!SWIG_IsOK(res1)) {
 
6039
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceHessian_clone" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *""'"); 
 
6040
  }
 
6041
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian * >(argp1);
 
6042
  {
 
6043
    try {
 
6044
      result = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *)((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *)arg1)->clone();
 
6045
    }
 
6046
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6047
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6048
    }
 
6049
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6050
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6051
    }
 
6052
    catch (OT::Base::Common::Exception & ex) {
 
6053
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6054
    }
 
6055
    catch (std::out_of_range & ex) {
 
6056
      SWIG_exception(SWIG_IndexError,ex.what());
 
6057
    }
 
6058
    catch (std::exception & ex) {
 
6059
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6060
    }
 
6061
  }
 
6062
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, 0 |  0 );
 
6063
  return resultobj;
 
6064
fail:
 
6065
  return NULL;
 
6066
}
 
6067
 
 
6068
 
 
6069
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceHessian___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6070
  PyObject *resultobj = 0;
 
6071
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) 0 ;
 
6072
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *arg2 = 0 ;
 
6073
  void *argp1 = 0 ;
 
6074
  int res1 = 0 ;
 
6075
  void *argp2 = 0 ;
 
6076
  int res2 = 0 ;
 
6077
  PyObject * obj0 = 0 ;
 
6078
  PyObject * obj1 = 0 ;
 
6079
  OpenTURNS::Bool result;
 
6080
  
 
6081
  if (!PyArg_ParseTuple(args,(char *)"OO:CenteredFiniteDifferenceHessian___eq__",&obj0,&obj1)) SWIG_fail;
 
6082
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, 0 |  0 );
 
6083
  if (!SWIG_IsOK(res1)) {
 
6084
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceHessian___eq__" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *""'"); 
 
6085
  }
 
6086
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian * >(argp1);
 
6087
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian,  0  | 0);
 
6088
  if (!SWIG_IsOK(res2)) {
 
6089
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CenteredFiniteDifferenceHessian___eq__" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const &""'"); 
 
6090
  }
 
6091
  if (!argp2) {
 
6092
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CenteredFiniteDifferenceHessian___eq__" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const &""'"); 
 
6093
  }
 
6094
  arg2 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian * >(argp2);
 
6095
  {
 
6096
    try {
 
6097
      result = (OpenTURNS::Bool)((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *)arg1)->operator ==((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const &)*arg2);
 
6098
    }
 
6099
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6100
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6101
    }
 
6102
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6103
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6104
    }
 
6105
    catch (OT::Base::Common::Exception & ex) {
 
6106
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6107
    }
 
6108
    catch (std::out_of_range & ex) {
 
6109
      SWIG_exception(SWIG_IndexError,ex.what());
 
6110
    }
 
6111
    catch (std::exception & ex) {
 
6112
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6113
    }
 
6114
  }
 
6115
  resultobj = SWIG_From_bool(static_cast< bool >(result));
 
6116
  return resultobj;
 
6117
fail:
 
6118
  return NULL;
 
6119
}
 
6120
 
 
6121
 
 
6122
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceHessian___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6123
  PyObject *resultobj = 0;
 
6124
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) 0 ;
 
6125
  void *argp1 = 0 ;
 
6126
  int res1 = 0 ;
 
6127
  PyObject * obj0 = 0 ;
 
6128
  OpenTURNS::String result;
 
6129
  
 
6130
  if (!PyArg_ParseTuple(args,(char *)"O:CenteredFiniteDifferenceHessian___repr__",&obj0)) SWIG_fail;
 
6131
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, 0 |  0 );
 
6132
  if (!SWIG_IsOK(res1)) {
 
6133
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceHessian___repr__" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *""'"); 
 
6134
  }
 
6135
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian * >(argp1);
 
6136
  {
 
6137
    try {
 
6138
      result = ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *)arg1)->__repr__();
 
6139
    }
 
6140
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6141
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6142
    }
 
6143
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6144
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6145
    }
 
6146
    catch (OT::Base::Common::Exception & ex) {
 
6147
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6148
    }
 
6149
    catch (std::out_of_range & ex) {
 
6150
      SWIG_exception(SWIG_IndexError,ex.what());
 
6151
    }
 
6152
    catch (std::exception & ex) {
 
6153
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6154
    }
 
6155
  }
 
6156
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
 
6157
  return resultobj;
 
6158
fail:
 
6159
  return NULL;
 
6160
}
 
6161
 
 
6162
 
 
6163
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceHessian_hessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6164
  PyObject *resultobj = 0;
 
6165
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) 0 ;
 
6166
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::NumericalPoint *arg2 = 0 ;
 
6167
  void *argp1 = 0 ;
 
6168
  int res1 = 0 ;
 
6169
  void *argp2 = 0 ;
 
6170
  int res2 = 0 ;
 
6171
  PyObject * obj0 = 0 ;
 
6172
  PyObject * obj1 = 0 ;
 
6173
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::SymmetricTensor result;
 
6174
  
 
6175
  if (!PyArg_ParseTuple(args,(char *)"OO:CenteredFiniteDifferenceHessian_hessian",&obj0,&obj1)) SWIG_fail;
 
6176
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, 0 |  0 );
 
6177
  if (!SWIG_IsOK(res1)) {
 
6178
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceHessian_hessian" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *""'"); 
 
6179
  }
 
6180
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian * >(argp1);
 
6181
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPoint,  0  | 0);
 
6182
  if (!SWIG_IsOK(res2)) {
 
6183
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CenteredFiniteDifferenceHessian_hessian" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::NumericalPoint const &""'"); 
 
6184
  }
 
6185
  if (!argp2) {
 
6186
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CenteredFiniteDifferenceHessian_hessian" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::NumericalPoint const &""'"); 
 
6187
  }
 
6188
  arg2 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::NumericalPoint * >(argp2);
 
6189
  {
 
6190
    try {
 
6191
      result = ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *)arg1)->hessian((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::NumericalPoint const &)*arg2);
 
6192
    }
 
6193
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6194
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6195
    }
 
6196
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6197
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6198
    }
 
6199
    catch (OT::Base::Common::Exception & ex) {
 
6200
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6201
    }
 
6202
    catch (std::out_of_range & ex) {
 
6203
      SWIG_exception(SWIG_IndexError,ex.what());
 
6204
    }
 
6205
    catch (std::exception & ex) {
 
6206
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6207
    }
 
6208
  }
 
6209
  resultobj = SWIG_NewPointerObj((new OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::SymmetricTensor(static_cast< const OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::SymmetricTensor& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__SymmetricTensor, SWIG_POINTER_OWN |  0 );
 
6210
  return resultobj;
 
6211
fail:
 
6212
  return NULL;
 
6213
}
 
6214
 
 
6215
 
 
6216
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceHessian_getInputDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6217
  PyObject *resultobj = 0;
 
6218
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) 0 ;
 
6219
  void *argp1 = 0 ;
 
6220
  int res1 = 0 ;
 
6221
  PyObject * obj0 = 0 ;
 
6222
  OpenTURNS::UnsignedLong result;
 
6223
  
 
6224
  if (!PyArg_ParseTuple(args,(char *)"O:CenteredFiniteDifferenceHessian_getInputDimension",&obj0)) SWIG_fail;
 
6225
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, 0 |  0 );
 
6226
  if (!SWIG_IsOK(res1)) {
 
6227
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceHessian_getInputDimension" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *""'"); 
 
6228
  }
 
6229
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian * >(argp1);
 
6230
  {
 
6231
    try {
 
6232
      result = (OpenTURNS::UnsignedLong)((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *)arg1)->getInputDimension();
 
6233
    }
 
6234
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6235
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6236
    }
 
6237
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6238
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6239
    }
 
6240
    catch (OT::Base::Common::Exception & ex) {
 
6241
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6242
    }
 
6243
    catch (std::out_of_range & ex) {
 
6244
      SWIG_exception(SWIG_IndexError,ex.what());
 
6245
    }
 
6246
    catch (std::exception & ex) {
 
6247
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6248
    }
 
6249
  }
 
6250
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
 
6251
  return resultobj;
 
6252
fail:
 
6253
  return NULL;
 
6254
}
 
6255
 
 
6256
 
 
6257
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceHessian_getOutputDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6258
  PyObject *resultobj = 0;
 
6259
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) 0 ;
 
6260
  void *argp1 = 0 ;
 
6261
  int res1 = 0 ;
 
6262
  PyObject * obj0 = 0 ;
 
6263
  OpenTURNS::UnsignedLong result;
 
6264
  
 
6265
  if (!PyArg_ParseTuple(args,(char *)"O:CenteredFiniteDifferenceHessian_getOutputDimension",&obj0)) SWIG_fail;
 
6266
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, 0 |  0 );
 
6267
  if (!SWIG_IsOK(res1)) {
 
6268
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceHessian_getOutputDimension" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *""'"); 
 
6269
  }
 
6270
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian * >(argp1);
 
6271
  {
 
6272
    try {
 
6273
      result = (OpenTURNS::UnsignedLong)((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *)arg1)->getOutputDimension();
 
6274
    }
 
6275
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6276
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6277
    }
 
6278
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6279
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6280
    }
 
6281
    catch (OT::Base::Common::Exception & ex) {
 
6282
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6283
    }
 
6284
    catch (std::out_of_range & ex) {
 
6285
      SWIG_exception(SWIG_IndexError,ex.what());
 
6286
    }
 
6287
    catch (std::exception & ex) {
 
6288
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6289
    }
 
6290
  }
 
6291
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
 
6292
  return resultobj;
 
6293
fail:
 
6294
  return NULL;
 
6295
}
 
6296
 
 
6297
 
 
6298
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceHessian_getEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6299
  PyObject *resultobj = 0;
 
6300
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) 0 ;
 
6301
  void *argp1 = 0 ;
 
6302
  int res1 = 0 ;
 
6303
  PyObject * obj0 = 0 ;
 
6304
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::NumericalPoint result;
 
6305
  
 
6306
  if (!PyArg_ParseTuple(args,(char *)"O:CenteredFiniteDifferenceHessian_getEpsilon",&obj0)) SWIG_fail;
 
6307
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, 0 |  0 );
 
6308
  if (!SWIG_IsOK(res1)) {
 
6309
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceHessian_getEpsilon" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *""'"); 
 
6310
  }
 
6311
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian * >(argp1);
 
6312
  {
 
6313
    try {
 
6314
      result = ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *)arg1)->getEpsilon();
 
6315
    }
 
6316
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6317
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6318
    }
 
6319
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6320
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6321
    }
 
6322
    catch (OT::Base::Common::Exception & ex) {
 
6323
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6324
    }
 
6325
    catch (std::out_of_range & ex) {
 
6326
      SWIG_exception(SWIG_IndexError,ex.what());
 
6327
    }
 
6328
    catch (std::exception & ex) {
 
6329
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6330
    }
 
6331
  }
 
6332
  resultobj = SWIG_NewPointerObj((new OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::NumericalPoint(static_cast< const OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::NumericalPoint& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPoint, SWIG_POINTER_OWN |  0 );
 
6333
  return resultobj;
 
6334
fail:
 
6335
  return NULL;
 
6336
}
 
6337
 
 
6338
 
 
6339
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceHessian_getEvaluation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6340
  PyObject *resultobj = 0;
 
6341
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) 0 ;
 
6342
  void *argp1 = 0 ;
 
6343
  int res1 = 0 ;
 
6344
  PyObject * obj0 = 0 ;
 
6345
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation result;
 
6346
  
 
6347
  if (!PyArg_ParseTuple(args,(char *)"O:CenteredFiniteDifferenceHessian_getEvaluation",&obj0)) SWIG_fail;
 
6348
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, 0 |  0 );
 
6349
  if (!SWIG_IsOK(res1)) {
 
6350
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceHessian_getEvaluation" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *""'"); 
 
6351
  }
 
6352
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian * >(argp1);
 
6353
  {
 
6354
    try {
 
6355
      result = ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *)arg1)->getEvaluation();
 
6356
    }
 
6357
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6358
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6359
    }
 
6360
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6361
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6362
    }
 
6363
    catch (OT::Base::Common::Exception & ex) {
 
6364
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6365
    }
 
6366
    catch (std::out_of_range & ex) {
 
6367
      SWIG_exception(SWIG_IndexError,ex.what());
 
6368
    }
 
6369
    catch (std::exception & ex) {
 
6370
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6371
    }
 
6372
  }
 
6373
  resultobj = SWIG_NewPointerObj((new OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation(static_cast< const OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation& >(result))), SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t, SWIG_POINTER_OWN |  0 );
 
6374
  return resultobj;
 
6375
fail:
 
6376
  return NULL;
 
6377
}
 
6378
 
 
6379
 
 
6380
SWIGINTERN PyObject *_wrap_CenteredFiniteDifferenceHessian_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6381
  PyObject *resultobj = 0;
 
6382
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) 0 ;
 
6383
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::StorageManager::Advocate *arg2 = 0 ;
 
6384
  void *argp1 = 0 ;
 
6385
  int res1 = 0 ;
 
6386
  void *argp2 = 0 ;
 
6387
  int res2 = 0 ;
 
6388
  PyObject * obj0 = 0 ;
 
6389
  PyObject * obj1 = 0 ;
 
6390
  
 
6391
  if (!PyArg_ParseTuple(args,(char *)"OO:CenteredFiniteDifferenceHessian_save",&obj0,&obj1)) SWIG_fail;
 
6392
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, 0 |  0 );
 
6393
  if (!SWIG_IsOK(res1)) {
 
6394
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CenteredFiniteDifferenceHessian_save" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *""'"); 
 
6395
  }
 
6396
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian * >(argp1);
 
6397
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Advocate,  0 );
 
6398
  if (!SWIG_IsOK(res2)) {
 
6399
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CenteredFiniteDifferenceHessian_save" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::StorageManager::Advocate &""'"); 
 
6400
  }
 
6401
  if (!argp2) {
 
6402
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CenteredFiniteDifferenceHessian_save" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::StorageManager::Advocate &""'"); 
 
6403
  }
 
6404
  arg2 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::StorageManager::Advocate * >(argp2);
 
6405
  {
 
6406
    try {
 
6407
      ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const *)arg1)->save(*arg2);
 
6408
    }
 
6409
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6410
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6411
    }
 
6412
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6413
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6414
    }
 
6415
    catch (OT::Base::Common::Exception & ex) {
 
6416
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6417
    }
 
6418
    catch (std::out_of_range & ex) {
 
6419
      SWIG_exception(SWIG_IndexError,ex.what());
 
6420
    }
 
6421
    catch (std::exception & ex) {
 
6422
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6423
    }
 
6424
  }
 
6425
  resultobj = SWIG_Py_Void();
 
6426
  return resultobj;
 
6427
fail:
 
6428
  return NULL;
 
6429
}
 
6430
 
 
6431
 
 
6432
SWIGINTERN PyObject *_wrap_new_CenteredFiniteDifferenceHessian__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6433
  PyObject *resultobj = 0;
 
6434
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *arg1 = 0 ;
 
6435
  void *argp1 = 0 ;
 
6436
  int res1 = 0 ;
 
6437
  PyObject * obj0 = 0 ;
 
6438
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *result = 0 ;
 
6439
  
 
6440
  if (!PyArg_ParseTuple(args,(char *)"O:new_CenteredFiniteDifferenceHessian",&obj0)) SWIG_fail;
 
6441
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian,  0  | 0);
 
6442
  if (!SWIG_IsOK(res1)) {
 
6443
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CenteredFiniteDifferenceHessian" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const &""'"); 
 
6444
  }
 
6445
  if (!argp1) {
 
6446
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CenteredFiniteDifferenceHessian" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const &""'"); 
 
6447
  }
 
6448
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian * >(argp1);
 
6449
  {
 
6450
    try {
 
6451
      result = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *)new_OpenTURNS_Base_Diff_CenteredFiniteDifferenceHessian__SWIG_3((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const &)*arg1);
 
6452
    }
 
6453
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6454
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6455
    }
 
6456
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6457
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6458
    }
 
6459
    catch (OT::Base::Common::Exception & ex) {
 
6460
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6461
    }
 
6462
    catch (std::out_of_range & ex) {
 
6463
      SWIG_exception(SWIG_IndexError,ex.what());
 
6464
    }
 
6465
    catch (std::exception & ex) {
 
6466
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6467
    }
 
6468
  }
 
6469
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, SWIG_POINTER_NEW |  0 );
 
6470
  return resultobj;
 
6471
fail:
 
6472
  return NULL;
 
6473
}
 
6474
 
 
6475
 
 
6476
SWIGINTERN PyObject *_wrap_new_CenteredFiniteDifferenceHessian(PyObject *self, PyObject *args) {
 
6477
  int argc;
 
6478
  PyObject *argv[3];
 
6479
  int ii;
 
6480
  
 
6481
  if (!PyTuple_Check(args)) SWIG_fail;
 
6482
  argc = (int)PyObject_Length(args);
 
6483
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
 
6484
    argv[ii] = PyTuple_GET_ITEM(args,ii);
 
6485
  }
 
6486
  if (argc == 0) {
 
6487
    return _wrap_new_CenteredFiniteDifferenceHessian__SWIG_0(self, args);
 
6488
  }
 
6489
  if (argc == 1) {
 
6490
    int _v;
 
6491
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, 0);
 
6492
    _v = SWIG_CheckState(res);
 
6493
    if (_v) {
 
6494
      return _wrap_new_CenteredFiniteDifferenceHessian__SWIG_3(self, args);
 
6495
    }
 
6496
  }
 
6497
  if (argc == 2) {
 
6498
    int _v;
 
6499
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPoint, 0);
 
6500
    _v = SWIG_CheckState(res);
 
6501
    if (_v) {
 
6502
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t, 0);
 
6503
      _v = SWIG_CheckState(res);
 
6504
      if (_v) {
 
6505
        return _wrap_new_CenteredFiniteDifferenceHessian__SWIG_1(self, args);
 
6506
      }
 
6507
    }
 
6508
  }
 
6509
  if (argc == 2) {
 
6510
    int _v;
 
6511
    {
 
6512
      int res = SWIG_AsVal_double(argv[0], NULL);
 
6513
      _v = SWIG_CheckState(res);
 
6514
    }
 
6515
    if (_v) {
 
6516
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t, 0);
 
6517
      _v = SWIG_CheckState(res);
 
6518
      if (_v) {
 
6519
        return _wrap_new_CenteredFiniteDifferenceHessian__SWIG_2(self, args);
 
6520
      }
 
6521
    }
 
6522
  }
 
6523
  
 
6524
fail:
 
6525
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CenteredFiniteDifferenceHessian'.\n"
 
6526
    "  Possible C/C++ prototypes are:\n"
 
6527
    "    OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian()\n"
 
6528
    "    OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian(OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::NumericalPoint const &,OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation const &)\n"
 
6529
    "    OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian(OpenTURNS::NumericalScalar const,OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation const &)\n"
 
6530
    "    OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian(OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian const &)\n");
 
6531
  return NULL;
 
6532
}
 
6533
 
 
6534
 
 
6535
SWIGINTERN PyObject *_wrap_delete_CenteredFiniteDifferenceHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6536
  PyObject *resultobj = 0;
 
6537
  OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *arg1 = (OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) 0 ;
 
6538
  void *argp1 = 0 ;
 
6539
  int res1 = 0 ;
 
6540
  PyObject * obj0 = 0 ;
 
6541
  
 
6542
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CenteredFiniteDifferenceHessian",&obj0)) SWIG_fail;
 
6543
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, SWIG_POINTER_DISOWN |  0 );
 
6544
  if (!SWIG_IsOK(res1)) {
 
6545
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CenteredFiniteDifferenceHessian" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *""'"); 
 
6546
  }
 
6547
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian * >(argp1);
 
6548
  {
 
6549
    try {
 
6550
      delete arg1;
 
6551
    }
 
6552
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6553
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6554
    }
 
6555
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6556
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6557
    }
 
6558
    catch (OT::Base::Common::Exception & ex) {
 
6559
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6560
    }
 
6561
    catch (std::out_of_range & ex) {
 
6562
      SWIG_exception(SWIG_IndexError,ex.what());
 
6563
    }
 
6564
    catch (std::exception & ex) {
 
6565
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6566
    }
 
6567
  }
 
6568
  resultobj = SWIG_Py_Void();
 
6569
  return resultobj;
 
6570
fail:
 
6571
  return NULL;
 
6572
}
 
6573
 
 
6574
 
 
6575
SWIGINTERN PyObject *CenteredFiniteDifferenceHessian_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6576
  PyObject *obj;
 
6577
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
 
6578
  SWIG_TypeNewClientData(SWIGTYPE_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, SWIG_NewClientData(obj));
 
6579
  return SWIG_Py_Void();
 
6580
}
 
6581
 
 
6582
SWIGINTERN PyObject *_wrap_NonCenteredFiniteDifferenceGradient_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6583
  PyObject *resultobj = 0;
 
6584
  OT::String *result = 0 ;
 
6585
  
 
6586
  if (!PyArg_ParseTuple(args,(char *)":NonCenteredFiniteDifferenceGradient_GetClassName")) SWIG_fail;
 
6587
  {
 
6588
    try {
 
6589
      {
 
6590
        OT::String const &_result_ref = OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::GetClassName();
 
6591
        result = (OT::String *) &_result_ref;
 
6592
      }
 
6593
    }
 
6594
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6595
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6596
    }
 
6597
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6598
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6599
    }
 
6600
    catch (OT::Base::Common::Exception & ex) {
 
6601
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6602
    }
 
6603
    catch (std::out_of_range & ex) {
 
6604
      SWIG_exception(SWIG_IndexError,ex.what());
 
6605
    }
 
6606
    catch (std::exception & ex) {
 
6607
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6608
    }
 
6609
  }
 
6610
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
 
6611
  return resultobj;
 
6612
fail:
 
6613
  return NULL;
 
6614
}
 
6615
 
 
6616
 
 
6617
SWIGINTERN PyObject *_wrap_NonCenteredFiniteDifferenceGradient_getClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6618
  PyObject *resultobj = 0;
 
6619
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) 0 ;
 
6620
  void *argp1 = 0 ;
 
6621
  int res1 = 0 ;
 
6622
  PyObject * obj0 = 0 ;
 
6623
  OT::String *result = 0 ;
 
6624
  
 
6625
  if (!PyArg_ParseTuple(args,(char *)"O:NonCenteredFiniteDifferenceGradient_getClassName",&obj0)) SWIG_fail;
 
6626
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, 0 |  0 );
 
6627
  if (!SWIG_IsOK(res1)) {
 
6628
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonCenteredFiniteDifferenceGradient_getClassName" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *""'"); 
 
6629
  }
 
6630
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient * >(argp1);
 
6631
  {
 
6632
    try {
 
6633
      {
 
6634
        OT::String const &_result_ref = ((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *)arg1)->getClassName();
 
6635
        result = (OT::String *) &_result_ref;
 
6636
      }
 
6637
    }
 
6638
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6639
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6640
    }
 
6641
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6642
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6643
    }
 
6644
    catch (OT::Base::Common::Exception & ex) {
 
6645
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6646
    }
 
6647
    catch (std::out_of_range & ex) {
 
6648
      SWIG_exception(SWIG_IndexError,ex.what());
 
6649
    }
 
6650
    catch (std::exception & ex) {
 
6651
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6652
    }
 
6653
  }
 
6654
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
 
6655
  return resultobj;
 
6656
fail:
 
6657
  return NULL;
 
6658
}
 
6659
 
 
6660
 
 
6661
SWIGINTERN int Swig_var_NonCenteredFiniteDifferenceGradient_DefaultEpsilon_set(PyObject *) {
 
6662
  SWIG_Error(SWIG_AttributeError,"Variable NonCenteredFiniteDifferenceGradient_DefaultEpsilon is read-only.");
 
6663
  return 1;
 
6664
}
 
6665
 
 
6666
 
 
6667
SWIGINTERN PyObject *Swig_var_NonCenteredFiniteDifferenceGradient_DefaultEpsilon_get(void) {
 
6668
  PyObject *pyobj = 0;
 
6669
  
 
6670
  pyobj = SWIG_From_double(static_cast< double >(OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::DefaultEpsilon));
 
6671
  return pyobj;
 
6672
}
 
6673
 
 
6674
 
 
6675
SWIGINTERN PyObject *_wrap_new_NonCenteredFiniteDifferenceGradient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6676
  PyObject *resultobj = 0;
 
6677
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *result = 0 ;
 
6678
  
 
6679
  if (!PyArg_ParseTuple(args,(char *)":new_NonCenteredFiniteDifferenceGradient")) SWIG_fail;
 
6680
  {
 
6681
    try {
 
6682
      result = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *)new OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient();
 
6683
    }
 
6684
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6685
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6686
    }
 
6687
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6688
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6689
    }
 
6690
    catch (OT::Base::Common::Exception & ex) {
 
6691
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6692
    }
 
6693
    catch (std::out_of_range & ex) {
 
6694
      SWIG_exception(SWIG_IndexError,ex.what());
 
6695
    }
 
6696
    catch (std::exception & ex) {
 
6697
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6698
    }
 
6699
  }
 
6700
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, SWIG_POINTER_NEW |  0 );
 
6701
  return resultobj;
 
6702
fail:
 
6703
  return NULL;
 
6704
}
 
6705
 
 
6706
 
 
6707
SWIGINTERN PyObject *_wrap_new_NonCenteredFiniteDifferenceGradient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6708
  PyObject *resultobj = 0;
 
6709
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::NumericalPoint *arg1 = 0 ;
 
6710
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation *arg2 = 0 ;
 
6711
  void *argp1 = 0 ;
 
6712
  int res1 = 0 ;
 
6713
  void *argp2 = 0 ;
 
6714
  int res2 = 0 ;
 
6715
  PyObject * obj0 = 0 ;
 
6716
  PyObject * obj1 = 0 ;
 
6717
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *result = 0 ;
 
6718
  
 
6719
  if (!PyArg_ParseTuple(args,(char *)"OO:new_NonCenteredFiniteDifferenceGradient",&obj0,&obj1)) SWIG_fail;
 
6720
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPoint,  0  | 0);
 
6721
  if (!SWIG_IsOK(res1)) {
 
6722
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NonCenteredFiniteDifferenceGradient" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::NumericalPoint const &""'"); 
 
6723
  }
 
6724
  if (!argp1) {
 
6725
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonCenteredFiniteDifferenceGradient" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::NumericalPoint const &""'"); 
 
6726
  }
 
6727
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::NumericalPoint * >(argp1);
 
6728
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t,  0  | 0);
 
6729
  if (!SWIG_IsOK(res2)) {
 
6730
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NonCenteredFiniteDifferenceGradient" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation const &""'"); 
 
6731
  }
 
6732
  if (!argp2) {
 
6733
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonCenteredFiniteDifferenceGradient" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation const &""'"); 
 
6734
  }
 
6735
  arg2 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation * >(argp2);
 
6736
  {
 
6737
    try {
 
6738
      result = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *)new OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::NumericalPoint const &)*arg1,(OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation const &)*arg2);
 
6739
    }
 
6740
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6741
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6742
    }
 
6743
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6744
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6745
    }
 
6746
    catch (OT::Base::Common::Exception & ex) {
 
6747
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6748
    }
 
6749
    catch (std::out_of_range & ex) {
 
6750
      SWIG_exception(SWIG_IndexError,ex.what());
 
6751
    }
 
6752
    catch (std::exception & ex) {
 
6753
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6754
    }
 
6755
  }
 
6756
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, SWIG_POINTER_NEW |  0 );
 
6757
  return resultobj;
 
6758
fail:
 
6759
  return NULL;
 
6760
}
 
6761
 
 
6762
 
 
6763
SWIGINTERN PyObject *_wrap_new_NonCenteredFiniteDifferenceGradient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6764
  PyObject *resultobj = 0;
 
6765
  OpenTURNS::NumericalScalar arg1 ;
 
6766
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation *arg2 = 0 ;
 
6767
  double val1 ;
 
6768
  int ecode1 = 0 ;
 
6769
  void *argp2 = 0 ;
 
6770
  int res2 = 0 ;
 
6771
  PyObject * obj0 = 0 ;
 
6772
  PyObject * obj1 = 0 ;
 
6773
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *result = 0 ;
 
6774
  
 
6775
  if (!PyArg_ParseTuple(args,(char *)"OO:new_NonCenteredFiniteDifferenceGradient",&obj0,&obj1)) SWIG_fail;
 
6776
  ecode1 = SWIG_AsVal_double(obj0, &val1);
 
6777
  if (!SWIG_IsOK(ecode1)) {
 
6778
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NonCenteredFiniteDifferenceGradient" "', argument " "1"" of type '" "OpenTURNS::NumericalScalar""'");
 
6779
  } 
 
6780
  arg1 = static_cast< OpenTURNS::NumericalScalar >(val1);
 
6781
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t,  0  | 0);
 
6782
  if (!SWIG_IsOK(res2)) {
 
6783
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NonCenteredFiniteDifferenceGradient" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation const &""'"); 
 
6784
  }
 
6785
  if (!argp2) {
 
6786
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonCenteredFiniteDifferenceGradient" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation const &""'"); 
 
6787
  }
 
6788
  arg2 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation * >(argp2);
 
6789
  {
 
6790
    try {
 
6791
      result = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *)new OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient(arg1,(OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation const &)*arg2);
 
6792
    }
 
6793
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6794
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6795
    }
 
6796
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6797
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6798
    }
 
6799
    catch (OT::Base::Common::Exception & ex) {
 
6800
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6801
    }
 
6802
    catch (std::out_of_range & ex) {
 
6803
      SWIG_exception(SWIG_IndexError,ex.what());
 
6804
    }
 
6805
    catch (std::exception & ex) {
 
6806
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6807
    }
 
6808
  }
 
6809
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, SWIG_POINTER_NEW |  0 );
 
6810
  return resultobj;
 
6811
fail:
 
6812
  return NULL;
 
6813
}
 
6814
 
 
6815
 
 
6816
SWIGINTERN PyObject *_wrap_NonCenteredFiniteDifferenceGradient_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6817
  PyObject *resultobj = 0;
 
6818
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) 0 ;
 
6819
  void *argp1 = 0 ;
 
6820
  int res1 = 0 ;
 
6821
  PyObject * obj0 = 0 ;
 
6822
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *result = 0 ;
 
6823
  
 
6824
  if (!PyArg_ParseTuple(args,(char *)"O:NonCenteredFiniteDifferenceGradient_clone",&obj0)) SWIG_fail;
 
6825
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, 0 |  0 );
 
6826
  if (!SWIG_IsOK(res1)) {
 
6827
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonCenteredFiniteDifferenceGradient_clone" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *""'"); 
 
6828
  }
 
6829
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient * >(argp1);
 
6830
  {
 
6831
    try {
 
6832
      result = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *)((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *)arg1)->clone();
 
6833
    }
 
6834
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6835
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6836
    }
 
6837
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6838
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6839
    }
 
6840
    catch (OT::Base::Common::Exception & ex) {
 
6841
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6842
    }
 
6843
    catch (std::out_of_range & ex) {
 
6844
      SWIG_exception(SWIG_IndexError,ex.what());
 
6845
    }
 
6846
    catch (std::exception & ex) {
 
6847
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6848
    }
 
6849
  }
 
6850
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, 0 |  0 );
 
6851
  return resultobj;
 
6852
fail:
 
6853
  return NULL;
 
6854
}
 
6855
 
 
6856
 
 
6857
SWIGINTERN PyObject *_wrap_NonCenteredFiniteDifferenceGradient___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6858
  PyObject *resultobj = 0;
 
6859
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) 0 ;
 
6860
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *arg2 = 0 ;
 
6861
  void *argp1 = 0 ;
 
6862
  int res1 = 0 ;
 
6863
  void *argp2 = 0 ;
 
6864
  int res2 = 0 ;
 
6865
  PyObject * obj0 = 0 ;
 
6866
  PyObject * obj1 = 0 ;
 
6867
  OpenTURNS::Bool result;
 
6868
  
 
6869
  if (!PyArg_ParseTuple(args,(char *)"OO:NonCenteredFiniteDifferenceGradient___eq__",&obj0,&obj1)) SWIG_fail;
 
6870
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, 0 |  0 );
 
6871
  if (!SWIG_IsOK(res1)) {
 
6872
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonCenteredFiniteDifferenceGradient___eq__" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *""'"); 
 
6873
  }
 
6874
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient * >(argp1);
 
6875
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient,  0  | 0);
 
6876
  if (!SWIG_IsOK(res2)) {
 
6877
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonCenteredFiniteDifferenceGradient___eq__" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const &""'"); 
 
6878
  }
 
6879
  if (!argp2) {
 
6880
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonCenteredFiniteDifferenceGradient___eq__" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const &""'"); 
 
6881
  }
 
6882
  arg2 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient * >(argp2);
 
6883
  {
 
6884
    try {
 
6885
      result = (OpenTURNS::Bool)((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *)arg1)->operator ==((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const &)*arg2);
 
6886
    }
 
6887
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6888
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6889
    }
 
6890
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6891
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6892
    }
 
6893
    catch (OT::Base::Common::Exception & ex) {
 
6894
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6895
    }
 
6896
    catch (std::out_of_range & ex) {
 
6897
      SWIG_exception(SWIG_IndexError,ex.what());
 
6898
    }
 
6899
    catch (std::exception & ex) {
 
6900
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6901
    }
 
6902
  }
 
6903
  resultobj = SWIG_From_bool(static_cast< bool >(result));
 
6904
  return resultobj;
 
6905
fail:
 
6906
  return NULL;
 
6907
}
 
6908
 
 
6909
 
 
6910
SWIGINTERN PyObject *_wrap_NonCenteredFiniteDifferenceGradient___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6911
  PyObject *resultobj = 0;
 
6912
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) 0 ;
 
6913
  void *argp1 = 0 ;
 
6914
  int res1 = 0 ;
 
6915
  PyObject * obj0 = 0 ;
 
6916
  OpenTURNS::String result;
 
6917
  
 
6918
  if (!PyArg_ParseTuple(args,(char *)"O:NonCenteredFiniteDifferenceGradient___repr__",&obj0)) SWIG_fail;
 
6919
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, 0 |  0 );
 
6920
  if (!SWIG_IsOK(res1)) {
 
6921
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonCenteredFiniteDifferenceGradient___repr__" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *""'"); 
 
6922
  }
 
6923
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient * >(argp1);
 
6924
  {
 
6925
    try {
 
6926
      result = ((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *)arg1)->__repr__();
 
6927
    }
 
6928
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6929
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6930
    }
 
6931
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6932
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6933
    }
 
6934
    catch (OT::Base::Common::Exception & ex) {
 
6935
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6936
    }
 
6937
    catch (std::out_of_range & ex) {
 
6938
      SWIG_exception(SWIG_IndexError,ex.what());
 
6939
    }
 
6940
    catch (std::exception & ex) {
 
6941
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6942
    }
 
6943
  }
 
6944
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
 
6945
  return resultobj;
 
6946
fail:
 
6947
  return NULL;
 
6948
}
 
6949
 
 
6950
 
 
6951
SWIGINTERN PyObject *_wrap_NonCenteredFiniteDifferenceGradient_gradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6952
  PyObject *resultobj = 0;
 
6953
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) 0 ;
 
6954
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::NumericalPoint *arg2 = 0 ;
 
6955
  void *argp1 = 0 ;
 
6956
  int res1 = 0 ;
 
6957
  void *argp2 = 0 ;
 
6958
  int res2 = 0 ;
 
6959
  PyObject * obj0 = 0 ;
 
6960
  PyObject * obj1 = 0 ;
 
6961
  OpenTURNS::Base::Func::NumericalMathGradientImplementation::Matrix result;
 
6962
  
 
6963
  if (!PyArg_ParseTuple(args,(char *)"OO:NonCenteredFiniteDifferenceGradient_gradient",&obj0,&obj1)) SWIG_fail;
 
6964
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, 0 |  0 );
 
6965
  if (!SWIG_IsOK(res1)) {
 
6966
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonCenteredFiniteDifferenceGradient_gradient" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *""'"); 
 
6967
  }
 
6968
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient * >(argp1);
 
6969
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPoint,  0  | 0);
 
6970
  if (!SWIG_IsOK(res2)) {
 
6971
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonCenteredFiniteDifferenceGradient_gradient" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::NumericalPoint const &""'"); 
 
6972
  }
 
6973
  if (!argp2) {
 
6974
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonCenteredFiniteDifferenceGradient_gradient" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::NumericalPoint const &""'"); 
 
6975
  }
 
6976
  arg2 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::NumericalPoint * >(argp2);
 
6977
  {
 
6978
    try {
 
6979
      result = ((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *)arg1)->gradient((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::NumericalPoint const &)*arg2);
 
6980
    }
 
6981
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
6982
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
6983
    }
 
6984
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
6985
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
6986
    }
 
6987
    catch (OT::Base::Common::Exception & ex) {
 
6988
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
6989
    }
 
6990
    catch (std::out_of_range & ex) {
 
6991
      SWIG_exception(SWIG_IndexError,ex.what());
 
6992
    }
 
6993
    catch (std::exception & ex) {
 
6994
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
6995
    }
 
6996
  }
 
6997
  resultobj = SWIG_NewPointerObj((new OpenTURNS::Base::Func::NumericalMathGradientImplementation::Matrix(static_cast< const OpenTURNS::Base::Func::NumericalMathGradientImplementation::Matrix& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__Matrix, SWIG_POINTER_OWN |  0 );
 
6998
  return resultobj;
 
6999
fail:
 
7000
  return NULL;
 
7001
}
 
7002
 
 
7003
 
 
7004
SWIGINTERN PyObject *_wrap_NonCenteredFiniteDifferenceGradient_getInputDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7005
  PyObject *resultobj = 0;
 
7006
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) 0 ;
 
7007
  void *argp1 = 0 ;
 
7008
  int res1 = 0 ;
 
7009
  PyObject * obj0 = 0 ;
 
7010
  OpenTURNS::UnsignedLong result;
 
7011
  
 
7012
  if (!PyArg_ParseTuple(args,(char *)"O:NonCenteredFiniteDifferenceGradient_getInputDimension",&obj0)) SWIG_fail;
 
7013
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, 0 |  0 );
 
7014
  if (!SWIG_IsOK(res1)) {
 
7015
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonCenteredFiniteDifferenceGradient_getInputDimension" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *""'"); 
 
7016
  }
 
7017
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient * >(argp1);
 
7018
  {
 
7019
    try {
 
7020
      result = (OpenTURNS::UnsignedLong)((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *)arg1)->getInputDimension();
 
7021
    }
 
7022
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
7023
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
7024
    }
 
7025
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
7026
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
7027
    }
 
7028
    catch (OT::Base::Common::Exception & ex) {
 
7029
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
7030
    }
 
7031
    catch (std::out_of_range & ex) {
 
7032
      SWIG_exception(SWIG_IndexError,ex.what());
 
7033
    }
 
7034
    catch (std::exception & ex) {
 
7035
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
7036
    }
 
7037
  }
 
7038
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
 
7039
  return resultobj;
 
7040
fail:
 
7041
  return NULL;
 
7042
}
 
7043
 
 
7044
 
 
7045
SWIGINTERN PyObject *_wrap_NonCenteredFiniteDifferenceGradient_getOutputDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7046
  PyObject *resultobj = 0;
 
7047
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) 0 ;
 
7048
  void *argp1 = 0 ;
 
7049
  int res1 = 0 ;
 
7050
  PyObject * obj0 = 0 ;
 
7051
  OpenTURNS::UnsignedLong result;
 
7052
  
 
7053
  if (!PyArg_ParseTuple(args,(char *)"O:NonCenteredFiniteDifferenceGradient_getOutputDimension",&obj0)) SWIG_fail;
 
7054
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, 0 |  0 );
 
7055
  if (!SWIG_IsOK(res1)) {
 
7056
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonCenteredFiniteDifferenceGradient_getOutputDimension" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *""'"); 
 
7057
  }
 
7058
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient * >(argp1);
 
7059
  {
 
7060
    try {
 
7061
      result = (OpenTURNS::UnsignedLong)((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *)arg1)->getOutputDimension();
 
7062
    }
 
7063
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
7064
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
7065
    }
 
7066
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
7067
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
7068
    }
 
7069
    catch (OT::Base::Common::Exception & ex) {
 
7070
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
7071
    }
 
7072
    catch (std::out_of_range & ex) {
 
7073
      SWIG_exception(SWIG_IndexError,ex.what());
 
7074
    }
 
7075
    catch (std::exception & ex) {
 
7076
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
7077
    }
 
7078
  }
 
7079
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
 
7080
  return resultobj;
 
7081
fail:
 
7082
  return NULL;
 
7083
}
 
7084
 
 
7085
 
 
7086
SWIGINTERN PyObject *_wrap_NonCenteredFiniteDifferenceGradient_getEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7087
  PyObject *resultobj = 0;
 
7088
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) 0 ;
 
7089
  void *argp1 = 0 ;
 
7090
  int res1 = 0 ;
 
7091
  PyObject * obj0 = 0 ;
 
7092
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::NumericalPoint result;
 
7093
  
 
7094
  if (!PyArg_ParseTuple(args,(char *)"O:NonCenteredFiniteDifferenceGradient_getEpsilon",&obj0)) SWIG_fail;
 
7095
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, 0 |  0 );
 
7096
  if (!SWIG_IsOK(res1)) {
 
7097
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonCenteredFiniteDifferenceGradient_getEpsilon" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *""'"); 
 
7098
  }
 
7099
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient * >(argp1);
 
7100
  {
 
7101
    try {
 
7102
      result = ((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *)arg1)->getEpsilon();
 
7103
    }
 
7104
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
7105
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
7106
    }
 
7107
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
7108
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
7109
    }
 
7110
    catch (OT::Base::Common::Exception & ex) {
 
7111
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
7112
    }
 
7113
    catch (std::out_of_range & ex) {
 
7114
      SWIG_exception(SWIG_IndexError,ex.what());
 
7115
    }
 
7116
    catch (std::exception & ex) {
 
7117
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
7118
    }
 
7119
  }
 
7120
  resultobj = SWIG_NewPointerObj((new OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::NumericalPoint(static_cast< const OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::NumericalPoint& >(result))), SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPoint, SWIG_POINTER_OWN |  0 );
 
7121
  return resultobj;
 
7122
fail:
 
7123
  return NULL;
 
7124
}
 
7125
 
 
7126
 
 
7127
SWIGINTERN PyObject *_wrap_NonCenteredFiniteDifferenceGradient_getEvaluation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7128
  PyObject *resultobj = 0;
 
7129
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) 0 ;
 
7130
  void *argp1 = 0 ;
 
7131
  int res1 = 0 ;
 
7132
  PyObject * obj0 = 0 ;
 
7133
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation result;
 
7134
  
 
7135
  if (!PyArg_ParseTuple(args,(char *)"O:NonCenteredFiniteDifferenceGradient_getEvaluation",&obj0)) SWIG_fail;
 
7136
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, 0 |  0 );
 
7137
  if (!SWIG_IsOK(res1)) {
 
7138
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonCenteredFiniteDifferenceGradient_getEvaluation" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *""'"); 
 
7139
  }
 
7140
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient * >(argp1);
 
7141
  {
 
7142
    try {
 
7143
      result = ((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *)arg1)->getEvaluation();
 
7144
    }
 
7145
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
7146
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
7147
    }
 
7148
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
7149
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
7150
    }
 
7151
    catch (OT::Base::Common::Exception & ex) {
 
7152
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
7153
    }
 
7154
    catch (std::out_of_range & ex) {
 
7155
      SWIG_exception(SWIG_IndexError,ex.what());
 
7156
    }
 
7157
    catch (std::exception & ex) {
 
7158
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
7159
    }
 
7160
  }
 
7161
  resultobj = SWIG_NewPointerObj((new OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation(static_cast< const OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation& >(result))), SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t, SWIG_POINTER_OWN |  0 );
 
7162
  return resultobj;
 
7163
fail:
 
7164
  return NULL;
 
7165
}
 
7166
 
 
7167
 
 
7168
SWIGINTERN PyObject *_wrap_NonCenteredFiniteDifferenceGradient_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7169
  PyObject *resultobj = 0;
 
7170
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) 0 ;
 
7171
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::StorageManager::Advocate *arg2 = 0 ;
 
7172
  void *argp1 = 0 ;
 
7173
  int res1 = 0 ;
 
7174
  void *argp2 = 0 ;
 
7175
  int res2 = 0 ;
 
7176
  PyObject * obj0 = 0 ;
 
7177
  PyObject * obj1 = 0 ;
 
7178
  
 
7179
  if (!PyArg_ParseTuple(args,(char *)"OO:NonCenteredFiniteDifferenceGradient_save",&obj0,&obj1)) SWIG_fail;
 
7180
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, 0 |  0 );
 
7181
  if (!SWIG_IsOK(res1)) {
 
7182
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonCenteredFiniteDifferenceGradient_save" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *""'"); 
 
7183
  }
 
7184
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient * >(argp1);
 
7185
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_OpenTURNS__Advocate,  0 );
 
7186
  if (!SWIG_IsOK(res2)) {
 
7187
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonCenteredFiniteDifferenceGradient_save" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::StorageManager::Advocate &""'"); 
 
7188
  }
 
7189
  if (!argp2) {
 
7190
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonCenteredFiniteDifferenceGradient_save" "', argument " "2"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::StorageManager::Advocate &""'"); 
 
7191
  }
 
7192
  arg2 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::StorageManager::Advocate * >(argp2);
 
7193
  {
 
7194
    try {
 
7195
      ((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const *)arg1)->save(*arg2);
 
7196
    }
 
7197
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
7198
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
7199
    }
 
7200
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
7201
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
7202
    }
 
7203
    catch (OT::Base::Common::Exception & ex) {
 
7204
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
7205
    }
 
7206
    catch (std::out_of_range & ex) {
 
7207
      SWIG_exception(SWIG_IndexError,ex.what());
 
7208
    }
 
7209
    catch (std::exception & ex) {
 
7210
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
7211
    }
 
7212
  }
 
7213
  resultobj = SWIG_Py_Void();
 
7214
  return resultobj;
 
7215
fail:
 
7216
  return NULL;
 
7217
}
 
7218
 
 
7219
 
 
7220
SWIGINTERN PyObject *_wrap_new_NonCenteredFiniteDifferenceGradient__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7221
  PyObject *resultobj = 0;
 
7222
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *arg1 = 0 ;
 
7223
  void *argp1 = 0 ;
 
7224
  int res1 = 0 ;
 
7225
  PyObject * obj0 = 0 ;
 
7226
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *result = 0 ;
 
7227
  
 
7228
  if (!PyArg_ParseTuple(args,(char *)"O:new_NonCenteredFiniteDifferenceGradient",&obj0)) SWIG_fail;
 
7229
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient,  0  | 0);
 
7230
  if (!SWIG_IsOK(res1)) {
 
7231
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NonCenteredFiniteDifferenceGradient" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const &""'"); 
 
7232
  }
 
7233
  if (!argp1) {
 
7234
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonCenteredFiniteDifferenceGradient" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const &""'"); 
 
7235
  }
 
7236
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient * >(argp1);
 
7237
  {
 
7238
    try {
 
7239
      result = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *)new_OpenTURNS_Base_Diff_NonCenteredFiniteDifferenceGradient__SWIG_3((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const &)*arg1);
 
7240
    }
 
7241
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
7242
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
7243
    }
 
7244
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
7245
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
7246
    }
 
7247
    catch (OT::Base::Common::Exception & ex) {
 
7248
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
7249
    }
 
7250
    catch (std::out_of_range & ex) {
 
7251
      SWIG_exception(SWIG_IndexError,ex.what());
 
7252
    }
 
7253
    catch (std::exception & ex) {
 
7254
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
7255
    }
 
7256
  }
 
7257
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, SWIG_POINTER_NEW |  0 );
 
7258
  return resultobj;
 
7259
fail:
 
7260
  return NULL;
 
7261
}
 
7262
 
 
7263
 
 
7264
SWIGINTERN PyObject *_wrap_new_NonCenteredFiniteDifferenceGradient(PyObject *self, PyObject *args) {
 
7265
  int argc;
 
7266
  PyObject *argv[3];
 
7267
  int ii;
 
7268
  
 
7269
  if (!PyTuple_Check(args)) SWIG_fail;
 
7270
  argc = (int)PyObject_Length(args);
 
7271
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
 
7272
    argv[ii] = PyTuple_GET_ITEM(args,ii);
 
7273
  }
 
7274
  if (argc == 0) {
 
7275
    return _wrap_new_NonCenteredFiniteDifferenceGradient__SWIG_0(self, args);
 
7276
  }
 
7277
  if (argc == 1) {
 
7278
    int _v;
 
7279
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, 0);
 
7280
    _v = SWIG_CheckState(res);
 
7281
    if (_v) {
 
7282
      return _wrap_new_NonCenteredFiniteDifferenceGradient__SWIG_3(self, args);
 
7283
    }
 
7284
  }
 
7285
  if (argc == 2) {
 
7286
    int _v;
 
7287
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_OpenTURNS__Base__Type__NumericalPoint, 0);
 
7288
    _v = SWIG_CheckState(res);
 
7289
    if (_v) {
 
7290
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t, 0);
 
7291
      _v = SWIG_CheckState(res);
 
7292
      if (_v) {
 
7293
        return _wrap_new_NonCenteredFiniteDifferenceGradient__SWIG_1(self, args);
 
7294
      }
 
7295
    }
 
7296
  }
 
7297
  if (argc == 2) {
 
7298
    int _v;
 
7299
    {
 
7300
      int res = SWIG_AsVal_double(argv[0], NULL);
 
7301
      _v = SWIG_CheckState(res);
 
7302
    }
 
7303
    if (_v) {
 
7304
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t, 0);
 
7305
      _v = SWIG_CheckState(res);
 
7306
      if (_v) {
 
7307
        return _wrap_new_NonCenteredFiniteDifferenceGradient__SWIG_2(self, args);
 
7308
      }
 
7309
    }
 
7310
  }
 
7311
  
 
7312
fail:
 
7313
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NonCenteredFiniteDifferenceGradient'.\n"
 
7314
    "  Possible C/C++ prototypes are:\n"
 
7315
    "    OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient()\n"
 
7316
    "    OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient(OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::NumericalPoint const &,OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation const &)\n"
 
7317
    "    OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient(OpenTURNS::NumericalScalar const,OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation const &)\n"
 
7318
    "    OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient(OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient const &)\n");
 
7319
  return NULL;
 
7320
}
 
7321
 
 
7322
 
 
7323
SWIGINTERN PyObject *_wrap_delete_NonCenteredFiniteDifferenceGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7324
  PyObject *resultobj = 0;
 
7325
  OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *arg1 = (OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) 0 ;
 
7326
  void *argp1 = 0 ;
 
7327
  int res1 = 0 ;
 
7328
  PyObject * obj0 = 0 ;
 
7329
  
 
7330
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NonCenteredFiniteDifferenceGradient",&obj0)) SWIG_fail;
 
7331
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, SWIG_POINTER_DISOWN |  0 );
 
7332
  if (!SWIG_IsOK(res1)) {
 
7333
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NonCenteredFiniteDifferenceGradient" "', argument " "1"" of type '" "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *""'"); 
 
7334
  }
 
7335
  arg1 = reinterpret_cast< OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient * >(argp1);
 
7336
  {
 
7337
    try {
 
7338
      delete arg1;
 
7339
    }
 
7340
    catch (OT::Base::Common::InvalidArgumentException & ex) {
 
7341
      SWIG_exception(SWIG_TypeError,ex.__repr__().c_str());
 
7342
    }
 
7343
    catch (OT::Base::Common::OutOfBoundException & ex) {
 
7344
      SWIG_exception(SWIG_IndexError,ex.__repr__().c_str());
 
7345
    }
 
7346
    catch (OT::Base::Common::Exception & ex) {
 
7347
      SWIG_exception(SWIG_RuntimeError,ex.__repr__().c_str());
 
7348
    }
 
7349
    catch (std::out_of_range & ex) {
 
7350
      SWIG_exception(SWIG_IndexError,ex.what());
 
7351
    }
 
7352
    catch (std::exception & ex) {
 
7353
      SWIG_exception(SWIG_RuntimeError,ex.what());
 
7354
    }
 
7355
  }
 
7356
  resultobj = SWIG_Py_Void();
 
7357
  return resultobj;
 
7358
fail:
 
7359
  return NULL;
 
7360
}
 
7361
 
 
7362
 
 
7363
SWIGINTERN PyObject *NonCenteredFiniteDifferenceGradient_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7364
  PyObject *obj;
 
7365
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
 
7366
  SWIG_TypeNewClientData(SWIGTYPE_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, SWIG_NewClientData(obj));
 
7367
  return SWIG_Py_Void();
 
7368
}
 
7369
 
 
7370
static PyMethodDef SwigMethods[] = {
 
7371
         { (char *)"delete_PySwigIterator", _wrap_delete_PySwigIterator, METH_VARARGS, (char *)"delete_PySwigIterator(PySwigIterator self)"},
 
7372
         { (char *)"PySwigIterator_value", _wrap_PySwigIterator_value, METH_VARARGS, (char *)"PySwigIterator_value(PySwigIterator self) -> PyObject"},
 
7373
         { (char *)"PySwigIterator_incr", _wrap_PySwigIterator_incr, METH_VARARGS, (char *)"\n"
 
7374
                "incr(size_t n=1) -> PySwigIterator\n"
 
7375
                "PySwigIterator_incr(PySwigIterator self) -> PySwigIterator\n"
 
7376
                ""},
 
7377
         { (char *)"PySwigIterator_decr", _wrap_PySwigIterator_decr, METH_VARARGS, (char *)"\n"
 
7378
                "decr(size_t n=1) -> PySwigIterator\n"
 
7379
                "PySwigIterator_decr(PySwigIterator self) -> PySwigIterator\n"
 
7380
                ""},
 
7381
         { (char *)"PySwigIterator_distance", _wrap_PySwigIterator_distance, METH_VARARGS, (char *)"PySwigIterator_distance(PySwigIterator self, PySwigIterator x) -> ptrdiff_t"},
 
7382
         { (char *)"PySwigIterator_equal", _wrap_PySwigIterator_equal, METH_VARARGS, (char *)"PySwigIterator_equal(PySwigIterator self, PySwigIterator x) -> bool"},
 
7383
         { (char *)"PySwigIterator_copy", _wrap_PySwigIterator_copy, METH_VARARGS, (char *)"PySwigIterator_copy(PySwigIterator self) -> PySwigIterator"},
 
7384
         { (char *)"PySwigIterator_next", _wrap_PySwigIterator_next, METH_VARARGS, (char *)"PySwigIterator_next(PySwigIterator self) -> PyObject"},
 
7385
         { (char *)"PySwigIterator_previous", _wrap_PySwigIterator_previous, METH_VARARGS, (char *)"PySwigIterator_previous(PySwigIterator self) -> PyObject"},
 
7386
         { (char *)"PySwigIterator_advance", _wrap_PySwigIterator_advance, METH_VARARGS, (char *)"PySwigIterator_advance(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
 
7387
         { (char *)"PySwigIterator___eq__", _wrap_PySwigIterator___eq__, METH_VARARGS, (char *)"PySwigIterator___eq__(PySwigIterator self, PySwigIterator x) -> bool"},
 
7388
         { (char *)"PySwigIterator___ne__", _wrap_PySwigIterator___ne__, METH_VARARGS, (char *)"PySwigIterator___ne__(PySwigIterator self, PySwigIterator x) -> bool"},
 
7389
         { (char *)"PySwigIterator___iadd__", _wrap_PySwigIterator___iadd__, METH_VARARGS, (char *)"PySwigIterator___iadd__(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
 
7390
         { (char *)"PySwigIterator___isub__", _wrap_PySwigIterator___isub__, METH_VARARGS, (char *)"PySwigIterator___isub__(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
 
7391
         { (char *)"PySwigIterator___add__", _wrap_PySwigIterator___add__, METH_VARARGS, (char *)"PySwigIterator___add__(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
 
7392
         { (char *)"PySwigIterator___sub__", _wrap_PySwigIterator___sub__, METH_VARARGS, (char *)"\n"
 
7393
                "__sub__(ptrdiff_t n) -> PySwigIterator\n"
 
7394
                "PySwigIterator___sub__(PySwigIterator self, PySwigIterator x) -> ptrdiff_t\n"
 
7395
                ""},
 
7396
         { (char *)"PySwigIterator_swigregister", PySwigIterator_swigregister, METH_VARARGS, NULL},
 
7397
         { (char *)"CenteredFiniteDifferenceGradient_GetClassName", _wrap_CenteredFiniteDifferenceGradient_GetClassName, METH_VARARGS, (char *)"CenteredFiniteDifferenceGradient_GetClassName() -> String"},
 
7398
         { (char *)"CenteredFiniteDifferenceGradient_getClassName", _wrap_CenteredFiniteDifferenceGradient_getClassName, METH_VARARGS, (char *)"CenteredFiniteDifferenceGradient_getClassName(CenteredFiniteDifferenceGradient self) -> String"},
 
7399
         { (char *)"CenteredFiniteDifferenceGradient_clone", _wrap_CenteredFiniteDifferenceGradient_clone, METH_VARARGS, (char *)"CenteredFiniteDifferenceGradient_clone(CenteredFiniteDifferenceGradient self) -> CenteredFiniteDifferenceGradient"},
 
7400
         { (char *)"CenteredFiniteDifferenceGradient___eq__", _wrap_CenteredFiniteDifferenceGradient___eq__, METH_VARARGS, (char *)"CenteredFiniteDifferenceGradient___eq__(CenteredFiniteDifferenceGradient self, CenteredFiniteDifferenceGradient other) -> Bool"},
 
7401
         { (char *)"CenteredFiniteDifferenceGradient___repr__", _wrap_CenteredFiniteDifferenceGradient___repr__, METH_VARARGS, (char *)"CenteredFiniteDifferenceGradient___repr__(CenteredFiniteDifferenceGradient self) -> String"},
 
7402
         { (char *)"CenteredFiniteDifferenceGradient_gradient", _wrap_CenteredFiniteDifferenceGradient_gradient, METH_VARARGS, (char *)"CenteredFiniteDifferenceGradient_gradient(CenteredFiniteDifferenceGradient self, NumericalPoint in) -> Matrix"},
 
7403
         { (char *)"CenteredFiniteDifferenceGradient_getInputDimension", _wrap_CenteredFiniteDifferenceGradient_getInputDimension, METH_VARARGS, (char *)"CenteredFiniteDifferenceGradient_getInputDimension(CenteredFiniteDifferenceGradient self) -> UnsignedLong"},
 
7404
         { (char *)"CenteredFiniteDifferenceGradient_getOutputDimension", _wrap_CenteredFiniteDifferenceGradient_getOutputDimension, METH_VARARGS, (char *)"CenteredFiniteDifferenceGradient_getOutputDimension(CenteredFiniteDifferenceGradient self) -> UnsignedLong"},
 
7405
         { (char *)"CenteredFiniteDifferenceGradient_getEpsilon", _wrap_CenteredFiniteDifferenceGradient_getEpsilon, METH_VARARGS, (char *)"CenteredFiniteDifferenceGradient_getEpsilon(CenteredFiniteDifferenceGradient self) -> NumericalPoint"},
 
7406
         { (char *)"CenteredFiniteDifferenceGradient_getEvaluation", _wrap_CenteredFiniteDifferenceGradient_getEvaluation, METH_VARARGS, (char *)"CenteredFiniteDifferenceGradient_getEvaluation(CenteredFiniteDifferenceGradient self) -> EvaluationImplementation"},
 
7407
         { (char *)"CenteredFiniteDifferenceGradient_save", _wrap_CenteredFiniteDifferenceGradient_save, METH_VARARGS, (char *)"CenteredFiniteDifferenceGradient_save(CenteredFiniteDifferenceGradient self, OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::StorageManager::Advocate adv)"},
 
7408
         { (char *)"new_CenteredFiniteDifferenceGradient", _wrap_new_CenteredFiniteDifferenceGradient, METH_VARARGS, (char *)"\n"
 
7409
                "CenteredFiniteDifferenceGradient()\n"
 
7410
                "CenteredFiniteDifferenceGradient(NumericalPoint epsilon, EvaluationImplementation p_evaluation)\n"
 
7411
                "CenteredFiniteDifferenceGradient(NumericalScalar epsilon, EvaluationImplementation p_evaluation)\n"
 
7412
                "new_CenteredFiniteDifferenceGradient(CenteredFiniteDifferenceGradient other) -> CenteredFiniteDifferenceGradient\n"
 
7413
                ""},
 
7414
         { (char *)"delete_CenteredFiniteDifferenceGradient", _wrap_delete_CenteredFiniteDifferenceGradient, METH_VARARGS, (char *)"delete_CenteredFiniteDifferenceGradient(CenteredFiniteDifferenceGradient self)"},
 
7415
         { (char *)"CenteredFiniteDifferenceGradient_swigregister", CenteredFiniteDifferenceGradient_swigregister, METH_VARARGS, NULL},
 
7416
         { (char *)"CenteredFiniteDifferenceHessian_GetClassName", _wrap_CenteredFiniteDifferenceHessian_GetClassName, METH_VARARGS, (char *)"CenteredFiniteDifferenceHessian_GetClassName() -> String"},
 
7417
         { (char *)"CenteredFiniteDifferenceHessian_getClassName", _wrap_CenteredFiniteDifferenceHessian_getClassName, METH_VARARGS, (char *)"CenteredFiniteDifferenceHessian_getClassName(CenteredFiniteDifferenceHessian self) -> String"},
 
7418
         { (char *)"CenteredFiniteDifferenceHessian_clone", _wrap_CenteredFiniteDifferenceHessian_clone, METH_VARARGS, (char *)"CenteredFiniteDifferenceHessian_clone(CenteredFiniteDifferenceHessian self) -> CenteredFiniteDifferenceHessian"},
 
7419
         { (char *)"CenteredFiniteDifferenceHessian___eq__", _wrap_CenteredFiniteDifferenceHessian___eq__, METH_VARARGS, (char *)"CenteredFiniteDifferenceHessian___eq__(CenteredFiniteDifferenceHessian self, CenteredFiniteDifferenceHessian other) -> Bool"},
 
7420
         { (char *)"CenteredFiniteDifferenceHessian___repr__", _wrap_CenteredFiniteDifferenceHessian___repr__, METH_VARARGS, (char *)"CenteredFiniteDifferenceHessian___repr__(CenteredFiniteDifferenceHessian self) -> String"},
 
7421
         { (char *)"CenteredFiniteDifferenceHessian_hessian", _wrap_CenteredFiniteDifferenceHessian_hessian, METH_VARARGS, (char *)"CenteredFiniteDifferenceHessian_hessian(CenteredFiniteDifferenceHessian self, NumericalPoint in) -> SymmetricTensor"},
 
7422
         { (char *)"CenteredFiniteDifferenceHessian_getInputDimension", _wrap_CenteredFiniteDifferenceHessian_getInputDimension, METH_VARARGS, (char *)"CenteredFiniteDifferenceHessian_getInputDimension(CenteredFiniteDifferenceHessian self) -> UnsignedLong"},
 
7423
         { (char *)"CenteredFiniteDifferenceHessian_getOutputDimension", _wrap_CenteredFiniteDifferenceHessian_getOutputDimension, METH_VARARGS, (char *)"CenteredFiniteDifferenceHessian_getOutputDimension(CenteredFiniteDifferenceHessian self) -> UnsignedLong"},
 
7424
         { (char *)"CenteredFiniteDifferenceHessian_getEpsilon", _wrap_CenteredFiniteDifferenceHessian_getEpsilon, METH_VARARGS, (char *)"CenteredFiniteDifferenceHessian_getEpsilon(CenteredFiniteDifferenceHessian self) -> NumericalPoint"},
 
7425
         { (char *)"CenteredFiniteDifferenceHessian_getEvaluation", _wrap_CenteredFiniteDifferenceHessian_getEvaluation, METH_VARARGS, (char *)"CenteredFiniteDifferenceHessian_getEvaluation(CenteredFiniteDifferenceHessian self) -> EvaluationImplementation"},
 
7426
         { (char *)"CenteredFiniteDifferenceHessian_save", _wrap_CenteredFiniteDifferenceHessian_save, METH_VARARGS, (char *)"CenteredFiniteDifferenceHessian_save(CenteredFiniteDifferenceHessian self, OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::StorageManager::Advocate adv)"},
 
7427
         { (char *)"new_CenteredFiniteDifferenceHessian", _wrap_new_CenteredFiniteDifferenceHessian, METH_VARARGS, (char *)"\n"
 
7428
                "CenteredFiniteDifferenceHessian()\n"
 
7429
                "CenteredFiniteDifferenceHessian(NumericalPoint epsilon, EvaluationImplementation p_evaluation)\n"
 
7430
                "CenteredFiniteDifferenceHessian(NumericalScalar epsilon, EvaluationImplementation p_evaluation)\n"
 
7431
                "new_CenteredFiniteDifferenceHessian(CenteredFiniteDifferenceHessian other) -> CenteredFiniteDifferenceHessian\n"
 
7432
                ""},
 
7433
         { (char *)"delete_CenteredFiniteDifferenceHessian", _wrap_delete_CenteredFiniteDifferenceHessian, METH_VARARGS, (char *)"delete_CenteredFiniteDifferenceHessian(CenteredFiniteDifferenceHessian self)"},
 
7434
         { (char *)"CenteredFiniteDifferenceHessian_swigregister", CenteredFiniteDifferenceHessian_swigregister, METH_VARARGS, NULL},
 
7435
         { (char *)"NonCenteredFiniteDifferenceGradient_GetClassName", _wrap_NonCenteredFiniteDifferenceGradient_GetClassName, METH_VARARGS, (char *)"NonCenteredFiniteDifferenceGradient_GetClassName() -> String"},
 
7436
         { (char *)"NonCenteredFiniteDifferenceGradient_getClassName", _wrap_NonCenteredFiniteDifferenceGradient_getClassName, METH_VARARGS, (char *)"NonCenteredFiniteDifferenceGradient_getClassName(NonCenteredFiniteDifferenceGradient self) -> String"},
 
7437
         { (char *)"NonCenteredFiniteDifferenceGradient_clone", _wrap_NonCenteredFiniteDifferenceGradient_clone, METH_VARARGS, (char *)"NonCenteredFiniteDifferenceGradient_clone(NonCenteredFiniteDifferenceGradient self) -> NonCenteredFiniteDifferenceGradient"},
 
7438
         { (char *)"NonCenteredFiniteDifferenceGradient___eq__", _wrap_NonCenteredFiniteDifferenceGradient___eq__, METH_VARARGS, (char *)"NonCenteredFiniteDifferenceGradient___eq__(NonCenteredFiniteDifferenceGradient self, NonCenteredFiniteDifferenceGradient other) -> Bool"},
 
7439
         { (char *)"NonCenteredFiniteDifferenceGradient___repr__", _wrap_NonCenteredFiniteDifferenceGradient___repr__, METH_VARARGS, (char *)"NonCenteredFiniteDifferenceGradient___repr__(NonCenteredFiniteDifferenceGradient self) -> String"},
 
7440
         { (char *)"NonCenteredFiniteDifferenceGradient_gradient", _wrap_NonCenteredFiniteDifferenceGradient_gradient, METH_VARARGS, (char *)"NonCenteredFiniteDifferenceGradient_gradient(NonCenteredFiniteDifferenceGradient self, NumericalPoint in) -> Matrix"},
 
7441
         { (char *)"NonCenteredFiniteDifferenceGradient_getInputDimension", _wrap_NonCenteredFiniteDifferenceGradient_getInputDimension, METH_VARARGS, (char *)"NonCenteredFiniteDifferenceGradient_getInputDimension(NonCenteredFiniteDifferenceGradient self) -> UnsignedLong"},
 
7442
         { (char *)"NonCenteredFiniteDifferenceGradient_getOutputDimension", _wrap_NonCenteredFiniteDifferenceGradient_getOutputDimension, METH_VARARGS, (char *)"NonCenteredFiniteDifferenceGradient_getOutputDimension(NonCenteredFiniteDifferenceGradient self) -> UnsignedLong"},
 
7443
         { (char *)"NonCenteredFiniteDifferenceGradient_getEpsilon", _wrap_NonCenteredFiniteDifferenceGradient_getEpsilon, METH_VARARGS, (char *)"NonCenteredFiniteDifferenceGradient_getEpsilon(NonCenteredFiniteDifferenceGradient self) -> NumericalPoint"},
 
7444
         { (char *)"NonCenteredFiniteDifferenceGradient_getEvaluation", _wrap_NonCenteredFiniteDifferenceGradient_getEvaluation, METH_VARARGS, (char *)"NonCenteredFiniteDifferenceGradient_getEvaluation(NonCenteredFiniteDifferenceGradient self) -> EvaluationImplementation"},
 
7445
         { (char *)"NonCenteredFiniteDifferenceGradient_save", _wrap_NonCenteredFiniteDifferenceGradient_save, METH_VARARGS, (char *)"NonCenteredFiniteDifferenceGradient_save(NonCenteredFiniteDifferenceGradient self, OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::StorageManager::Advocate adv)"},
 
7446
         { (char *)"new_NonCenteredFiniteDifferenceGradient", _wrap_new_NonCenteredFiniteDifferenceGradient, METH_VARARGS, (char *)"\n"
 
7447
                "NonCenteredFiniteDifferenceGradient()\n"
 
7448
                "NonCenteredFiniteDifferenceGradient(NumericalPoint epsilon, EvaluationImplementation p_evaluation)\n"
 
7449
                "NonCenteredFiniteDifferenceGradient(NumericalScalar epsilon, EvaluationImplementation p_evaluation)\n"
 
7450
                "new_NonCenteredFiniteDifferenceGradient(NonCenteredFiniteDifferenceGradient other) -> NonCenteredFiniteDifferenceGradient\n"
 
7451
                ""},
 
7452
         { (char *)"delete_NonCenteredFiniteDifferenceGradient", _wrap_delete_NonCenteredFiniteDifferenceGradient, METH_VARARGS, (char *)"delete_NonCenteredFiniteDifferenceGradient(NonCenteredFiniteDifferenceGradient self)"},
 
7453
         { (char *)"NonCenteredFiniteDifferenceGradient_swigregister", NonCenteredFiniteDifferenceGradient_swigregister, METH_VARARGS, NULL},
 
7454
         { NULL, NULL, 0, NULL }
 
7455
};
 
7456
 
 
7457
 
 
7458
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
7459
 
 
7460
static void *_p_OpenTURNS__Base__Type__NumericalPointWithDescriptionTo_p_OpenTURNS__Base__Type__NumericalPoint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7461
    return (void *)((OpenTURNS::Base::Type::NumericalPoint *)  ((OpenTURNS::Base::Type::NumericalPointWithDescription *) x));
 
7462
}
 
7463
static void *_p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7464
    return (void *)((OpenTURNS::Base::Func::NumericalMathGradientImplementation *)  ((OpenTURNS::Base::Func::ConstantNumericalMathGradientImplementation *) x));
 
7465
}
 
7466
static void *_p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7467
    return (void *)((OpenTURNS::Base::Func::NumericalMathGradientImplementation *)  ((OpenTURNS::Base::Func::ComputedNumericalMathGradientImplementation *) x));
 
7468
}
 
7469
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7470
    return (void *)((OpenTURNS::Base::Func::NumericalMathGradientImplementation *)  ((OpenTURNS::Base::Func::ComposedNumericalMathGradientImplementation *) x));
 
7471
}
 
7472
static void *_p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7473
    return (void *)((OpenTURNS::Base::Func::NumericalMathGradientImplementation *)  ((OpenTURNS::Base::Func::NoNumericalMathGradientImplementation *) x));
 
7474
}
 
7475
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7476
    return (void *)((OpenTURNS::Base::Func::NumericalMathGradientImplementation *)  ((OpenTURNS::Base::Func::ProductNumericalMathGradientImplementation *) x));
 
7477
}
 
7478
static void *_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7479
    return (void *)((OpenTURNS::Base::Func::NumericalMathGradientImplementation *)  ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) x));
 
7480
}
 
7481
static void *_p_OpenTURNS__Base__Func__LinearCombinationGradientImplementationTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7482
    return (void *)((OpenTURNS::Base::Func::NumericalMathGradientImplementation *)  ((OpenTURNS::Base::Func::LinearCombinationGradientImplementation *) x));
 
7483
}
 
7484
static void *_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7485
    return (void *)((OpenTURNS::Base::Func::NumericalMathGradientImplementation *)  ((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) x));
 
7486
}
 
7487
static void *_p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7488
    return (void *)((OpenTURNS::Base::Func::NumericalMathGradientImplementation *)  ((OpenTURNS::Base::Func::LinearNumericalMathGradientImplementation *) x));
 
7489
}
 
7490
static void *_p_OpenTURNS__Base__Stat__CorrelationMatrixTo_p_OpenTURNS__Base__Type__Matrix(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7491
    return (void *)((OpenTURNS::Base::Type::Matrix *) (OpenTURNS::Base::Type::SquareMatrix *)(OpenTURNS::Base::Type::SymmetricMatrix *)(OpenTURNS::Base::Stat::CovarianceMatrix *) ((OpenTURNS::Base::Stat::CorrelationMatrix *) x));
 
7492
}
 
7493
static void *_p_OpenTURNS__Base__Type__SquareMatrixTo_p_OpenTURNS__Base__Type__Matrix(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7494
    return (void *)((OpenTURNS::Base::Type::Matrix *)  ((OpenTURNS::Base::Type::SquareMatrix *) x));
 
7495
}
 
7496
static void *_p_OpenTURNS__Base__Type__SymmetricMatrixTo_p_OpenTURNS__Base__Type__Matrix(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7497
    return (void *)((OpenTURNS::Base::Type::Matrix *) (OpenTURNS::Base::Type::SquareMatrix *) ((OpenTURNS::Base::Type::SymmetricMatrix *) x));
 
7498
}
 
7499
static void *_p_OpenTURNS__Base__Stat__CovarianceMatrixTo_p_OpenTURNS__Base__Type__Matrix(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7500
    return (void *)((OpenTURNS::Base::Type::Matrix *) (OpenTURNS::Base::Type::SquareMatrix *)(OpenTURNS::Base::Type::SymmetricMatrix *) ((OpenTURNS::Base::Stat::CovarianceMatrix *) x));
 
7501
}
 
7502
static void *_p_OpenTURNS__Base__Type__IdentityMatrixTo_p_OpenTURNS__Base__Type__Matrix(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7503
    return (void *)((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));
 
7504
}
 
7505
static void *_p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7506
    return (void *)((OpenTURNS::Base::Func::NumericalMathHessianImplementation *)  ((OpenTURNS::Base::Func::ConstantNumericalMathHessianImplementation *) x));
 
7507
}
 
7508
static void *_p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7509
    return (void *)((OpenTURNS::Base::Func::NumericalMathHessianImplementation *)  ((OpenTURNS::Base::Func::ComputedNumericalMathHessianImplementation *) x));
 
7510
}
 
7511
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7512
    return (void *)((OpenTURNS::Base::Func::NumericalMathHessianImplementation *)  ((OpenTURNS::Base::Func::ComposedNumericalMathHessianImplementation *) x));
 
7513
}
 
7514
static void *_p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7515
    return (void *)((OpenTURNS::Base::Func::NumericalMathHessianImplementation *)  ((OpenTURNS::Base::Func::NoNumericalMathHessianImplementation *) x));
 
7516
}
 
7517
static void *_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessianTo_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7518
    return (void *)((OpenTURNS::Base::Func::NumericalMathHessianImplementation *)  ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) x));
 
7519
}
 
7520
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7521
    return (void *)((OpenTURNS::Base::Func::NumericalMathHessianImplementation *)  ((OpenTURNS::Base::Func::ProductNumericalMathHessianImplementation *) x));
 
7522
}
 
7523
static void *_p_OpenTURNS__Base__Func__LinearCombinationHessianImplementationTo_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7524
    return (void *)((OpenTURNS::Base::Func::NumericalMathHessianImplementation *)  ((OpenTURNS::Base::Func::LinearCombinationHessianImplementation *) x));
 
7525
}
 
7526
static void *_p_OpenTURNS__Base__Common__ComparisonOperatorTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7527
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Common::ComparisonOperatorImplementation > *) ((OpenTURNS::Base::Common::ComparisonOperator *) x));
 
7528
}
 
7529
static void *_p_OpenTURNS__Base__Type__NumericalPointTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7530
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::NumericalScalar > *) ((OpenTURNS::Base::Type::NumericalPoint *) x));
 
7531
}
 
7532
static void *_p_OpenTURNS__Base__Func__WrapperDataVariableTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7533
    return (void *)((OpenTURNS::Base::Common::Object *)  ((OpenTURNS::Base::Func::WrapperDataVariable *) x));
 
7534
}
 
7535
static void *_p_OpenTURNS__Base__Type__TensorImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7536
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::NumericalScalar > *) ((OpenTURNS::Base::Type::TensorImplementation *) x));
 
7537
}
 
7538
static void *_p_OpenTURNS__Base__Type__DescriptionImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7539
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::String > *) ((OpenTURNS::Base::Type::DescriptionImplementation *) x));
 
7540
}
 
7541
static void *_p_OpenTURNS__Base__Type__MatrixImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7542
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::NumericalScalar > *) ((OpenTURNS::Base::Type::MatrixImplementation *) x));
 
7543
}
 
7544
static void *_p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7545
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::LinearNumericalMathEvaluationImplementation *) x));
 
7546
}
 
7547
static void *_p_OpenTURNS__Base__Stat__LastTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7548
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Last *) x));
 
7549
}
 
7550
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathFunctionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7551
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathFunctionImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathFunction *) x));
 
7552
}
 
7553
static void *_p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7554
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) x));
 
7555
}
 
7556
static void *_p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7557
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::NoNumericalMathGradientImplementation *) x));
 
7558
}
 
7559
static void *_p_OpenTURNS__Base__Stat__TestResultTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7560
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::TestResult *) x));
 
7561
}
 
7562
static void *_p_OpenTURNS__Base__Common__GreaterTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7563
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::Greater *) x));
 
7564
}
 
7565
static void *_p_OpenTURNS__Base__Stat__CorrelationMatrixTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7566
    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));
 
7567
}
 
7568
static void *_p_OpenTURNS__Base__Type__MatrixTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7569
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::MatrixImplementation > *) ((OpenTURNS::Base::Type::Matrix *) x));
 
7570
}
 
7571
static void *_p_OpenTURNS__Base__Common__EqualTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7572
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::Equal *) x));
 
7573
}
 
7574
static void *_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessianTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7575
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) x));
 
7576
}
 
7577
static void *_p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7578
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::LinearNumericalMathGradientImplementation *) x));
 
7579
}
 
7580
static void *_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7581
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) x));
 
7582
}
 
7583
static void *_p_OpenTURNS__Base__Func__NumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7584
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::NumericalMathGradientImplementation *) x));
 
7585
}
 
7586
static void *_p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7587
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ConstantNumericalMathHessianImplementation *) x));
 
7588
}
 
7589
static void *_p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7590
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ComputedNumericalMathEvaluationImplementation *) x));
 
7591
}
 
7592
static void *_p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7593
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ComputedNumericalMathHessianImplementation *) x));
 
7594
}
 
7595
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7596
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathEvaluationImplementation *) x));
 
7597
}
 
7598
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7599
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathHessianImplementation *) x));
 
7600
}
 
7601
static void *_p_OpenTURNS__Base__Func__NumericalMathFunctionImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7602
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::NumericalMathFunctionImplementation *) x));
 
7603
}
 
7604
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7605
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathEvaluationImplementation *) x));
 
7606
}
 
7607
static void *_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7608
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) x));
 
7609
}
 
7610
static void *_p_OpenTURNS__Base__Common__LessOrEqualTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7611
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::LessOrEqual *) x));
 
7612
}
 
7613
static void *_p_OpenTURNS__Base__Common__GreaterOrEqualTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7614
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::GreaterOrEqual *) x));
 
7615
}
 
7616
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7617
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< std::string > *) x));
 
7618
}
 
7619
static void *_p_OpenTURNS__Base__Type__NumericalPointWithDescriptionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7620
    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));
 
7621
}
 
7622
static void *_p_OpenTURNS__Base__Common__InterfaceObjectTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7623
    return (void *)((OpenTURNS::Base::Common::Object *)  ((OpenTURNS::Base::Common::InterfaceObject *) x));
 
7624
}
 
7625
static void *_p_OpenTURNS__Base__Stat__HistoryStrategyImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7626
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::HistoryStrategyImplementation *) x));
 
7627
}
 
7628
static void *_p_OpenTURNS__Base__Stat__NumericalSampleImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7629
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Type::NumericalPoint > *) ((OpenTURNS::Base::Stat::NumericalSampleImplementation *) x));
 
7630
}
 
7631
static void *_p_OpenTURNS__Base__Type__IndicesTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7632
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::UnsignedLong > *) ((OpenTURNS::Base::Type::Indices *) x));
 
7633
}
 
7634
static void *_p_OpenTURNS__Base__Type__SymmetricTensorTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7635
    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));
 
7636
}
 
7637
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7638
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathGradientImplementation *) x));
 
7639
}
 
7640
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7641
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Type::NumericalPoint > *) x));
 
7642
}
 
7643
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7644
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Type::NumericalPointWithDescription > *) x));
 
7645
}
 
7646
static void *_p_OpenTURNS__Base__Func__NumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7647
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::NumericalMathHessianImplementation *) x));
 
7648
}
 
7649
static void *_p_OpenTURNS__Base__Common__ComparisonOperatorImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7650
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Common::ComparisonOperatorImplementation *) x));
 
7651
}
 
7652
static void *_p_OpenTURNS__Base__Func__UniVariatePolynomialImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7653
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::UniVariatePolynomialImplementation *) x));
 
7654
}
 
7655
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7656
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Func::UniVariatePolynomial > *) x));
 
7657
}
 
7658
static void *_p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7659
    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));
 
7660
}
 
7661
static void *_p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7662
    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));
 
7663
}
 
7664
static void *_p_OpenTURNS__Base__Common__StudyTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7665
    return (void *)((OpenTURNS::Base::Common::Object *)  ((OpenTURNS::Base::Common::Study *) x));
 
7666
}
 
7667
static void *_p_OpenTURNS__Base__Stat__NumericalSampleTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7668
    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));
 
7669
}
 
7670
static void *_p_OpenTURNS__Base__Func__WrapperFunctionDescriptionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7671
    return (void *)((OpenTURNS::Base::Common::Object *)  ((OpenTURNS::Base::Func::WrapperFunctionDescription *) x));
 
7672
}
 
7673
static void *_p_OpenTURNS__Base__Type__DescriptionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7674
    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));
 
7675
}
 
7676
static void *_p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7677
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ConstantNumericalMathGradientImplementation *) x));
 
7678
}
 
7679
static void *_p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7680
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ComputedNumericalMathGradientImplementation *) x));
 
7681
}
 
7682
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7683
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathGradientImplementation *) x));
 
7684
}
 
7685
static void *_p_OpenTURNS__Base__Stat__FullTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7686
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Full *) x));
 
7687
}
 
7688
static void *_p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7689
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::NoNumericalMathHessianImplementation *) x));
 
7690
}
 
7691
static void *_p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7692
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::LinearCombinationEvaluationImplementation *) x));
 
7693
}
 
7694
static void *_p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7695
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ProductPolynomialEvaluationImplementation *) x));
 
7696
}
 
7697
static void *_p_OpenTURNS__Base__Func__WrapperFrameworkDataTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7698
    return (void *)((OpenTURNS::Base::Common::Object *)  ((OpenTURNS::Base::Func::WrapperFrameworkData *) x));
 
7699
}
 
7700
static void *_p_OpenTURNS__Base__Stat__ConfidenceIntervalTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7701
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::ConfidenceInterval *) x));
 
7702
}
 
7703
static void *_p_OpenTURNS__Base__Type__IntervalTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7704
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::Interval *) x));
 
7705
}
 
7706
static void *_p_OpenTURNS__Base__Func__NumericalMathFunctionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7707
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Func::NumericalMathFunctionImplementation > *) ((OpenTURNS::Base::Func::NumericalMathFunction *) x));
 
7708
}
 
7709
static void *_p_OpenTURNS__Base__Func__LinearNumericalMathFunctionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7710
    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));
 
7711
}
 
7712
static void *_p_OpenTURNS__Base__Common__XMLStorageManagerTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7713
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::StorageManager *) ((OpenTURNS::Base::Common::XMLStorageManager *) x));
 
7714
}
 
7715
static void *_p_OpenTURNS__Base__Common__StorageManagerTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7716
    return (void *)((OpenTURNS::Base::Common::Object *)  ((OpenTURNS::Base::Common::StorageManager *) x));
 
7717
}
 
7718
static void *_p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResultTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7719
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::CorrelationAnalysisSobolIndiceResult *) x));
 
7720
}
 
7721
static void *_p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParametersTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7722
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::CorrelationAnalysisSobolIndiceParameters *) x));
 
7723
}
 
7724
static void *_p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7725
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::NoNumericalMathEvaluationImplementation *) x));
 
7726
}
 
7727
static void *_p_OpenTURNS__Base__Func__WrapperDataTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7728
    return (void *)((OpenTURNS::Base::Common::Object *)  ((OpenTURNS::Base::Func::WrapperData *) x));
 
7729
}
 
7730
static void *_p_OpenTURNS__Base__Common__PersistentObjectTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7731
    return (void *)((OpenTURNS::Base::Common::Object *)  ((OpenTURNS::Base::Common::PersistentObject *) x));
 
7732
}
 
7733
static void *_p_OpenTURNS__Base__Stat__HaltonSequenceTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7734
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation *) ((OpenTURNS::Base::Stat::HaltonSequence *) x));
 
7735
}
 
7736
static void *_p_OpenTURNS__Base__Stat__SobolSequenceTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7737
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation *) ((OpenTURNS::Base::Stat::SobolSequence *) x));
 
7738
}
 
7739
static void *_p_OpenTURNS__Base__Stat__LowDiscrepancySequenceTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7740
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation > *) ((OpenTURNS::Base::Stat::LowDiscrepancySequence *) x));
 
7741
}
 
7742
static void *_p_OpenTURNS__Base__Stat__HistoryStrategyTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7743
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Stat::HistoryStrategyImplementation > *) ((OpenTURNS::Base::Stat::HistoryStrategy *) x));
 
7744
}
 
7745
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7746
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation > *) x));
 
7747
}
 
7748
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__HistoryStrategyImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7749
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Stat::HistoryStrategyImplementation > *) x));
 
7750
}
 
7751
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7752
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Stat::NumericalSampleImplementation > *) x));
 
7753
}
 
7754
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__TensorImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7755
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::TensorImplementation > *) x));
 
7756
}
 
7757
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__MatrixImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7758
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::MatrixImplementation > *) x));
 
7759
}
 
7760
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Common__ComparisonOperatorImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7761
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Common::ComparisonOperatorImplementation > *) x));
 
7762
}
 
7763
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7764
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::DescriptionImplementation > *) x));
 
7765
}
 
7766
static void *_p_OpenTURNS__Base__Type__TensorTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7767
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Type::TensorImplementation > *) ((OpenTURNS::Base::Type::Tensor *) x));
 
7768
}
 
7769
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__NumericalMathFunctionImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7770
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Func::NumericalMathFunctionImplementation > *) x));
 
7771
}
 
7772
static void *_p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__UniVariatePolynomialImplementation_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7773
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *) ((OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Func::UniVariatePolynomialImplementation > *) x));
 
7774
}
 
7775
static void *_p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7776
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::QuadraticNumericalMathEvaluationImplementation *) x));
 
7777
}
 
7778
static void *_p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7779
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::IndicatorNumericalMathEvaluationImplementation *) x));
 
7780
}
 
7781
static void *_p_OpenTURNS__Base__Func__WrapperFileTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7782
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Func::WrapperFile *) x));
 
7783
}
 
7784
static void *_p_OpenTURNS__Base__Func__LinearCombinationGradientImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7785
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::LinearCombinationGradientImplementation *) x));
 
7786
}
 
7787
static void *_p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7788
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation *) x));
 
7789
}
 
7790
static void *_p_OpenTURNS__Base__Type__IdentityMatrixTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7791
    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));
 
7792
}
 
7793
static void *_p_OpenTURNS__Base__Stat__CovarianceMatrixTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7794
    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));
 
7795
}
 
7796
static void *_p_OpenTURNS__Base__Type__SymmetricMatrixTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7797
    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));
 
7798
}
 
7799
static void *_p_OpenTURNS__Base__Type__SquareMatrixTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7800
    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));
 
7801
}
 
7802
static void *_p_OpenTURNS__Base__Stat__CompactTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7803
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Compact *) x));
 
7804
}
 
7805
static void *_p_OpenTURNS__Base__Common__LessTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7806
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::Less *) x));
 
7807
}
 
7808
static void *_p_OpenTURNS__Base__Func__UniVariatePolynomialTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7809
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::InterfaceObject *)(OpenTURNS::Base::Common::TypedInterfaceObject< OpenTURNS::Base::Func::UniVariatePolynomialImplementation > *) ((OpenTURNS::Base::Func::UniVariatePolynomial *) x));
 
7810
}
 
7811
static void *_p_OpenTURNS__Base__Stat__NullTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7812
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Null *) x));
 
7813
}
 
7814
static void *_p_OpenTURNS__Base__Func__WrapperDataFileTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7815
    return (void *)((OpenTURNS::Base::Common::Object *)  ((OpenTURNS::Base::Func::WrapperDataFile *) x));
 
7816
}
 
7817
static void *_p_OpenTURNS__Base__Func__WrapperParameterTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7818
    return (void *)((OpenTURNS::Base::Common::Object *)  ((OpenTURNS::Base::Func::WrapperParameter *) x));
 
7819
}
 
7820
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7821
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathHessianImplementation *) x));
 
7822
}
 
7823
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7824
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< unsigned long > *) x));
 
7825
}
 
7826
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_double_tTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7827
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Type::PersistentCollection< double > *) x));
 
7828
}
 
7829
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathFunctionTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7830
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathFunctionImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathFunction *) x));
 
7831
}
 
7832
static void *_p_OpenTURNS__Base__Stat__LinearModelTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7833
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *) ((OpenTURNS::Base::Stat::LinearModel *) x));
 
7834
}
 
7835
static void *_p_OpenTURNS__Base__Func__LinearCombinationHessianImplementationTo_p_OpenTURNS__Base__Common__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7836
    return (void *)((OpenTURNS::Base::Common::Object *) (OpenTURNS::Base::Common::PersistentObject *)(OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::LinearCombinationHessianImplementation *) x));
 
7837
}
 
7838
static void *_p_OpenTURNS__Base__Stat__HaltonSequenceTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7839
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation *) ((OpenTURNS::Base::Stat::HaltonSequence *) x));
 
7840
}
 
7841
static void *_p_OpenTURNS__Base__Stat__SobolSequenceTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7842
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation *) ((OpenTURNS::Base::Stat::SobolSequence *) x));
 
7843
}
 
7844
static void *_p_OpenTURNS__Base__Common__EqualTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7845
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::Equal *) x));
 
7846
}
 
7847
static void *_p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7848
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) x));
 
7849
}
 
7850
static void *_p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7851
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ConstantNumericalMathHessianImplementation *) x));
 
7852
}
 
7853
static void *_p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7854
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ComputedNumericalMathEvaluationImplementation *) x));
 
7855
}
 
7856
static void *_p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7857
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ComputedNumericalMathHessianImplementation *) x));
 
7858
}
 
7859
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7860
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathEvaluationImplementation *) x));
 
7861
}
 
7862
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7863
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathHessianImplementation *) x));
 
7864
}
 
7865
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathFunctionTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7866
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathFunctionImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathFunction *) x));
 
7867
}
 
7868
static void *_p_OpenTURNS__Base__Type__NumericalPointTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7869
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::NumericalScalar > *) ((OpenTURNS::Base::Type::NumericalPoint *) x));
 
7870
}
 
7871
static void *_p_OpenTURNS__Base__Func__LinearCombinationGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7872
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::LinearCombinationGradientImplementation *) x));
 
7873
}
 
7874
static void *_p_OpenTURNS__Base__Common__LessTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7875
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::Less *) x));
 
7876
}
 
7877
static void *_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7878
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *) x));
 
7879
}
 
7880
static void *_p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7881
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::LinearCombinationEvaluationImplementation *) x));
 
7882
}
 
7883
static void *_p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7884
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ProductPolynomialEvaluationImplementation *) x));
 
7885
}
 
7886
static void *_p_OpenTURNS__Base__Stat__CompactTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7887
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Compact *) x));
 
7888
}
 
7889
static void *_p_OpenTURNS__Base__Stat__LinearModelTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7890
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Stat::LinearModel *) x));
 
7891
}
 
7892
static void *_p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7893
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::NoNumericalMathHessianImplementation *) x));
 
7894
}
 
7895
static void *_p_OpenTURNS__Base__Func__WrapperFileTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7896
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Func::WrapperFile *) x));
 
7897
}
 
7898
static void *_p_OpenTURNS__Base__Common__ComparisonOperatorImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7899
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Common::ComparisonOperatorImplementation *) x));
 
7900
}
 
7901
static void *_p_OpenTURNS__Base__Func__NumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7902
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Func::NumericalMathHessianImplementation *) x));
 
7903
}
 
7904
static void *_p_OpenTURNS__Base__Func__UniVariatePolynomialImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7905
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Func::UniVariatePolynomialImplementation *) x));
 
7906
}
 
7907
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_tTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7908
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Type::NumericalPointWithDescription > *) x));
 
7909
}
 
7910
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_tTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7911
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Type::NumericalPoint > *) x));
 
7912
}
 
7913
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_tTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7914
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Func::UniVariatePolynomial > *) x));
 
7915
}
 
7916
static void *_p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7917
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Stat::LowDiscrepancySequenceImplementation *) x));
 
7918
}
 
7919
static void *_p_OpenTURNS__Base__Type__IndicesTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7920
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::UnsignedLong > *) ((OpenTURNS::Base::Type::Indices *) x));
 
7921
}
 
7922
static void *_p_OpenTURNS__Base__Common__GreaterOrEqualTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7923
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::GreaterOrEqual *) x));
 
7924
}
 
7925
static void *_p_OpenTURNS__Base__Common__LessOrEqualTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7926
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::LessOrEqual *) x));
 
7927
}
 
7928
static void *_p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResultTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7929
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Stat::CorrelationAnalysisSobolIndiceResult *) x));
 
7930
}
 
7931
static void *_p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParametersTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7932
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Stat::CorrelationAnalysisSobolIndiceParameters *) x));
 
7933
}
 
7934
static void *_p_OpenTURNS__Base__Func__LinearCombinationHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7935
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::LinearCombinationHessianImplementation *) x));
 
7936
}
 
7937
static void *_p_OpenTURNS__Base__Type__NumericalPointWithDescriptionTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7938
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::NumericalScalar > *)(OpenTURNS::Base::Type::NumericalPoint *) ((OpenTURNS::Base::Type::NumericalPointWithDescription *) x));
 
7939
}
 
7940
static void *_p_OpenTURNS__Base__Stat__LastTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7941
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Last *) x));
 
7942
}
 
7943
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathFunctionTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7944
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathFunctionImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathFunction *) x));
 
7945
}
 
7946
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_double_tTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7947
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Type::PersistentCollection< double > *) x));
 
7948
}
 
7949
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_tTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7950
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Type::PersistentCollection< std::string > *) x));
 
7951
}
 
7952
static void *_p_OpenTURNS__Base__Stat__ConfidenceIntervalTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7953
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Stat::ConfidenceInterval *) x));
 
7954
}
 
7955
static void *_p_OpenTURNS__Base__Type__IntervalTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7956
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Type::Interval *) x));
 
7957
}
 
7958
static void *_p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7959
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::LinearNumericalMathEvaluationImplementation *) x));
 
7960
}
 
7961
static void *_p_OpenTURNS__Base__Stat__HistoryStrategyImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7962
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Stat::HistoryStrategyImplementation *) x));
 
7963
}
 
7964
static void *_p_OpenTURNS__Base__Stat__NumericalSampleImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7965
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::Base::Type::NumericalPoint > *) ((OpenTURNS::Base::Stat::NumericalSampleImplementation *) x));
 
7966
}
 
7967
static void *_p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7968
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::QuadraticNumericalMathEvaluationImplementation *) x));
 
7969
}
 
7970
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7971
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathEvaluationImplementation *) x));
 
7972
}
 
7973
static void *_p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7974
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::IndicatorNumericalMathEvaluationImplementation *) x));
 
7975
}
 
7976
static void *_p_OpenTURNS__Base__Type__TensorImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7977
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::NumericalScalar > *) ((OpenTURNS::Base::Type::TensorImplementation *) x));
 
7978
}
 
7979
static void *_p_OpenTURNS__Base__Type__MatrixImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7980
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::NumericalScalar > *) ((OpenTURNS::Base::Type::MatrixImplementation *) x));
 
7981
}
 
7982
static void *_p_OpenTURNS__Base__Type__DescriptionImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7983
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Type::PersistentCollection< OpenTURNS::String > *) ((OpenTURNS::Base::Type::DescriptionImplementation *) x));
 
7984
}
 
7985
static void *_p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_tTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7986
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Type::PersistentCollection< unsigned long > *) x));
 
7987
}
 
7988
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7989
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathGradientImplementation *) x));
 
7990
}
 
7991
static void *_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessianTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7992
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *) x));
 
7993
}
 
7994
static void *_p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7995
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::LinearNumericalMathGradientImplementation *) x));
 
7996
}
 
7997
static void *_p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
7998
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::NoNumericalMathGradientImplementation *) x));
 
7999
}
 
8000
static void *_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
8001
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *) x));
 
8002
}
 
8003
static void *_p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
8004
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathEvaluationImplementation *) ((OpenTURNS::Base::Func::NoNumericalMathEvaluationImplementation *) x));
 
8005
}
 
8006
static void *_p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
8007
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ConstantNumericalMathGradientImplementation *) x));
 
8008
}
 
8009
static void *_p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
8010
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ComputedNumericalMathGradientImplementation *) x));
 
8011
}
 
8012
static void *_p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
8013
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathGradientImplementation *) ((OpenTURNS::Base::Func::ComposedNumericalMathGradientImplementation *) x));
 
8014
}
 
8015
static void *_p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
8016
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Func::NumericalMathHessianImplementation *) ((OpenTURNS::Base::Func::ProductNumericalMathHessianImplementation *) x));
 
8017
}
 
8018
static void *_p_OpenTURNS__Base__Stat__TestResultTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
8019
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Stat::TestResult *) x));
 
8020
}
 
8021
static void *_p_OpenTURNS__Base__Common__GreaterTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
8022
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Common::ComparisonOperatorImplementation *) ((OpenTURNS::Base::Common::Greater *) x));
 
8023
}
 
8024
static void *_p_OpenTURNS__Base__Stat__NullTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
8025
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Null *) x));
 
8026
}
 
8027
static void *_p_OpenTURNS__Base__Stat__FullTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
8028
    return (void *)((OpenTURNS::Base::Common::PersistentObject *) (OpenTURNS::Base::Stat::HistoryStrategyImplementation *) ((OpenTURNS::Base::Stat::Full *) x));
 
8029
}
 
8030
static void *_p_OpenTURNS__Base__Func__NumericalMathGradientImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
8031
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Func::NumericalMathGradientImplementation *) x));
 
8032
}
 
8033
static void *_p_OpenTURNS__Base__Func__NumericalMathFunctionImplementationTo_p_OpenTURNS__Base__Common__PersistentObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
 
8034
    return (void *)((OpenTURNS::Base::Common::PersistentObject *)  ((OpenTURNS::Base::Func::NumericalMathFunctionImplementation *) x));
 
8035
}
 
8036
static swig_type_info _swigt__p_BoolCollection = {"_p_BoolCollection", "BoolCollection *", 0, 0, (void*)0, 0};
 
8037
static swig_type_info _swigt__p_BoolPersistentCollection = {"_p_BoolPersistentCollection", "BoolPersistentCollection *", 0, 0, (void*)0, 0};
 
8038
static swig_type_info _swigt__p_CacheImplementation = {"_p_CacheImplementation", "CacheImplementation *", 0, 0, (void*)0, 0};
 
8039
static swig_type_info _swigt__p_CacheKeyType = {"_p_CacheKeyType", "CacheKeyType *", 0, 0, (void*)0, 0};
 
8040
static swig_type_info _swigt__p_CacheType = {"_p_CacheType", "CacheType *", 0, 0, (void*)0, 0};
 
8041
static swig_type_info _swigt__p_CacheValueType = {"_p_CacheValueType", "CacheValueType *", 0, 0, (void*)0, 0};
 
8042
static swig_type_info _swigt__p_Coefficients = {"_p_Coefficients", "Coefficients *", 0, 0, (void*)0, 0};
 
8043
static swig_type_info _swigt__p_ComparisonOperator = {"_p_ComparisonOperator", "ComparisonOperator *", 0, 0, (void*)0, 0};
 
8044
static swig_type_info _swigt__p_ConfidenceIntervalCollection = {"_p_ConfidenceIntervalCollection", "ConfidenceIntervalCollection *", 0, 0, (void*)0, 0};
 
8045
static swig_type_info _swigt__p_ConfidenceIntervalPersistentCollection = {"_p_ConfidenceIntervalPersistentCollection", "ConfidenceIntervalPersistentCollection *", 0, 0, (void*)0, 0};
 
8046
static swig_type_info _swigt__p_CorrelationMatrix = {"_p_CorrelationMatrix", "CorrelationMatrix *", 0, 0, (void*)0, 0};
 
8047
static swig_type_info _swigt__p_CovarianceMatrix = {"_p_CovarianceMatrix", "CovarianceMatrix *", 0, 0, (void*)0, 0};
 
8048
static swig_type_info _swigt__p_Description = {"_p_Description", "Description *", 0, 0, (void*)0, 0};
 
8049
static swig_type_info _swigt__p_DirectoryList = {"_p_DirectoryList", "DirectoryList *", 0, 0, (void*)0, 0};
 
8050
static swig_type_info _swigt__p_ElementType = {"_p_ElementType", "ElementType *", 0, 0, (void*)0, 0};
 
8051
static swig_type_info _swigt__p_EvaluationImplementation = {"_p_EvaluationImplementation", "EvaluationImplementation *", 0, 0, (void*)0, 0};
 
8052
static swig_type_info _swigt__p_FileListType = {"_p_FileListType", "FileListType *", 0, 0, (void*)0, 0};
 
8053
static swig_type_info _swigt__p_FileNotFoundException = {"_p_FileNotFoundException", "FileNotFoundException *", 0, 0, (void*)0, 0};
 
8054
static swig_type_info _swigt__p_GradientImplementation = {"_p_GradientImplementation", "GradientImplementation *", 0, 0, (void*)0, 0};
 
8055
static swig_type_info _swigt__p_Graph = {"_p_Graph", "Graph *", 0, 0, (void*)0, 0};
 
8056
static swig_type_info _swigt__p_HessianImplementation = {"_p_HessianImplementation", "HessianImplementation *", 0, 0, (void*)0, 0};
 
8057
static swig_type_info _swigt__p_IdentityMatrix = {"_p_IdentityMatrix", "IdentityMatrix *", 0, 0, (void*)0, 0};
 
8058
static swig_type_info _swigt__p_Implementation = {"_p_Implementation", "Implementation *", 0, 0, (void*)0, 0};
 
8059
static swig_type_info _swigt__p_ImplementationAsPersistentObject = {"_p_ImplementationAsPersistentObject", "ImplementationAsPersistentObject *", 0, 0, (void*)0, 0};
 
8060
static swig_type_info _swigt__p_ImplementationElementType = {"_p_ImplementationElementType", "ImplementationElementType *", 0, 0, (void*)0, 0};
 
8061
static swig_type_info _swigt__p_ImplementationType = {"_p_ImplementationType", "ImplementationType *", 0, 0, (void*)0, 0};
 
8062
static swig_type_info _swigt__p_Indices = {"_p_Indices", "Indices *", 0, 0, (void*)0, 0};
 
8063
static swig_type_info _swigt__p_InternalException = {"_p_InternalException", "InternalException *", 0, 0, (void*)0, 0};
 
8064
static swig_type_info _swigt__p_InternalFunction = {"_p_InternalFunction", "InternalFunction *", 0, 0, (void*)0, 0};
 
8065
static swig_type_info _swigt__p_InternalGradient = {"_p_InternalGradient", "InternalGradient *", 0, 0, (void*)0, 0};
 
8066
static swig_type_info _swigt__p_InternalHessian = {"_p_InternalHessian", "InternalHessian *", 0, 0, (void*)0, 0};
 
8067
static swig_type_info _swigt__p_InternalType = {"_p_InternalType", "InternalType *", 0, 0, (void*)0, 0};
 
8068
static swig_type_info _swigt__p_Interval = {"_p_Interval", "Interval *", 0, 0, (void*)0, 0};
 
8069
static swig_type_info _swigt__p_InvalidArgumentException = {"_p_InvalidArgumentException", "InvalidArgumentException *", 0, 0, (void*)0, 0};
 
8070
static swig_type_info _swigt__p_InvalidDimensionException = {"_p_InvalidDimensionException", "InvalidDimensionException *", 0, 0, (void*)0, 0};
 
8071
static swig_type_info _swigt__p_KeyType = {"_p_KeyType", "KeyType *", 0, 0, (void*)0, 0};
 
8072
static swig_type_info _swigt__p_LabelMap = {"_p_LabelMap", "LabelMap *", 0, 0, (void*)0, 0};
 
8073
static swig_type_info _swigt__p_Map = {"_p_Map", "Map *", 0, 0, (void*)0, 0};
 
8074
static swig_type_info _swigt__p_MapElement = {"_p_MapElement", "MapElement *", 0, 0, (void*)0, 0};
 
8075
static swig_type_info _swigt__p_MappedType = {"_p_MappedType", "MappedType *", 0, 0, (void*)0, 0};
 
8076
static swig_type_info _swigt__p_Matrix = {"_p_Matrix", "Matrix *", 0, 0, (void*)0, 0};
 
8077
static swig_type_info _swigt__p_MersenneTwister = {"_p_MersenneTwister", "MersenneTwister *", 0, 0, (void*)0, 0};
 
8078
static swig_type_info _swigt__p_NoWrapperFileFoundException = {"_p_NoWrapperFileFoundException", "NoWrapperFileFoundException *", 0, 0, (void*)0, 0};
 
8079
static swig_type_info _swigt__p_NumericalComplexCollection = {"_p_NumericalComplexCollection", "NumericalComplexCollection *", 0, 0, (void*)0, 0};
 
8080
static swig_type_info _swigt__p_NumericalMathFunction = {"_p_NumericalMathFunction", "NumericalMathFunction *", 0, 0, (void*)0, 0};
 
8081
static swig_type_info _swigt__p_NumericalMathFunctionCollection = {"_p_NumericalMathFunctionCollection", "NumericalMathFunctionCollection *", 0, 0, (void*)0, 0};
 
8082
static swig_type_info _swigt__p_NumericalMathFunctionPersistentCollection = {"_p_NumericalMathFunctionPersistentCollection", "NumericalMathFunctionPersistentCollection *", 0, 0, (void*)0, 0};
 
8083
static swig_type_info _swigt__p_NumericalPoint = {"_p_NumericalPoint", "NumericalPoint *", 0, 0, (void*)0, 0};
 
8084
static swig_type_info _swigt__p_NumericalPointWithDescription = {"_p_NumericalPointWithDescription", "NumericalPointWithDescription *", 0, 0, (void*)0, 0};
 
8085
static swig_type_info _swigt__p_NumericalSample = {"_p_NumericalSample", "NumericalSample *", 0, 0, (void*)0, 0};
 
8086
static swig_type_info _swigt__p_NumericalScalarCollection = {"_p_NumericalScalarCollection", "NumericalScalarCollection *", 0, 0, (void*)0, 0};
 
8087
static swig_type_info _swigt__p_NumericalScalarPersistentCollection = {"_p_NumericalScalarPersistentCollection", "NumericalScalarPersistentCollection *", 0, 0, (void*)0, 0};
 
8088
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};
 
8089
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};
 
8090
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};
 
8091
static swig_type_info _swigt__p_OpenTURNS__Advocate = {"_p_OpenTURNS__Advocate", "OpenTURNS::Advocate *|OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::StorageManager::Advocate *|OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::StorageManager::Advocate *|OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::StorageManager::Advocate *", 0, 0, (void*)0, 0};
 
8092
static swig_type_info _swigt__p_OpenTURNS__Base__Common__Object = {"_p_OpenTURNS__Base__Common__Object", "OpenTURNS::Base::Common::Object *", 0, 0, (void*)0, 0};
 
8093
static swig_type_info _swigt__p_OpenTURNS__Base__Common__ComparisonOperator = {"_p_OpenTURNS__Base__Common__ComparisonOperator", 0, 0, 0, 0, 0};
 
8094
static swig_type_info _swigt__p_OpenTURNS__Base__Func__LinearNumericalMathFunction = {"_p_OpenTURNS__Base__Func__LinearNumericalMathFunction", 0, 0, 0, 0, 0};
 
8095
static swig_type_info _swigt__p_OpenTURNS__Base__Func__WrapperDataVariable = {"_p_OpenTURNS__Base__Func__WrapperDataVariable", 0, 0, 0, 0, 0};
 
8096
static swig_type_info _swigt__p_OpenTURNS__Base__Type__TensorImplementation = {"_p_OpenTURNS__Base__Type__TensorImplementation", 0, 0, 0, 0, 0};
 
8097
static swig_type_info _swigt__p_OpenTURNS__Base__Type__MatrixImplementation = {"_p_OpenTURNS__Base__Type__MatrixImplementation", 0, 0, 0, 0, 0};
 
8098
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ProductNumericalMathFunction = {"_p_OpenTURNS__Base__Func__ProductNumericalMathFunction", 0, 0, 0, 0, 0};
 
8099
static swig_type_info _swigt__p_OpenTURNS__Base__Type__NumericalPointWithDescription = {"_p_OpenTURNS__Base__Type__NumericalPointWithDescription", 0, 0, 0, 0, 0};
 
8100
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
 
8101
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation = {"_p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation", 0, 0, 0, 0, 0};
 
8102
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation = {"_p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation", 0, 0, 0, 0, 0};
 
8103
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation = {"_p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation", 0, 0, 0, 0, 0};
 
8104
static swig_type_info _swigt__p_OpenTURNS__Base__Common__Equal = {"_p_OpenTURNS__Base__Common__Equal", 0, 0, 0, 0, 0};
 
8105
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation = {"_p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation", 0, 0, 0, 0, 0};
 
8106
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};
 
8107
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};
 
8108
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};
 
8109
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};
 
8110
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};
 
8111
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};
 
8112
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};
 
8113
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};
 
8114
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};
 
8115
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__TestResult = {"_p_OpenTURNS__Base__Stat__TestResult", 0, 0, 0, 0, 0};
 
8116
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation = {"_p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation", 0, 0, 0, 0, 0};
 
8117
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation = {"_p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation", 0, 0, 0, 0, 0};
 
8118
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation = {"_p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation", 0, 0, 0, 0, 0};
 
8119
static swig_type_info _swigt__p_OpenTURNS__Base__Common__Greater = {"_p_OpenTURNS__Base__Common__Greater", 0, 0, 0, 0, 0};
 
8120
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__CorrelationMatrix = {"_p_OpenTURNS__Base__Stat__CorrelationMatrix", 0, 0, 0, 0, 0};
 
8121
static swig_type_info _swigt__p_OpenTURNS__Base__Common__ComparisonOperatorImplementation = {"_p_OpenTURNS__Base__Common__ComparisonOperatorImplementation", 0, 0, 0, 0, 0};
 
8122
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation = {"_p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation", 0, 0, 0, 0, 0};
 
8123
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};
 
8124
static swig_type_info _swigt__p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation = {"_p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation", 0, 0, 0, 0, 0};
 
8125
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation = {"_p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation", 0, 0, 0, 0, 0};
 
8126
static swig_type_info _swigt__p_OpenTURNS__Base__Common__GreaterOrEqual = {"_p_OpenTURNS__Base__Common__GreaterOrEqual", 0, 0, 0, 0, 0};
 
8127
static swig_type_info _swigt__p_OpenTURNS__Base__Common__LessOrEqual = {"_p_OpenTURNS__Base__Common__LessOrEqual", 0, 0, 0, 0, 0};
 
8128
static swig_type_info _swigt__p_OpenTURNS__Base__Func__WrapperFunctionDescription = {"_p_OpenTURNS__Base__Func__WrapperFunctionDescription", 0, 0, 0, 0, 0};
 
8129
static swig_type_info _swigt__p_OpenTURNS__Base__Common__InterfaceObject = {"_p_OpenTURNS__Base__Common__InterfaceObject", 0, 0, 0, 0, 0};
 
8130
static swig_type_info _swigt__p_OpenTURNS__Base__Common__Study = {"_p_OpenTURNS__Base__Common__Study", 0, 0, 0, 0, 0};
 
8131
static swig_type_info _swigt__p_OpenTURNS__Base__Type__Indices = {"_p_OpenTURNS__Base__Type__Indices", 0, 0, 0, 0, 0};
 
8132
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__Full = {"_p_OpenTURNS__Base__Stat__Full", 0, 0, 0, 0, 0};
 
8133
static swig_type_info _swigt__p_OpenTURNS__Base__Type__Tensor = {"_p_OpenTURNS__Base__Type__Tensor", 0, 0, 0, 0, 0};
 
8134
static swig_type_info _swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_double_t = {"_p_OpenTURNS__Base__Type__PersistentCollectionT_double_t", 0, 0, 0, 0, 0};
 
8135
static swig_type_info _swigt__p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation = {"_p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation", 0, 0, 0, 0, 0};
 
8136
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation = {"_p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation", 0, 0, 0, 0, 0};
 
8137
static swig_type_info _swigt__p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation = {"_p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation", 0, 0, 0, 0, 0};
 
8138
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
 
8139
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation = {"_p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation", 0, 0, 0, 0, 0};
 
8140
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation = {"_p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation", 0, 0, 0, 0, 0};
 
8141
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};
 
8142
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathFunction = {"_p_OpenTURNS__Base__Func__ComposedNumericalMathFunction", 0, 0, 0, 0, 0};
 
8143
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__NumericalSample = {"_p_OpenTURNS__Base__Stat__NumericalSample", 0, 0, 0, 0, 0};
 
8144
static swig_type_info _swigt__p_OpenTURNS__Base__Type__Description = {"_p_OpenTURNS__Base__Type__Description", 0, 0, 0, 0, 0};
 
8145
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__HistoryStrategyImplementation = {"_p_OpenTURNS__Base__Stat__HistoryStrategyImplementation", 0, 0, 0, 0, 0};
 
8146
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__NumericalSampleImplementation = {"_p_OpenTURNS__Base__Stat__NumericalSampleImplementation", 0, 0, 0, 0, 0};
 
8147
static swig_type_info _swigt__p_OpenTURNS__Base__Common__Less = {"_p_OpenTURNS__Base__Common__Less", 0, 0, 0, 0, 0};
 
8148
static swig_type_info _swigt__p_OpenTURNS__Base__Func__WrapperFrameworkData = {"_p_OpenTURNS__Base__Func__WrapperFrameworkData", 0, 0, 0, 0, 0};
 
8149
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation = {"_p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation", 0, 0, 0, 0, 0};
 
8150
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NumericalMathFunction = {"_p_OpenTURNS__Base__Func__NumericalMathFunction", 0, 0, 0, 0, 0};
 
8151
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__ConfidenceInterval = {"_p_OpenTURNS__Base__Stat__ConfidenceInterval", 0, 0, 0, 0, 0};
 
8152
static swig_type_info _swigt__p_OpenTURNS__Base__Type__Interval = {"_p_OpenTURNS__Base__Type__Interval", 0, 0, 0, 0, 0};
 
8153
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__Null = {"_p_OpenTURNS__Base__Stat__Null", 0, 0, 0, 0, 0};
 
8154
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};
 
8155
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};
 
8156
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
 
8157
static swig_type_info _swigt__p_OpenTURNS__Base__Common__StorageManager = {"_p_OpenTURNS__Base__Common__StorageManager", 0, 0, 0, 0, 0};
 
8158
static swig_type_info _swigt__p_OpenTURNS__Base__Common__XMLStorageManager = {"_p_OpenTURNS__Base__Common__XMLStorageManager", 0, 0, 0, 0, 0};
 
8159
static swig_type_info _swigt__p_OpenTURNS__Base__Func__WrapperData = {"_p_OpenTURNS__Base__Func__WrapperData", 0, 0, 0, 0, 0};
 
8160
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__HaltonSequence = {"_p_OpenTURNS__Base__Stat__HaltonSequence", 0, 0, 0, 0, 0};
 
8161
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__SobolSequence = {"_p_OpenTURNS__Base__Stat__SobolSequence", 0, 0, 0, 0, 0};
 
8162
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__LowDiscrepancySequence = {"_p_OpenTURNS__Base__Stat__LowDiscrepancySequence", 0, 0, 0, 0, 0};
 
8163
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__HistoryStrategy = {"_p_OpenTURNS__Base__Stat__HistoryStrategy", 0, 0, 0, 0, 0};
 
8164
static swig_type_info _swigt__p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
 
8165
static swig_type_info _swigt__p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation = {"_p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation", 0, 0, 0, 0, 0};
 
8166
static swig_type_info _swigt__p_OpenTURNS__Base__Func__WrapperFile = {"_p_OpenTURNS__Base__Func__WrapperFile", 0, 0, 0, 0, 0};
 
8167
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__Last = {"_p_OpenTURNS__Base__Stat__Last", 0, 0, 0, 0, 0};
 
8168
static swig_type_info _swigt__p_OpenTURNS__Base__Type__SquareMatrix = {"_p_OpenTURNS__Base__Type__SquareMatrix", 0, 0, 0, 0, 0};
 
8169
static swig_type_info _swigt__p_OpenTURNS__Base__Type__SymmetricMatrix = {"_p_OpenTURNS__Base__Type__SymmetricMatrix", 0, 0, 0, 0, 0};
 
8170
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__CovarianceMatrix = {"_p_OpenTURNS__Base__Stat__CovarianceMatrix", 0, 0, 0, 0, 0};
 
8171
static swig_type_info _swigt__p_OpenTURNS__Base__Type__IdentityMatrix = {"_p_OpenTURNS__Base__Type__IdentityMatrix", 0, 0, 0, 0, 0};
 
8172
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__Compact = {"_p_OpenTURNS__Base__Stat__Compact", 0, 0, 0, 0, 0};
 
8173
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
 
8174
static swig_type_info _swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
 
8175
static swig_type_info _swigt__p_OpenTURNS__Base__Func__UniVariatePolynomial = {"_p_OpenTURNS__Base__Func__UniVariatePolynomial", 0, 0, 0, 0, 0};
 
8176
static swig_type_info _swigt__p_OpenTURNS__Base__Type__DescriptionImplementation = {"_p_OpenTURNS__Base__Type__DescriptionImplementation", 0, 0, 0, 0, 0};
 
8177
static swig_type_info _swigt__p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation = {"_p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation", 0, 0, 0, 0, 0};
 
8178
static swig_type_info _swigt__p_OpenTURNS__Base__Func__WrapperDataFile = {"_p_OpenTURNS__Base__Func__WrapperDataFile", 0, 0, 0, 0, 0};
 
8179
static swig_type_info _swigt__p_OpenTURNS__Base__Func__WrapperParameter = {"_p_OpenTURNS__Base__Func__WrapperParameter", 0, 0, 0, 0, 0};
 
8180
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};
 
8181
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};
 
8182
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};
 
8183
static swig_type_info _swigt__p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
 
8184
static swig_type_info _swigt__p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation = {"_p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation", 0, 0, 0, 0, 0};
 
8185
static swig_type_info _swigt__p_OpenTURNS__Base__Stat__LinearModel = {"_p_OpenTURNS__Base__Stat__LinearModel", 0, 0, 0, 0, 0};
 
8186
static swig_type_info _swigt__p_OpenTURNS__Base__Common__PersistentObject = {"_p_OpenTURNS__Base__Common__PersistentObject", "OpenTURNS::Base::Common::PersistentObject *", 0, 0, (void*)0, 0};
 
8187
static swig_type_info _swigt__p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t = {"_p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t", "OpenTURNS::Base::Common::Pointer< OpenTURNS::Base::Func::NumericalMathEvaluationImplementation > *|OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::EvaluationImplementation *|OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::EvaluationImplementation *|OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::EvaluationImplementation *", 0, 0, (void*)0, 0};
 
8188
static swig_type_info _swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient = {"_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient", "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient *", 0, 0, (void*)0, 0};
 
8189
static swig_type_info _swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian = {"_p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian", "OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian *", 0, 0, (void*)0, 0};
 
8190
static swig_type_info _swigt__p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient = {"_p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient", "OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient *", 0, 0, (void*)0, 0};
 
8191
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NumericalMathGradientImplementation = {"_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation", "OpenTURNS::Base::Func::NumericalMathGradientImplementation *", 0, 0, (void*)0, 0};
 
8192
static swig_type_info _swigt__p_OpenTURNS__Base__Func__NumericalMathHessianImplementation = {"_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation", "OpenTURNS::Base::Func::NumericalMathHessianImplementation *", 0, 0, (void*)0, 0};
 
8193
static swig_type_info _swigt__p_OpenTURNS__Base__Type__Matrix = {"_p_OpenTURNS__Base__Type__Matrix", "OpenTURNS::Base::Func::NumericalMathGradientImplementation::Matrix *|OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::Matrix *|OpenTURNS::Base::Type::Matrix *", 0, 0, (void*)0, 0};
 
8194
static swig_type_info _swigt__p_OpenTURNS__Base__Type__NumericalPoint = {"_p_OpenTURNS__Base__Type__NumericalPoint", "OpenTURNS::Base::Diff::CenteredFiniteDifferenceGradient::NumericalPoint *|OpenTURNS::Base::Type::NumericalPoint *|OpenTURNS::Base::Diff::NonCenteredFiniteDifferenceGradient::NumericalPoint *|OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::NumericalPoint *", 0, 0, (void*)0, 0};
 
8195
static swig_type_info _swigt__p_OpenTURNS__Base__Type__SymmetricTensor = {"_p_OpenTURNS__Base__Type__SymmetricTensor", "OpenTURNS::Base::Type::SymmetricTensor *|OpenTURNS::Base::Diff::CenteredFiniteDifferenceHessian::SymmetricTensor *", 0, 0, (void*)0, 0};
 
8196
static swig_type_info _swigt__p_OpenTURNS__PointInSourceFile = {"_p_OpenTURNS__PointInSourceFile", "OpenTURNS::PointInSourceFile *|PointInSourceFile *", 0, 0, (void*)0, 0};
 
8197
static swig_type_info _swigt__p_OutOfBoundException = {"_p_OutOfBoundException", "OutOfBoundException *", 0, 0, (void*)0, 0};
 
8198
static swig_type_info _swigt__p_PersistentObject = {"_p_PersistentObject", "PersistentObject *", 0, 0, (void*)0, 0};
 
8199
static swig_type_info _swigt__p_PolynomialCollection = {"_p_PolynomialCollection", "PolynomialCollection *", 0, 0, (void*)0, 0};
 
8200
static swig_type_info _swigt__p_PolynomialPersistentCollection = {"_p_PolynomialPersistentCollection", "PolynomialPersistentCollection *", 0, 0, (void*)0, 0};
 
8201
static swig_type_info _swigt__p_Severity = {"_p_Severity", "Severity *", 0, 0, (void*)0, 0};
 
8202
static swig_type_info _swigt__p_SobolIndiceParameters = {"_p_SobolIndiceParameters", "SobolIndiceParameters *", 0, 0, (void*)0, 0};
 
8203
static swig_type_info _swigt__p_SobolIndiceResult = {"_p_SobolIndiceResult", "SobolIndiceResult *", 0, 0, (void*)0, 0};
 
8204
static swig_type_info _swigt__p_SquareMatrix = {"_p_SquareMatrix", "SquareMatrix *", 0, 0, (void*)0, 0};
 
8205
static swig_type_info _swigt__p_State = {"_p_State", "State *", 0, 0, (void*)0, 0};
 
8206
static swig_type_info _swigt__p_StorageManager = {"_p_StorageManager", "StorageManager *", 0, 0, (void*)0, 0};
 
8207
static swig_type_info _swigt__p_StorageManagerImplementation = {"_p_StorageManagerImplementation", "StorageManagerImplementation *", 0, 0, (void*)0, 0};
 
8208
static swig_type_info _swigt__p_SymmetricTensor = {"_p_SymmetricTensor", "SymmetricTensor *", 0, 0, (void*)0, 0};
 
8209
static swig_type_info _swigt__p_Tensor = {"_p_Tensor", "Tensor *", 0, 0, (void*)0, 0};
 
8210
static swig_type_info _swigt__p_UnsignedLongCollection = {"_p_UnsignedLongCollection", "UnsignedLongCollection *", 0, 0, (void*)0, 0};
 
8211
static swig_type_info _swigt__p_Value = {"_p_Value", "Value *", 0, 0, (void*)0, 0};
 
8212
static swig_type_info _swigt__p_ValueType = {"_p_ValueType", "ValueType *", 0, 0, (void*)0, 0};
 
8213
static swig_type_info _swigt__p_VariableListType = {"_p_VariableListType", "VariableListType *", 0, 0, (void*)0, 0};
 
8214
static swig_type_info _swigt__p_WrapperFileParsingException = {"_p_WrapperFileParsingException", "WrapperFileParsingException *", 0, 0, (void*)0, 0};
 
8215
static swig_type_info _swigt__p_WrapperInternalException = {"_p_WrapperInternalException", "WrapperInternalException *", 0, 0, (void*)0, 0};
 
8216
static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
 
8217
static swig_type_info _swigt__p_bool = {"_p_bool", "Bool *|OpenTURNS::Bool *|bool *", 0, 0, (void*)0, 0};
 
8218
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
 
8219
static swig_type_info _swigt__p_const_iterator = {"_p_const_iterator", "const_iterator *", 0, 0, (void*)0, 0};
 
8220
static swig_type_info _swigt__p_const_reverse_iterator = {"_p_const_reverse_iterator", "const_reverse_iterator *", 0, 0, (void*)0, 0};
 
8221
static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
 
8222
static swig_type_info _swigt__p_double = {"_p_double", "double *|OpenTURNS::NumericalScalar *|NumericalScalar *", 0, 0, (void*)0, 0};
 
8223
static swig_type_info _swigt__p_iterator = {"_p_iterator", "iterator *", 0, 0, (void*)0, 0};
 
8224
static swig_type_info _swigt__p_key_type = {"_p_key_type", "key_type *", 0, 0, (void*)0, 0};
 
8225
static swig_type_info _swigt__p_long = {"_p_long", "OpenTURNS::IndexType *|OpenTURNS::SizeType *|long *", 0, 0, (void*)0, 0};
 
8226
static swig_type_info _swigt__p_mapped_type = {"_p_mapped_type", "mapped_type *", 0, 0, (void*)0, 0};
 
8227
static swig_type_info _swigt__p_pointer_type = {"_p_pointer_type", "pointer_type *", 0, 0, (void*)0, 0};
 
8228
static swig_type_info _swigt__p_reverse_iterator = {"_p_reverse_iterator", "reverse_iterator *", 0, 0, (void*)0, 0};
 
8229
static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
 
8230
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};
 
8231
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
 
8232
static swig_type_info _swigt__p_std__string = {"_p_std__string", "OpenTURNS::FileName *|FileName *|std::string *|OpenTURNS::String *|String *", 0, 0, (void*)0, 0};
 
8233
static swig_type_info _swigt__p_swig__PySwigIterator = {"_p_swig__PySwigIterator", "swig::PySwigIterator *", 0, 0, (void*)0, 0};
 
8234
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "Id *|OpenTURNS::UnsignedLong *|unsigned long *|OpenTURNS::Id *", 0, 0, (void*)0, 0};
 
8235
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
 
8236
 
 
8237
static swig_type_info *swig_type_initial[] = {
 
8238
  &_swigt__p_BoolCollection,
 
8239
  &_swigt__p_BoolPersistentCollection,
 
8240
  &_swigt__p_CacheImplementation,
 
8241
  &_swigt__p_CacheKeyType,
 
8242
  &_swigt__p_CacheType,
 
8243
  &_swigt__p_CacheValueType,
 
8244
  &_swigt__p_Coefficients,
 
8245
  &_swigt__p_ComparisonOperator,
 
8246
  &_swigt__p_ConfidenceIntervalCollection,
 
8247
  &_swigt__p_ConfidenceIntervalPersistentCollection,
 
8248
  &_swigt__p_CorrelationMatrix,
 
8249
  &_swigt__p_CovarianceMatrix,
 
8250
  &_swigt__p_Description,
 
8251
  &_swigt__p_DirectoryList,
 
8252
  &_swigt__p_ElementType,
 
8253
  &_swigt__p_EvaluationImplementation,
 
8254
  &_swigt__p_FileListType,
 
8255
  &_swigt__p_FileNotFoundException,
 
8256
  &_swigt__p_GradientImplementation,
 
8257
  &_swigt__p_Graph,
 
8258
  &_swigt__p_HessianImplementation,
 
8259
  &_swigt__p_IdentityMatrix,
 
8260
  &_swigt__p_Implementation,
 
8261
  &_swigt__p_ImplementationAsPersistentObject,
 
8262
  &_swigt__p_ImplementationElementType,
 
8263
  &_swigt__p_ImplementationType,
 
8264
  &_swigt__p_Indices,
 
8265
  &_swigt__p_InternalException,
 
8266
  &_swigt__p_InternalFunction,
 
8267
  &_swigt__p_InternalGradient,
 
8268
  &_swigt__p_InternalHessian,
 
8269
  &_swigt__p_InternalType,
 
8270
  &_swigt__p_Interval,
 
8271
  &_swigt__p_InvalidArgumentException,
 
8272
  &_swigt__p_InvalidDimensionException,
 
8273
  &_swigt__p_KeyType,
 
8274
  &_swigt__p_LabelMap,
 
8275
  &_swigt__p_Map,
 
8276
  &_swigt__p_MapElement,
 
8277
  &_swigt__p_MappedType,
 
8278
  &_swigt__p_Matrix,
 
8279
  &_swigt__p_MersenneTwister,
 
8280
  &_swigt__p_NoWrapperFileFoundException,
 
8281
  &_swigt__p_NumericalComplexCollection,
 
8282
  &_swigt__p_NumericalMathFunction,
 
8283
  &_swigt__p_NumericalMathFunctionCollection,
 
8284
  &_swigt__p_NumericalMathFunctionPersistentCollection,
 
8285
  &_swigt__p_NumericalPoint,
 
8286
  &_swigt__p_NumericalPointWithDescription,
 
8287
  &_swigt__p_NumericalSample,
 
8288
  &_swigt__p_NumericalScalarCollection,
 
8289
  &_swigt__p_NumericalScalarPersistentCollection,
 
8290
  &_swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters,
 
8291
  &_swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult,
 
8292
  &_swigt__p_OT__Base__Stat__RandomGeneratorState,
 
8293
  &_swigt__p_OpenTURNS__Advocate,
 
8294
  &_swigt__p_OpenTURNS__Base__Common__ComparisonOperator,
 
8295
  &_swigt__p_OpenTURNS__Base__Common__ComparisonOperatorImplementation,
 
8296
  &_swigt__p_OpenTURNS__Base__Common__Equal,
 
8297
  &_swigt__p_OpenTURNS__Base__Common__Greater,
 
8298
  &_swigt__p_OpenTURNS__Base__Common__GreaterOrEqual,
 
8299
  &_swigt__p_OpenTURNS__Base__Common__InterfaceObject,
 
8300
  &_swigt__p_OpenTURNS__Base__Common__Less,
 
8301
  &_swigt__p_OpenTURNS__Base__Common__LessOrEqual,
 
8302
  &_swigt__p_OpenTURNS__Base__Common__Object,
 
8303
  &_swigt__p_OpenTURNS__Base__Common__PersistentObject,
 
8304
  &_swigt__p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t,
 
8305
  &_swigt__p_OpenTURNS__Base__Common__StorageManager,
 
8306
  &_swigt__p_OpenTURNS__Base__Common__Study,
 
8307
  &_swigt__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t,
 
8308
  &_swigt__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t,
 
8309
  &_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Common__ComparisonOperatorImplementation_t,
 
8310
  &_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__NumericalMathFunctionImplementation_t,
 
8311
  &_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__UniVariatePolynomialImplementation_t,
 
8312
  &_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__HistoryStrategyImplementation_t,
 
8313
  &_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation_t,
 
8314
  &_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t,
 
8315
  &_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t,
 
8316
  &_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__MatrixImplementation_t,
 
8317
  &_swigt__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__TensorImplementation_t,
 
8318
  &_swigt__p_OpenTURNS__Base__Common__XMLStorageManager,
 
8319
  &_swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient,
 
8320
  &_swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian,
 
8321
  &_swigt__p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient,
 
8322
  &_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation,
 
8323
  &_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathFunction,
 
8324
  &_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation,
 
8325
  &_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation,
 
8326
  &_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation,
 
8327
  &_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation,
 
8328
  &_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation,
 
8329
  &_swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation,
 
8330
  &_swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation,
 
8331
  &_swigt__p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation,
 
8332
  &_swigt__p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation,
 
8333
  &_swigt__p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation,
 
8334
  &_swigt__p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation,
 
8335
  &_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation,
 
8336
  &_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathFunction,
 
8337
  &_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation,
 
8338
  &_swigt__p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation,
 
8339
  &_swigt__p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation,
 
8340
  &_swigt__p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation,
 
8341
  &_swigt__p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation,
 
8342
  &_swigt__p_OpenTURNS__Base__Func__NumericalMathFunction,
 
8343
  &_swigt__p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation,
 
8344
  &_swigt__p_OpenTURNS__Base__Func__NumericalMathGradientImplementation,
 
8345
  &_swigt__p_OpenTURNS__Base__Func__NumericalMathHessianImplementation,
 
8346
  &_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation,
 
8347
  &_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathFunction,
 
8348
  &_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation,
 
8349
  &_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation,
 
8350
  &_swigt__p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation,
 
8351
  &_swigt__p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation,
 
8352
  &_swigt__p_OpenTURNS__Base__Func__UniVariatePolynomial,
 
8353
  &_swigt__p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation,
 
8354
  &_swigt__p_OpenTURNS__Base__Func__WrapperData,
 
8355
  &_swigt__p_OpenTURNS__Base__Func__WrapperDataFile,
 
8356
  &_swigt__p_OpenTURNS__Base__Func__WrapperDataVariable,
 
8357
  &_swigt__p_OpenTURNS__Base__Func__WrapperFile,
 
8358
  &_swigt__p_OpenTURNS__Base__Func__WrapperFrameworkData,
 
8359
  &_swigt__p_OpenTURNS__Base__Func__WrapperFunctionDescription,
 
8360
  &_swigt__p_OpenTURNS__Base__Func__WrapperParameter,
 
8361
  &_swigt__p_OpenTURNS__Base__Stat__Compact,
 
8362
  &_swigt__p_OpenTURNS__Base__Stat__ConfidenceInterval,
 
8363
  &_swigt__p_OpenTURNS__Base__Stat__CorrelationMatrix,
 
8364
  &_swigt__p_OpenTURNS__Base__Stat__CovarianceMatrix,
 
8365
  &_swigt__p_OpenTURNS__Base__Stat__Full,
 
8366
  &_swigt__p_OpenTURNS__Base__Stat__HaltonSequence,
 
8367
  &_swigt__p_OpenTURNS__Base__Stat__HistoryStrategy,
 
8368
  &_swigt__p_OpenTURNS__Base__Stat__HistoryStrategyImplementation,
 
8369
  &_swigt__p_OpenTURNS__Base__Stat__Last,
 
8370
  &_swigt__p_OpenTURNS__Base__Stat__LinearModel,
 
8371
  &_swigt__p_OpenTURNS__Base__Stat__LowDiscrepancySequence,
 
8372
  &_swigt__p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation,
 
8373
  &_swigt__p_OpenTURNS__Base__Stat__Null,
 
8374
  &_swigt__p_OpenTURNS__Base__Stat__NumericalSample,
 
8375
  &_swigt__p_OpenTURNS__Base__Stat__NumericalSampleImplementation,
 
8376
  &_swigt__p_OpenTURNS__Base__Stat__SobolSequence,
 
8377
  &_swigt__p_OpenTURNS__Base__Stat__TestResult,
 
8378
  &_swigt__p_OpenTURNS__Base__Type__Description,
 
8379
  &_swigt__p_OpenTURNS__Base__Type__DescriptionImplementation,
 
8380
  &_swigt__p_OpenTURNS__Base__Type__IdentityMatrix,
 
8381
  &_swigt__p_OpenTURNS__Base__Type__Indices,
 
8382
  &_swigt__p_OpenTURNS__Base__Type__Interval,
 
8383
  &_swigt__p_OpenTURNS__Base__Type__Matrix,
 
8384
  &_swigt__p_OpenTURNS__Base__Type__MatrixImplementation,
 
8385
  &_swigt__p_OpenTURNS__Base__Type__NumericalPoint,
 
8386
  &_swigt__p_OpenTURNS__Base__Type__NumericalPointWithDescription,
 
8387
  &_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_t,
 
8388
  &_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_t,
 
8389
  &_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_t,
 
8390
  &_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_double_t,
 
8391
  &_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_t,
 
8392
  &_swigt__p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_t,
 
8393
  &_swigt__p_OpenTURNS__Base__Type__SquareMatrix,
 
8394
  &_swigt__p_OpenTURNS__Base__Type__SymmetricMatrix,
 
8395
  &_swigt__p_OpenTURNS__Base__Type__SymmetricTensor,
 
8396
  &_swigt__p_OpenTURNS__Base__Type__Tensor,
 
8397
  &_swigt__p_OpenTURNS__Base__Type__TensorImplementation,
 
8398
  &_swigt__p_OpenTURNS__PointInSourceFile,
 
8399
  &_swigt__p_OutOfBoundException,
 
8400
  &_swigt__p_PersistentObject,
 
8401
  &_swigt__p_PolynomialCollection,
 
8402
  &_swigt__p_PolynomialPersistentCollection,
 
8403
  &_swigt__p_Severity,
 
8404
  &_swigt__p_SobolIndiceParameters,
 
8405
  &_swigt__p_SobolIndiceResult,
 
8406
  &_swigt__p_SquareMatrix,
 
8407
  &_swigt__p_State,
 
8408
  &_swigt__p_StorageManager,
 
8409
  &_swigt__p_StorageManagerImplementation,
 
8410
  &_swigt__p_SymmetricTensor,
 
8411
  &_swigt__p_Tensor,
 
8412
  &_swigt__p_UnsignedLongCollection,
 
8413
  &_swigt__p_Value,
 
8414
  &_swigt__p_ValueType,
 
8415
  &_swigt__p_VariableListType,
 
8416
  &_swigt__p_WrapperFileParsingException,
 
8417
  &_swigt__p_WrapperInternalException,
 
8418
  &_swigt__p_allocator_type,
 
8419
  &_swigt__p_bool,
 
8420
  &_swigt__p_char,
 
8421
  &_swigt__p_const_iterator,
 
8422
  &_swigt__p_const_reverse_iterator,
 
8423
  &_swigt__p_difference_type,
 
8424
  &_swigt__p_double,
 
8425
  &_swigt__p_iterator,
 
8426
  &_swigt__p_key_type,
 
8427
  &_swigt__p_long,
 
8428
  &_swigt__p_mapped_type,
 
8429
  &_swigt__p_pointer_type,
 
8430
  &_swigt__p_reverse_iterator,
 
8431
  &_swigt__p_size_type,
 
8432
  &_swigt__p_std__complexT_double_t,
 
8433
  &_swigt__p_std__invalid_argument,
 
8434
  &_swigt__p_std__string,
 
8435
  &_swigt__p_swig__PySwigIterator,
 
8436
  &_swigt__p_unsigned_long,
 
8437
  &_swigt__p_value_type,
 
8438
};
 
8439
 
 
8440
static swig_cast_info _swigc__p_BoolCollection[] = {  {&_swigt__p_BoolCollection, 0, 0, 0},{0, 0, 0, 0}};
 
8441
static swig_cast_info _swigc__p_BoolPersistentCollection[] = {  {&_swigt__p_BoolPersistentCollection, 0, 0, 0},{0, 0, 0, 0}};
 
8442
static swig_cast_info _swigc__p_CacheImplementation[] = {  {&_swigt__p_CacheImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8443
static swig_cast_info _swigc__p_CacheKeyType[] = {  {&_swigt__p_CacheKeyType, 0, 0, 0},{0, 0, 0, 0}};
 
8444
static swig_cast_info _swigc__p_CacheType[] = {  {&_swigt__p_CacheType, 0, 0, 0},{0, 0, 0, 0}};
 
8445
static swig_cast_info _swigc__p_CacheValueType[] = {  {&_swigt__p_CacheValueType, 0, 0, 0},{0, 0, 0, 0}};
 
8446
static swig_cast_info _swigc__p_Coefficients[] = {  {&_swigt__p_Coefficients, 0, 0, 0},{0, 0, 0, 0}};
 
8447
static swig_cast_info _swigc__p_ComparisonOperator[] = {  {&_swigt__p_ComparisonOperator, 0, 0, 0},{0, 0, 0, 0}};
 
8448
static swig_cast_info _swigc__p_ConfidenceIntervalCollection[] = {  {&_swigt__p_ConfidenceIntervalCollection, 0, 0, 0},{0, 0, 0, 0}};
 
8449
static swig_cast_info _swigc__p_ConfidenceIntervalPersistentCollection[] = {  {&_swigt__p_ConfidenceIntervalPersistentCollection, 0, 0, 0},{0, 0, 0, 0}};
 
8450
static swig_cast_info _swigc__p_CorrelationMatrix[] = {  {&_swigt__p_CorrelationMatrix, 0, 0, 0},{0, 0, 0, 0}};
 
8451
static swig_cast_info _swigc__p_CovarianceMatrix[] = {  {&_swigt__p_CovarianceMatrix, 0, 0, 0},{0, 0, 0, 0}};
 
8452
static swig_cast_info _swigc__p_Description[] = {  {&_swigt__p_Description, 0, 0, 0},{0, 0, 0, 0}};
 
8453
static swig_cast_info _swigc__p_DirectoryList[] = {  {&_swigt__p_DirectoryList, 0, 0, 0},{0, 0, 0, 0}};
 
8454
static swig_cast_info _swigc__p_ElementType[] = {  {&_swigt__p_ElementType, 0, 0, 0},{0, 0, 0, 0}};
 
8455
static swig_cast_info _swigc__p_EvaluationImplementation[] = {  {&_swigt__p_EvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8456
static swig_cast_info _swigc__p_FileListType[] = {  {&_swigt__p_FileListType, 0, 0, 0},{0, 0, 0, 0}};
 
8457
static swig_cast_info _swigc__p_FileNotFoundException[] = {  {&_swigt__p_FileNotFoundException, 0, 0, 0},{0, 0, 0, 0}};
 
8458
static swig_cast_info _swigc__p_GradientImplementation[] = {  {&_swigt__p_GradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8459
static swig_cast_info _swigc__p_Graph[] = {  {&_swigt__p_Graph, 0, 0, 0},{0, 0, 0, 0}};
 
8460
static swig_cast_info _swigc__p_HessianImplementation[] = {  {&_swigt__p_HessianImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8461
static swig_cast_info _swigc__p_IdentityMatrix[] = {  {&_swigt__p_IdentityMatrix, 0, 0, 0},{0, 0, 0, 0}};
 
8462
static swig_cast_info _swigc__p_Implementation[] = {  {&_swigt__p_Implementation, 0, 0, 0},{0, 0, 0, 0}};
 
8463
static swig_cast_info _swigc__p_ImplementationAsPersistentObject[] = {  {&_swigt__p_ImplementationAsPersistentObject, 0, 0, 0},{0, 0, 0, 0}};
 
8464
static swig_cast_info _swigc__p_ImplementationElementType[] = {  {&_swigt__p_ImplementationElementType, 0, 0, 0},{0, 0, 0, 0}};
 
8465
static swig_cast_info _swigc__p_ImplementationType[] = {  {&_swigt__p_ImplementationType, 0, 0, 0},{0, 0, 0, 0}};
 
8466
static swig_cast_info _swigc__p_Indices[] = {  {&_swigt__p_Indices, 0, 0, 0},{0, 0, 0, 0}};
 
8467
static swig_cast_info _swigc__p_InternalException[] = {  {&_swigt__p_InternalException, 0, 0, 0},{0, 0, 0, 0}};
 
8468
static swig_cast_info _swigc__p_InternalFunction[] = {  {&_swigt__p_InternalFunction, 0, 0, 0},{0, 0, 0, 0}};
 
8469
static swig_cast_info _swigc__p_InternalGradient[] = {  {&_swigt__p_InternalGradient, 0, 0, 0},{0, 0, 0, 0}};
 
8470
static swig_cast_info _swigc__p_InternalHessian[] = {  {&_swigt__p_InternalHessian, 0, 0, 0},{0, 0, 0, 0}};
 
8471
static swig_cast_info _swigc__p_InternalType[] = {  {&_swigt__p_InternalType, 0, 0, 0},{0, 0, 0, 0}};
 
8472
static swig_cast_info _swigc__p_Interval[] = {  {&_swigt__p_Interval, 0, 0, 0},{0, 0, 0, 0}};
 
8473
static swig_cast_info _swigc__p_InvalidArgumentException[] = {  {&_swigt__p_InvalidArgumentException, 0, 0, 0},{0, 0, 0, 0}};
 
8474
static swig_cast_info _swigc__p_InvalidDimensionException[] = {  {&_swigt__p_InvalidDimensionException, 0, 0, 0},{0, 0, 0, 0}};
 
8475
static swig_cast_info _swigc__p_KeyType[] = {  {&_swigt__p_KeyType, 0, 0, 0},{0, 0, 0, 0}};
 
8476
static swig_cast_info _swigc__p_LabelMap[] = {  {&_swigt__p_LabelMap, 0, 0, 0},{0, 0, 0, 0}};
 
8477
static swig_cast_info _swigc__p_Map[] = {  {&_swigt__p_Map, 0, 0, 0},{0, 0, 0, 0}};
 
8478
static swig_cast_info _swigc__p_MapElement[] = {  {&_swigt__p_MapElement, 0, 0, 0},{0, 0, 0, 0}};
 
8479
static swig_cast_info _swigc__p_MappedType[] = {  {&_swigt__p_MappedType, 0, 0, 0},{0, 0, 0, 0}};
 
8480
static swig_cast_info _swigc__p_Matrix[] = {  {&_swigt__p_Matrix, 0, 0, 0},{0, 0, 0, 0}};
 
8481
static swig_cast_info _swigc__p_MersenneTwister[] = {  {&_swigt__p_MersenneTwister, 0, 0, 0},{0, 0, 0, 0}};
 
8482
static swig_cast_info _swigc__p_NoWrapperFileFoundException[] = {  {&_swigt__p_NoWrapperFileFoundException, 0, 0, 0},{0, 0, 0, 0}};
 
8483
static swig_cast_info _swigc__p_NumericalComplexCollection[] = {  {&_swigt__p_NumericalComplexCollection, 0, 0, 0},{0, 0, 0, 0}};
 
8484
static swig_cast_info _swigc__p_NumericalMathFunction[] = {  {&_swigt__p_NumericalMathFunction, 0, 0, 0},{0, 0, 0, 0}};
 
8485
static swig_cast_info _swigc__p_NumericalMathFunctionCollection[] = {  {&_swigt__p_NumericalMathFunctionCollection, 0, 0, 0},{0, 0, 0, 0}};
 
8486
static swig_cast_info _swigc__p_NumericalMathFunctionPersistentCollection[] = {  {&_swigt__p_NumericalMathFunctionPersistentCollection, 0, 0, 0},{0, 0, 0, 0}};
 
8487
static swig_cast_info _swigc__p_NumericalPoint[] = {  {&_swigt__p_NumericalPoint, 0, 0, 0},{0, 0, 0, 0}};
 
8488
static swig_cast_info _swigc__p_NumericalPointWithDescription[] = {  {&_swigt__p_NumericalPointWithDescription, 0, 0, 0},{0, 0, 0, 0}};
 
8489
static swig_cast_info _swigc__p_NumericalSample[] = {  {&_swigt__p_NumericalSample, 0, 0, 0},{0, 0, 0, 0}};
 
8490
static swig_cast_info _swigc__p_NumericalScalarCollection[] = {  {&_swigt__p_NumericalScalarCollection, 0, 0, 0},{0, 0, 0, 0}};
 
8491
static swig_cast_info _swigc__p_NumericalScalarPersistentCollection[] = {  {&_swigt__p_NumericalScalarPersistentCollection, 0, 0, 0},{0, 0, 0, 0}};
 
8492
static swig_cast_info _swigc__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters[] = {  {&_swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters, 0, 0, 0},{0, 0, 0, 0}};
 
8493
static swig_cast_info _swigc__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult[] = {  {&_swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult, 0, 0, 0},{0, 0, 0, 0}};
 
8494
static swig_cast_info _swigc__p_OT__Base__Stat__RandomGeneratorState[] = {  {&_swigt__p_OT__Base__Stat__RandomGeneratorState, 0, 0, 0},{0, 0, 0, 0}};
 
8495
static swig_cast_info _swigc__p_OpenTURNS__Advocate[] = {  {&_swigt__p_OpenTURNS__Advocate, 0, 0, 0},{0, 0, 0, 0}};
 
8496
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__ComparisonOperator[] = {{&_swigt__p_OpenTURNS__Base__Common__ComparisonOperator, 0, 0, 0},{0, 0, 0, 0}};
 
8497
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__LinearNumericalMathFunction[] = {{&_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathFunction, 0, 0, 0},{0, 0, 0, 0}};
 
8498
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__WrapperDataVariable[] = {{&_swigt__p_OpenTURNS__Base__Func__WrapperDataVariable, 0, 0, 0},{0, 0, 0, 0}};
 
8499
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__TensorImplementation[] = {{&_swigt__p_OpenTURNS__Base__Type__TensorImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8500
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__MatrixImplementation[] = {{&_swigt__p_OpenTURNS__Base__Type__MatrixImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8501
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ProductNumericalMathFunction[] = {{&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathFunction, 0, 0, 0},{0, 0, 0, 0}};
 
8502
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__NumericalPointWithDescription[] = {{&_swigt__p_OpenTURNS__Base__Type__NumericalPointWithDescription, 0, 0, 0},{0, 0, 0, 0}};
 
8503
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8504
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8505
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8506
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8507
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__Equal[] = {{&_swigt__p_OpenTURNS__Base__Common__Equal, 0, 0, 0},{0, 0, 0, 0}};
 
8508
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8509
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}};
 
8510
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}};
 
8511
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}};
 
8512
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}};
 
8513
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}};
 
8514
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}};
 
8515
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}};
 
8516
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}};
 
8517
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}};
 
8518
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__TestResult[] = {{&_swigt__p_OpenTURNS__Base__Stat__TestResult, 0, 0, 0},{0, 0, 0, 0}};
 
8519
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8520
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8521
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8522
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__Greater[] = {{&_swigt__p_OpenTURNS__Base__Common__Greater, 0, 0, 0},{0, 0, 0, 0}};
 
8523
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__CorrelationMatrix[] = {{&_swigt__p_OpenTURNS__Base__Stat__CorrelationMatrix, 0, 0, 0},{0, 0, 0, 0}};
 
8524
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__ComparisonOperatorImplementation[] = {{&_swigt__p_OpenTURNS__Base__Common__ComparisonOperatorImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8525
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8526
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}};
 
8527
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8528
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8529
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__GreaterOrEqual[] = {{&_swigt__p_OpenTURNS__Base__Common__GreaterOrEqual, 0, 0, 0},{0, 0, 0, 0}};
 
8530
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__LessOrEqual[] = {{&_swigt__p_OpenTURNS__Base__Common__LessOrEqual, 0, 0, 0},{0, 0, 0, 0}};
 
8531
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__WrapperFunctionDescription[] = {{&_swigt__p_OpenTURNS__Base__Func__WrapperFunctionDescription, 0, 0, 0},{0, 0, 0, 0}};
 
8532
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__InterfaceObject[] = {{&_swigt__p_OpenTURNS__Base__Common__InterfaceObject, 0, 0, 0},{0, 0, 0, 0}};
 
8533
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__Study[] = {{&_swigt__p_OpenTURNS__Base__Common__Study, 0, 0, 0},{0, 0, 0, 0}};
 
8534
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__Indices[] = {{&_swigt__p_OpenTURNS__Base__Type__Indices, 0, 0, 0},{0, 0, 0, 0}};
 
8535
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__Full[] = {{&_swigt__p_OpenTURNS__Base__Stat__Full, 0, 0, 0},{0, 0, 0, 0}};
 
8536
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__Tensor[] = {{&_swigt__p_OpenTURNS__Base__Type__Tensor, 0, 0, 0},{0, 0, 0, 0}};
 
8537
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}};
 
8538
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8539
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8540
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8541
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8542
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8543
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation[] = {{&_swigt__p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8544
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}};
 
8545
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathFunction[] = {{&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathFunction, 0, 0, 0},{0, 0, 0, 0}};
 
8546
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__NumericalSample[] = {{&_swigt__p_OpenTURNS__Base__Stat__NumericalSample, 0, 0, 0},{0, 0, 0, 0}};
 
8547
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__Description[] = {{&_swigt__p_OpenTURNS__Base__Type__Description, 0, 0, 0},{0, 0, 0, 0}};
 
8548
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__HistoryStrategyImplementation[] = {{&_swigt__p_OpenTURNS__Base__Stat__HistoryStrategyImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8549
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__NumericalSampleImplementation[] = {{&_swigt__p_OpenTURNS__Base__Stat__NumericalSampleImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8550
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__Less[] = {{&_swigt__p_OpenTURNS__Base__Common__Less, 0, 0, 0},{0, 0, 0, 0}};
 
8551
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__WrapperFrameworkData[] = {{&_swigt__p_OpenTURNS__Base__Func__WrapperFrameworkData, 0, 0, 0},{0, 0, 0, 0}};
 
8552
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8553
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NumericalMathFunction[] = {{&_swigt__p_OpenTURNS__Base__Func__NumericalMathFunction, 0, 0, 0},{0, 0, 0, 0}};
 
8554
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__ConfidenceInterval[] = {{&_swigt__p_OpenTURNS__Base__Stat__ConfidenceInterval, 0, 0, 0},{0, 0, 0, 0}};
 
8555
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__Interval[] = {{&_swigt__p_OpenTURNS__Base__Type__Interval, 0, 0, 0},{0, 0, 0, 0}};
 
8556
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__Null[] = {{&_swigt__p_OpenTURNS__Base__Stat__Null, 0, 0, 0},{0, 0, 0, 0}};
 
8557
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}};
 
8558
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}};
 
8559
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8560
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__StorageManager[] = {{&_swigt__p_OpenTURNS__Base__Common__StorageManager, 0, 0, 0},{0, 0, 0, 0}};
 
8561
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__XMLStorageManager[] = {{&_swigt__p_OpenTURNS__Base__Common__XMLStorageManager, 0, 0, 0},{0, 0, 0, 0}};
 
8562
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__WrapperData[] = {{&_swigt__p_OpenTURNS__Base__Func__WrapperData, 0, 0, 0},{0, 0, 0, 0}};
 
8563
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__HaltonSequence[] = {{&_swigt__p_OpenTURNS__Base__Stat__HaltonSequence, 0, 0, 0},{0, 0, 0, 0}};
 
8564
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__SobolSequence[] = {{&_swigt__p_OpenTURNS__Base__Stat__SobolSequence, 0, 0, 0},{0, 0, 0, 0}};
 
8565
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__LowDiscrepancySequence[] = {{&_swigt__p_OpenTURNS__Base__Stat__LowDiscrepancySequence, 0, 0, 0},{0, 0, 0, 0}};
 
8566
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__HistoryStrategy[] = {{&_swigt__p_OpenTURNS__Base__Stat__HistoryStrategy, 0, 0, 0},{0, 0, 0, 0}};
 
8567
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8568
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8569
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__WrapperFile[] = {{&_swigt__p_OpenTURNS__Base__Func__WrapperFile, 0, 0, 0},{0, 0, 0, 0}};
 
8570
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__Last[] = {{&_swigt__p_OpenTURNS__Base__Stat__Last, 0, 0, 0},{0, 0, 0, 0}};
 
8571
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__SquareMatrix[] = {{&_swigt__p_OpenTURNS__Base__Type__SquareMatrix, 0, 0, 0},{0, 0, 0, 0}};
 
8572
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__SymmetricMatrix[] = {{&_swigt__p_OpenTURNS__Base__Type__SymmetricMatrix, 0, 0, 0},{0, 0, 0, 0}};
 
8573
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__CovarianceMatrix[] = {{&_swigt__p_OpenTURNS__Base__Stat__CovarianceMatrix, 0, 0, 0},{0, 0, 0, 0}};
 
8574
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__IdentityMatrix[] = {{&_swigt__p_OpenTURNS__Base__Type__IdentityMatrix, 0, 0, 0},{0, 0, 0, 0}};
 
8575
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__Compact[] = {{&_swigt__p_OpenTURNS__Base__Stat__Compact, 0, 0, 0},{0, 0, 0, 0}};
 
8576
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8577
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8578
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__UniVariatePolynomial[] = {{&_swigt__p_OpenTURNS__Base__Func__UniVariatePolynomial, 0, 0, 0},{0, 0, 0, 0}};
 
8579
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__DescriptionImplementation[] = {{&_swigt__p_OpenTURNS__Base__Type__DescriptionImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8580
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8581
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__WrapperDataFile[] = {{&_swigt__p_OpenTURNS__Base__Func__WrapperDataFile, 0, 0, 0},{0, 0, 0, 0}};
 
8582
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__WrapperParameter[] = {{&_swigt__p_OpenTURNS__Base__Func__WrapperParameter, 0, 0, 0},{0, 0, 0, 0}};
 
8583
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}};
 
8584
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}};
 
8585
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}};
 
8586
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8587
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation[] = {{&_swigt__p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8588
static swig_cast_info _swigc__p_OpenTURNS__Base__Stat__LinearModel[] = {{&_swigt__p_OpenTURNS__Base__Stat__LinearModel, 0, 0, 0},{0, 0, 0, 0}};
 
8589
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__Object[] = {  {&_swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters, _p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParametersTo_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__Base__Func__LinearNumericalMathFunction, _p_OpenTURNS__Base__Func__LinearNumericalMathFunctionTo_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__Base__Func__WrapperDataVariable, _p_OpenTURNS__Base__Func__WrapperDataVariableTo_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_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult, _p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResultTo_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__Func__NumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__NumericalMathHessianImplementationTo_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__ProductNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementationTo_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__ConstantNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementationTo_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__Common__Equal, _p_OpenTURNS__Base__Common__EqualTo_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__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__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__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__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__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__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__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__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__Func__UniVariatePolynomialImplementation_t, _p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__UniVariatePolynomialImplementation_tTo_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__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__Greater, _p_OpenTURNS__Base__Common__GreaterTo_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__Base__Common__ComparisonOperatorImplementation, _p_OpenTURNS__Base__Common__ComparisonOperatorImplementationTo_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__Base__Type__PersistentCollectionT_unsigned_long_t, _p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_tTo_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__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__Common__GreaterOrEqual, _p_OpenTURNS__Base__Common__GreaterOrEqualTo_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__Func__WrapperFunctionDescription, _p_OpenTURNS__Base__Func__WrapperFunctionDescriptionTo_p_OpenTURNS__Base__Common__Object, 0, 0},  {&_swigt__p_OpenTURNS__Base__Common__InterfaceObject, _p_OpenTURNS__Base__Common__InterfaceObjectTo_p_OpenTURNS__Base__Common__Object, 0, 0},  {&_swigt__p_OpenTURNS__Base__Common__Object, 0, 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__Indices, _p_OpenTURNS__Base__Type__IndicesTo_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__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__Base__Func__LinearCombinationGradientImplementation, _p_OpenTURNS__Base__Func__LinearCombinationGradientImplementationTo_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__Func__LinearNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementationTo_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__Base__Func__NoNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementationTo_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__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__NumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__NumericalMathGradientImplementationTo_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__Stat__NumericalSample, _p_OpenTURNS__Base__Stat__NumericalSampleTo_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__Base__Stat__HistoryStrategyImplementation, _p_OpenTURNS__Base__Stat__HistoryStrategyImplementationTo_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__Common__Less, _p_OpenTURNS__Base__Common__LessTo_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__Func__ProductNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementationTo_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__Base__Stat__ConfidenceInterval, _p_OpenTURNS__Base__Stat__ConfidenceIntervalTo_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__Null, _p_OpenTURNS__Base__Stat__NullTo_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__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__Func__NoNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementationTo_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__Base__Diff__NonCenteredFiniteDifferenceGradient, _p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradientTo_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__Base__Common__PersistentObject, _p_OpenTURNS__Base__Common__PersistentObjectTo_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__Stat__SobolSequence, _p_OpenTURNS__Base__Stat__SobolSequenceTo_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__HistoryStrategy, _p_OpenTURNS__Base__Stat__HistoryStrategyTo_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__Base__Func__UniVariatePolynomialImplementation, _p_OpenTURNS__Base__Func__UniVariatePolynomialImplementationTo_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__Base__Stat__Last, _p_OpenTURNS__Base__Stat__LastTo_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__Compact, _p_OpenTURNS__Base__Stat__CompactTo_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__UniVariatePolynomial, _p_OpenTURNS__Base__Func__UniVariatePolynomialTo_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_OpenTURNS__Base__Func__LinearCombinationHessianImplementation, _p_OpenTURNS__Base__Func__LinearCombinationHessianImplementationTo_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__WrapperParameter, _p_OpenTURNS__Base__Func__WrapperParameterTo_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__Base__Stat__LinearModel, _p_OpenTURNS__Base__Stat__LinearModelTo_p_OpenTURNS__Base__Common__Object, 0, 0},{0, 0, 0, 0}};
 
8590
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__PersistentObject[] = {  {&_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__ProductNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementationTo_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__Type__NumericalPoint, _p_OpenTURNS__Base__Type__NumericalPointTo_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__Base__Func__ComposedNumericalMathFunction, _p_OpenTURNS__Base__Func__ComposedNumericalMathFunctionTo_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__Base__Common__Equal, _p_OpenTURNS__Base__Common__EqualTo_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_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__NumericalMathFunctionImplementation, _p_OpenTURNS__Base__Func__NumericalMathFunctionImplementationTo_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__NoNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementationTo_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_OpenTURNS__Base__Stat__LinearModel, _p_OpenTURNS__Base__Stat__LinearModelTo_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__Base__Func__NoNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementationTo_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__Base__Stat__Null, _p_OpenTURNS__Base__Stat__NullTo_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__Base__Func__NumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementationTo_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__Stat__Full, _p_OpenTURNS__Base__Stat__FullTo_p_OpenTURNS__Base__Common__PersistentObject, 0, 0},  {&_swigt__p_OpenTURNS__Base__Common__PersistentObject, 0, 0, 0},  {&_swigt__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters, _p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParametersTo_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_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult, _p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResultTo_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_OpenTURNS__Base__Common__Less, _p_OpenTURNS__Base__Common__LessTo_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__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__Base__Func__NoNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementationTo_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__Base__Func__LinearNumericalMathEvaluationImplementation, _p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementationTo_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__Func__LinearNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementationTo_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__Func__UniVariatePolynomialImplementation, _p_OpenTURNS__Base__Func__UniVariatePolynomialImplementationTo_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__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__Func__ComposedNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementationTo_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__Base__Type__PersistentCollectionT_unsigned_long_t, _p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_tTo_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__Func__ComputedNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementationTo_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__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},  {&_swigt__p_OpenTURNS__Base__Common__ComparisonOperatorImplementation, _p_OpenTURNS__Base__Common__ComparisonOperatorImplementationTo_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__Base__Common__Greater, _p_OpenTURNS__Base__Common__GreaterTo_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__ProductNumericalMathFunction, _p_OpenTURNS__Base__Func__ProductNumericalMathFunctionTo_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},{0, 0, 0, 0}};
 
8591
static swig_cast_info _swigc__p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t[] = {  {&_swigt__p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
 
8592
static swig_cast_info _swigc__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient[] = {  {&_swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, 0, 0, 0},{0, 0, 0, 0}};
 
8593
static swig_cast_info _swigc__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian[] = {  {&_swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, 0, 0, 0},{0, 0, 0, 0}};
 
8594
static swig_cast_info _swigc__p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient[] = {  {&_swigt__p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, 0, 0, 0},{0, 0, 0, 0}};
 
8595
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NumericalMathGradientImplementation[] = {  {&_swigt__p_OpenTURNS__Base__Func__NumericalMathGradientImplementation, 0, 0, 0},  {&_swigt__p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient, _p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation, 0, 0},  {&_swigt__p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation, 0, 0},  {&_swigt__p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation, _p_OpenTURNS__Base__Func__LinearCombinationGradientImplementationTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation, 0, 0},  {&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation, 0, 0},  {&_swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient, _p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradientTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation, 0, 0},  {&_swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation, 0, 0},  {&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation, 0, 0},  {&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation, 0, 0},  {&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation, _p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementationTo_p_OpenTURNS__Base__Func__NumericalMathGradientImplementation, 0, 0},{0, 0, 0, 0}};
 
8596
static swig_cast_info _swigc__p_OpenTURNS__Base__Func__NumericalMathHessianImplementation[] = {  {&_swigt__p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation, 0, 0},  {&_swigt__p_OpenTURNS__Base__Func__NumericalMathHessianImplementation, 0, 0, 0},  {&_swigt__p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation, 0, 0},  {&_swigt__p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation, 0, 0},  {&_swigt__p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation, 0, 0},  {&_swigt__p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation, _p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementationTo_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation, 0, 0},  {&_swigt__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian, _p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessianTo_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation, 0, 0},  {&_swigt__p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation, _p_OpenTURNS__Base__Func__LinearCombinationHessianImplementationTo_p_OpenTURNS__Base__Func__NumericalMathHessianImplementation, 0, 0},{0, 0, 0, 0}};
 
8597
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__Matrix[] = {  {&_swigt__p_OpenTURNS__Base__Stat__CorrelationMatrix, _p_OpenTURNS__Base__Stat__CorrelationMatrixTo_p_OpenTURNS__Base__Type__Matrix, 0, 0},  {&_swigt__p_OpenTURNS__Base__Type__Matrix, 0, 0, 0},  {&_swigt__p_OpenTURNS__Base__Type__SquareMatrix, _p_OpenTURNS__Base__Type__SquareMatrixTo_p_OpenTURNS__Base__Type__Matrix, 0, 0},  {&_swigt__p_OpenTURNS__Base__Type__SymmetricMatrix, _p_OpenTURNS__Base__Type__SymmetricMatrixTo_p_OpenTURNS__Base__Type__Matrix, 0, 0},  {&_swigt__p_OpenTURNS__Base__Stat__CovarianceMatrix, _p_OpenTURNS__Base__Stat__CovarianceMatrixTo_p_OpenTURNS__Base__Type__Matrix, 0, 0},  {&_swigt__p_OpenTURNS__Base__Type__IdentityMatrix, _p_OpenTURNS__Base__Type__IdentityMatrixTo_p_OpenTURNS__Base__Type__Matrix, 0, 0},{0, 0, 0, 0}};
 
8598
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__NumericalPoint[] = {  {&_swigt__p_OpenTURNS__Base__Type__NumericalPoint, 0, 0, 0},  {&_swigt__p_OpenTURNS__Base__Type__NumericalPointWithDescription, _p_OpenTURNS__Base__Type__NumericalPointWithDescriptionTo_p_OpenTURNS__Base__Type__NumericalPoint, 0, 0},{0, 0, 0, 0}};
 
8599
static swig_cast_info _swigc__p_OpenTURNS__Base__Type__SymmetricTensor[] = {  {&_swigt__p_OpenTURNS__Base__Type__SymmetricTensor, 0, 0, 0},{0, 0, 0, 0}};
 
8600
static swig_cast_info _swigc__p_OpenTURNS__PointInSourceFile[] = {  {&_swigt__p_OpenTURNS__PointInSourceFile, 0, 0, 0},{0, 0, 0, 0}};
 
8601
static swig_cast_info _swigc__p_OutOfBoundException[] = {  {&_swigt__p_OutOfBoundException, 0, 0, 0},{0, 0, 0, 0}};
 
8602
static swig_cast_info _swigc__p_PersistentObject[] = {  {&_swigt__p_PersistentObject, 0, 0, 0},{0, 0, 0, 0}};
 
8603
static swig_cast_info _swigc__p_PolynomialCollection[] = {  {&_swigt__p_PolynomialCollection, 0, 0, 0},{0, 0, 0, 0}};
 
8604
static swig_cast_info _swigc__p_PolynomialPersistentCollection[] = {  {&_swigt__p_PolynomialPersistentCollection, 0, 0, 0},{0, 0, 0, 0}};
 
8605
static swig_cast_info _swigc__p_Severity[] = {  {&_swigt__p_Severity, 0, 0, 0},{0, 0, 0, 0}};
 
8606
static swig_cast_info _swigc__p_SobolIndiceParameters[] = {  {&_swigt__p_SobolIndiceParameters, 0, 0, 0},{0, 0, 0, 0}};
 
8607
static swig_cast_info _swigc__p_SobolIndiceResult[] = {  {&_swigt__p_SobolIndiceResult, 0, 0, 0},{0, 0, 0, 0}};
 
8608
static swig_cast_info _swigc__p_SquareMatrix[] = {  {&_swigt__p_SquareMatrix, 0, 0, 0},{0, 0, 0, 0}};
 
8609
static swig_cast_info _swigc__p_State[] = {  {&_swigt__p_State, 0, 0, 0},{0, 0, 0, 0}};
 
8610
static swig_cast_info _swigc__p_StorageManager[] = {  {&_swigt__p_StorageManager, 0, 0, 0},{0, 0, 0, 0}};
 
8611
static swig_cast_info _swigc__p_StorageManagerImplementation[] = {  {&_swigt__p_StorageManagerImplementation, 0, 0, 0},{0, 0, 0, 0}};
 
8612
static swig_cast_info _swigc__p_SymmetricTensor[] = {  {&_swigt__p_SymmetricTensor, 0, 0, 0},{0, 0, 0, 0}};
 
8613
static swig_cast_info _swigc__p_Tensor[] = {  {&_swigt__p_Tensor, 0, 0, 0},{0, 0, 0, 0}};
 
8614
static swig_cast_info _swigc__p_UnsignedLongCollection[] = {  {&_swigt__p_UnsignedLongCollection, 0, 0, 0},{0, 0, 0, 0}};
 
8615
static swig_cast_info _swigc__p_Value[] = {  {&_swigt__p_Value, 0, 0, 0},{0, 0, 0, 0}};
 
8616
static swig_cast_info _swigc__p_ValueType[] = {  {&_swigt__p_ValueType, 0, 0, 0},{0, 0, 0, 0}};
 
8617
static swig_cast_info _swigc__p_VariableListType[] = {  {&_swigt__p_VariableListType, 0, 0, 0},{0, 0, 0, 0}};
 
8618
static swig_cast_info _swigc__p_WrapperFileParsingException[] = {  {&_swigt__p_WrapperFileParsingException, 0, 0, 0},{0, 0, 0, 0}};
 
8619
static swig_cast_info _swigc__p_WrapperInternalException[] = {  {&_swigt__p_WrapperInternalException, 0, 0, 0},{0, 0, 0, 0}};
 
8620
static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
 
8621
static swig_cast_info _swigc__p_bool[] = {  {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
 
8622
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
 
8623
static swig_cast_info _swigc__p_const_iterator[] = {  {&_swigt__p_const_iterator, 0, 0, 0},{0, 0, 0, 0}};
 
8624
static swig_cast_info _swigc__p_const_reverse_iterator[] = {  {&_swigt__p_const_reverse_iterator, 0, 0, 0},{0, 0, 0, 0}};
 
8625
static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
 
8626
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
 
8627
static swig_cast_info _swigc__p_iterator[] = {  {&_swigt__p_iterator, 0, 0, 0},{0, 0, 0, 0}};
 
8628
static swig_cast_info _swigc__p_key_type[] = {  {&_swigt__p_key_type, 0, 0, 0},{0, 0, 0, 0}};
 
8629
static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
 
8630
static swig_cast_info _swigc__p_mapped_type[] = {  {&_swigt__p_mapped_type, 0, 0, 0},{0, 0, 0, 0}};
 
8631
static swig_cast_info _swigc__p_pointer_type[] = {  {&_swigt__p_pointer_type, 0, 0, 0},{0, 0, 0, 0}};
 
8632
static swig_cast_info _swigc__p_reverse_iterator[] = {  {&_swigt__p_reverse_iterator, 0, 0, 0},{0, 0, 0, 0}};
 
8633
static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
 
8634
static swig_cast_info _swigc__p_std__complexT_double_t[] = {  {&_swigt__p_std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
 
8635
static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
 
8636
static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
 
8637
static swig_cast_info _swigc__p_swig__PySwigIterator[] = {  {&_swigt__p_swig__PySwigIterator, 0, 0, 0},{0, 0, 0, 0}};
 
8638
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
 
8639
static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
 
8640
 
 
8641
static swig_cast_info *swig_cast_initial[] = {
 
8642
  _swigc__p_BoolCollection,
 
8643
  _swigc__p_BoolPersistentCollection,
 
8644
  _swigc__p_CacheImplementation,
 
8645
  _swigc__p_CacheKeyType,
 
8646
  _swigc__p_CacheType,
 
8647
  _swigc__p_CacheValueType,
 
8648
  _swigc__p_Coefficients,
 
8649
  _swigc__p_ComparisonOperator,
 
8650
  _swigc__p_ConfidenceIntervalCollection,
 
8651
  _swigc__p_ConfidenceIntervalPersistentCollection,
 
8652
  _swigc__p_CorrelationMatrix,
 
8653
  _swigc__p_CovarianceMatrix,
 
8654
  _swigc__p_Description,
 
8655
  _swigc__p_DirectoryList,
 
8656
  _swigc__p_ElementType,
 
8657
  _swigc__p_EvaluationImplementation,
 
8658
  _swigc__p_FileListType,
 
8659
  _swigc__p_FileNotFoundException,
 
8660
  _swigc__p_GradientImplementation,
 
8661
  _swigc__p_Graph,
 
8662
  _swigc__p_HessianImplementation,
 
8663
  _swigc__p_IdentityMatrix,
 
8664
  _swigc__p_Implementation,
 
8665
  _swigc__p_ImplementationAsPersistentObject,
 
8666
  _swigc__p_ImplementationElementType,
 
8667
  _swigc__p_ImplementationType,
 
8668
  _swigc__p_Indices,
 
8669
  _swigc__p_InternalException,
 
8670
  _swigc__p_InternalFunction,
 
8671
  _swigc__p_InternalGradient,
 
8672
  _swigc__p_InternalHessian,
 
8673
  _swigc__p_InternalType,
 
8674
  _swigc__p_Interval,
 
8675
  _swigc__p_InvalidArgumentException,
 
8676
  _swigc__p_InvalidDimensionException,
 
8677
  _swigc__p_KeyType,
 
8678
  _swigc__p_LabelMap,
 
8679
  _swigc__p_Map,
 
8680
  _swigc__p_MapElement,
 
8681
  _swigc__p_MappedType,
 
8682
  _swigc__p_Matrix,
 
8683
  _swigc__p_MersenneTwister,
 
8684
  _swigc__p_NoWrapperFileFoundException,
 
8685
  _swigc__p_NumericalComplexCollection,
 
8686
  _swigc__p_NumericalMathFunction,
 
8687
  _swigc__p_NumericalMathFunctionCollection,
 
8688
  _swigc__p_NumericalMathFunctionPersistentCollection,
 
8689
  _swigc__p_NumericalPoint,
 
8690
  _swigc__p_NumericalPointWithDescription,
 
8691
  _swigc__p_NumericalSample,
 
8692
  _swigc__p_NumericalScalarCollection,
 
8693
  _swigc__p_NumericalScalarPersistentCollection,
 
8694
  _swigc__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceParameters,
 
8695
  _swigc__p_OT__Base__Stat__CorrelationAnalysisSobolIndiceResult,
 
8696
  _swigc__p_OT__Base__Stat__RandomGeneratorState,
 
8697
  _swigc__p_OpenTURNS__Advocate,
 
8698
  _swigc__p_OpenTURNS__Base__Common__ComparisonOperator,
 
8699
  _swigc__p_OpenTURNS__Base__Common__ComparisonOperatorImplementation,
 
8700
  _swigc__p_OpenTURNS__Base__Common__Equal,
 
8701
  _swigc__p_OpenTURNS__Base__Common__Greater,
 
8702
  _swigc__p_OpenTURNS__Base__Common__GreaterOrEqual,
 
8703
  _swigc__p_OpenTURNS__Base__Common__InterfaceObject,
 
8704
  _swigc__p_OpenTURNS__Base__Common__Less,
 
8705
  _swigc__p_OpenTURNS__Base__Common__LessOrEqual,
 
8706
  _swigc__p_OpenTURNS__Base__Common__Object,
 
8707
  _swigc__p_OpenTURNS__Base__Common__PersistentObject,
 
8708
  _swigc__p_OpenTURNS__Base__Common__PointerT_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation_t,
 
8709
  _swigc__p_OpenTURNS__Base__Common__StorageManager,
 
8710
  _swigc__p_OpenTURNS__Base__Common__Study,
 
8711
  _swigc__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t,
 
8712
  _swigc__p_OpenTURNS__Base__Common__TypedCollectionInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t,
 
8713
  _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Common__ComparisonOperatorImplementation_t,
 
8714
  _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__NumericalMathFunctionImplementation_t,
 
8715
  _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Func__UniVariatePolynomialImplementation_t,
 
8716
  _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__HistoryStrategyImplementation_t,
 
8717
  _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation_t,
 
8718
  _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Stat__NumericalSampleImplementation_t,
 
8719
  _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__DescriptionImplementation_t,
 
8720
  _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__MatrixImplementation_t,
 
8721
  _swigc__p_OpenTURNS__Base__Common__TypedInterfaceObjectT_OpenTURNS__Base__Type__TensorImplementation_t,
 
8722
  _swigc__p_OpenTURNS__Base__Common__XMLStorageManager,
 
8723
  _swigc__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceGradient,
 
8724
  _swigc__p_OpenTURNS__Base__Diff__CenteredFiniteDifferenceHessian,
 
8725
  _swigc__p_OpenTURNS__Base__Diff__NonCenteredFiniteDifferenceGradient,
 
8726
  _swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathEvaluationImplementation,
 
8727
  _swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathFunction,
 
8728
  _swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathGradientImplementation,
 
8729
  _swigc__p_OpenTURNS__Base__Func__ComposedNumericalMathHessianImplementation,
 
8730
  _swigc__p_OpenTURNS__Base__Func__ComputedNumericalMathEvaluationImplementation,
 
8731
  _swigc__p_OpenTURNS__Base__Func__ComputedNumericalMathGradientImplementation,
 
8732
  _swigc__p_OpenTURNS__Base__Func__ComputedNumericalMathHessianImplementation,
 
8733
  _swigc__p_OpenTURNS__Base__Func__ConstantNumericalMathGradientImplementation,
 
8734
  _swigc__p_OpenTURNS__Base__Func__ConstantNumericalMathHessianImplementation,
 
8735
  _swigc__p_OpenTURNS__Base__Func__IndicatorNumericalMathEvaluationImplementation,
 
8736
  _swigc__p_OpenTURNS__Base__Func__LinearCombinationEvaluationImplementation,
 
8737
  _swigc__p_OpenTURNS__Base__Func__LinearCombinationGradientImplementation,
 
8738
  _swigc__p_OpenTURNS__Base__Func__LinearCombinationHessianImplementation,
 
8739
  _swigc__p_OpenTURNS__Base__Func__LinearNumericalMathEvaluationImplementation,
 
8740
  _swigc__p_OpenTURNS__Base__Func__LinearNumericalMathFunction,
 
8741
  _swigc__p_OpenTURNS__Base__Func__LinearNumericalMathGradientImplementation,
 
8742
  _swigc__p_OpenTURNS__Base__Func__NoNumericalMathEvaluationImplementation,
 
8743
  _swigc__p_OpenTURNS__Base__Func__NoNumericalMathGradientImplementation,
 
8744
  _swigc__p_OpenTURNS__Base__Func__NoNumericalMathHessianImplementation,
 
8745
  _swigc__p_OpenTURNS__Base__Func__NumericalMathEvaluationImplementation,
 
8746
  _swigc__p_OpenTURNS__Base__Func__NumericalMathFunction,
 
8747
  _swigc__p_OpenTURNS__Base__Func__NumericalMathFunctionImplementation,
 
8748
  _swigc__p_OpenTURNS__Base__Func__NumericalMathGradientImplementation,
 
8749
  _swigc__p_OpenTURNS__Base__Func__NumericalMathHessianImplementation,
 
8750
  _swigc__p_OpenTURNS__Base__Func__ProductNumericalMathEvaluationImplementation,
 
8751
  _swigc__p_OpenTURNS__Base__Func__ProductNumericalMathFunction,
 
8752
  _swigc__p_OpenTURNS__Base__Func__ProductNumericalMathGradientImplementation,
 
8753
  _swigc__p_OpenTURNS__Base__Func__ProductNumericalMathHessianImplementation,
 
8754
  _swigc__p_OpenTURNS__Base__Func__ProductPolynomialEvaluationImplementation,
 
8755
  _swigc__p_OpenTURNS__Base__Func__QuadraticNumericalMathEvaluationImplementation,
 
8756
  _swigc__p_OpenTURNS__Base__Func__UniVariatePolynomial,
 
8757
  _swigc__p_OpenTURNS__Base__Func__UniVariatePolynomialImplementation,
 
8758
  _swigc__p_OpenTURNS__Base__Func__WrapperData,
 
8759
  _swigc__p_OpenTURNS__Base__Func__WrapperDataFile,
 
8760
  _swigc__p_OpenTURNS__Base__Func__WrapperDataVariable,
 
8761
  _swigc__p_OpenTURNS__Base__Func__WrapperFile,
 
8762
  _swigc__p_OpenTURNS__Base__Func__WrapperFrameworkData,
 
8763
  _swigc__p_OpenTURNS__Base__Func__WrapperFunctionDescription,
 
8764
  _swigc__p_OpenTURNS__Base__Func__WrapperParameter,
 
8765
  _swigc__p_OpenTURNS__Base__Stat__Compact,
 
8766
  _swigc__p_OpenTURNS__Base__Stat__ConfidenceInterval,
 
8767
  _swigc__p_OpenTURNS__Base__Stat__CorrelationMatrix,
 
8768
  _swigc__p_OpenTURNS__Base__Stat__CovarianceMatrix,
 
8769
  _swigc__p_OpenTURNS__Base__Stat__Full,
 
8770
  _swigc__p_OpenTURNS__Base__Stat__HaltonSequence,
 
8771
  _swigc__p_OpenTURNS__Base__Stat__HistoryStrategy,
 
8772
  _swigc__p_OpenTURNS__Base__Stat__HistoryStrategyImplementation,
 
8773
  _swigc__p_OpenTURNS__Base__Stat__Last,
 
8774
  _swigc__p_OpenTURNS__Base__Stat__LinearModel,
 
8775
  _swigc__p_OpenTURNS__Base__Stat__LowDiscrepancySequence,
 
8776
  _swigc__p_OpenTURNS__Base__Stat__LowDiscrepancySequenceImplementation,
 
8777
  _swigc__p_OpenTURNS__Base__Stat__Null,
 
8778
  _swigc__p_OpenTURNS__Base__Stat__NumericalSample,
 
8779
  _swigc__p_OpenTURNS__Base__Stat__NumericalSampleImplementation,
 
8780
  _swigc__p_OpenTURNS__Base__Stat__SobolSequence,
 
8781
  _swigc__p_OpenTURNS__Base__Stat__TestResult,
 
8782
  _swigc__p_OpenTURNS__Base__Type__Description,
 
8783
  _swigc__p_OpenTURNS__Base__Type__DescriptionImplementation,
 
8784
  _swigc__p_OpenTURNS__Base__Type__IdentityMatrix,
 
8785
  _swigc__p_OpenTURNS__Base__Type__Indices,
 
8786
  _swigc__p_OpenTURNS__Base__Type__Interval,
 
8787
  _swigc__p_OpenTURNS__Base__Type__Matrix,
 
8788
  _swigc__p_OpenTURNS__Base__Type__MatrixImplementation,
 
8789
  _swigc__p_OpenTURNS__Base__Type__NumericalPoint,
 
8790
  _swigc__p_OpenTURNS__Base__Type__NumericalPointWithDescription,
 
8791
  _swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Func__UniVariatePolynomial_t,
 
8792
  _swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPointWithDescription_t,
 
8793
  _swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_OpenTURNS__Base__Type__NumericalPoint_t,
 
8794
  _swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_double_t,
 
8795
  _swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_std__string_t,
 
8796
  _swigc__p_OpenTURNS__Base__Type__PersistentCollectionT_unsigned_long_t,
 
8797
  _swigc__p_OpenTURNS__Base__Type__SquareMatrix,
 
8798
  _swigc__p_OpenTURNS__Base__Type__SymmetricMatrix,
 
8799
  _swigc__p_OpenTURNS__Base__Type__SymmetricTensor,
 
8800
  _swigc__p_OpenTURNS__Base__Type__Tensor,
 
8801
  _swigc__p_OpenTURNS__Base__Type__TensorImplementation,
 
8802
  _swigc__p_OpenTURNS__PointInSourceFile,
 
8803
  _swigc__p_OutOfBoundException,
 
8804
  _swigc__p_PersistentObject,
 
8805
  _swigc__p_PolynomialCollection,
 
8806
  _swigc__p_PolynomialPersistentCollection,
 
8807
  _swigc__p_Severity,
 
8808
  _swigc__p_SobolIndiceParameters,
 
8809
  _swigc__p_SobolIndiceResult,
 
8810
  _swigc__p_SquareMatrix,
 
8811
  _swigc__p_State,
 
8812
  _swigc__p_StorageManager,
 
8813
  _swigc__p_StorageManagerImplementation,
 
8814
  _swigc__p_SymmetricTensor,
 
8815
  _swigc__p_Tensor,
 
8816
  _swigc__p_UnsignedLongCollection,
 
8817
  _swigc__p_Value,
 
8818
  _swigc__p_ValueType,
 
8819
  _swigc__p_VariableListType,
 
8820
  _swigc__p_WrapperFileParsingException,
 
8821
  _swigc__p_WrapperInternalException,
 
8822
  _swigc__p_allocator_type,
 
8823
  _swigc__p_bool,
 
8824
  _swigc__p_char,
 
8825
  _swigc__p_const_iterator,
 
8826
  _swigc__p_const_reverse_iterator,
 
8827
  _swigc__p_difference_type,
 
8828
  _swigc__p_double,
 
8829
  _swigc__p_iterator,
 
8830
  _swigc__p_key_type,
 
8831
  _swigc__p_long,
 
8832
  _swigc__p_mapped_type,
 
8833
  _swigc__p_pointer_type,
 
8834
  _swigc__p_reverse_iterator,
 
8835
  _swigc__p_size_type,
 
8836
  _swigc__p_std__complexT_double_t,
 
8837
  _swigc__p_std__invalid_argument,
 
8838
  _swigc__p_std__string,
 
8839
  _swigc__p_swig__PySwigIterator,
 
8840
  _swigc__p_unsigned_long,
 
8841
  _swigc__p_value_type,
 
8842
};
 
8843
 
 
8844
 
 
8845
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
 
8846
 
 
8847
static swig_const_info swig_const_table[] = {
 
8848
{0, 0, 0, 0.0, 0, 0}};
 
8849
 
 
8850
#ifdef __cplusplus
 
8851
}
 
8852
#endif
 
8853
/* -----------------------------------------------------------------------------
 
8854
 * Type initialization:
 
8855
 * This problem is tough by the requirement that no dynamic 
 
8856
 * memory is used. Also, since swig_type_info structures store pointers to 
 
8857
 * swig_cast_info structures and swig_cast_info structures store pointers back
 
8858
 * to swig_type_info structures, we need some lookup code at initialization. 
 
8859
 * The idea is that swig generates all the structures that are needed. 
 
8860
 * The runtime then collects these partially filled structures. 
 
8861
 * The SWIG_InitializeModule function takes these initial arrays out of 
 
8862
 * swig_module, and does all the lookup, filling in the swig_module.types
 
8863
 * array with the correct data and linking the correct swig_cast_info
 
8864
 * structures together.
 
8865
 *
 
8866
 * The generated swig_type_info structures are assigned staticly to an initial 
 
8867
 * array. We just loop through that array, and handle each type individually.
 
8868
 * First we lookup if this type has been already loaded, and if so, use the
 
8869
 * loaded structure instead of the generated one. Then we have to fill in the
 
8870
 * cast linked list. The cast data is initially stored in something like a
 
8871
 * two-dimensional array. Each row corresponds to a type (there are the same
 
8872
 * number of rows as there are in the swig_type_initial array). Each entry in
 
8873
 * a column is one of the swig_cast_info structures for that type.
 
8874
 * The cast_initial array is actually an array of arrays, because each row has
 
8875
 * a variable number of columns. So to actually build the cast linked list,
 
8876
 * we find the array of casts associated with the type, and loop through it 
 
8877
 * adding the casts to the list. The one last trick we need to do is making
 
8878
 * sure the type pointer in the swig_cast_info struct is correct.
 
8879
 *
 
8880
 * First off, we lookup the cast->type name to see if it is already loaded. 
 
8881
 * There are three cases to handle:
 
8882
 *  1) If the cast->type has already been loaded AND the type we are adding
 
8883
 *     casting info to has not been loaded (it is in this module), THEN we
 
8884
 *     replace the cast->type pointer with the type pointer that has already
 
8885
 *     been loaded.
 
8886
 *  2) If BOTH types (the one we are adding casting info to, and the 
 
8887
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 
8888
 *     the previous module so we just ignore it.
 
8889
 *  3) Finally, if cast->type has not already been loaded, then we add that
 
8890
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 
8891
 *     be correct.
 
8892
 * ----------------------------------------------------------------------------- */
 
8893
 
 
8894
#ifdef __cplusplus
 
8895
extern "C" {
 
8896
#if 0
 
8897
} /* c-mode */
 
8898
#endif
 
8899
#endif
 
8900
 
 
8901
#if 0
 
8902
#define SWIGRUNTIME_DEBUG
 
8903
#endif
 
8904
 
 
8905
 
 
8906
SWIGRUNTIME void
 
8907
SWIG_InitializeModule(void *clientdata) {
 
8908
  size_t i;
 
8909
  swig_module_info *module_head, *iter;
 
8910
  int found, init;
 
8911
  
 
8912
  clientdata = clientdata;
 
8913
  
 
8914
  /* check to see if the circular list has been setup, if not, set it up */
 
8915
  if (swig_module.next==0) {
 
8916
    /* Initialize the swig_module */
 
8917
    swig_module.type_initial = swig_type_initial;
 
8918
    swig_module.cast_initial = swig_cast_initial;
 
8919
    swig_module.next = &swig_module;
 
8920
    init = 1;
 
8921
  } else {
 
8922
    init = 0;
 
8923
  }
 
8924
  
 
8925
  /* Try and load any already created modules */
 
8926
  module_head = SWIG_GetModule(clientdata);
 
8927
  if (!module_head) {
 
8928
    /* This is the first module loaded for this interpreter */
 
8929
    /* so set the swig module into the interpreter */
 
8930
    SWIG_SetModule(clientdata, &swig_module);
 
8931
    module_head = &swig_module;
 
8932
  } else {
 
8933
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
 
8934
    found=0;
 
8935
    iter=module_head;
 
8936
    do {
 
8937
      if (iter==&swig_module) {
 
8938
        found=1;
 
8939
        break;
 
8940
      }
 
8941
      iter=iter->next;
 
8942
    } while (iter!= module_head);
 
8943
    
 
8944
    /* if the is found in the list, then all is done and we may leave */
 
8945
    if (found) return;
 
8946
    /* otherwise we must add out module into the list */
 
8947
    swig_module.next = module_head->next;
 
8948
    module_head->next = &swig_module;
 
8949
  }
 
8950
  
 
8951
  /* When multiple interpeters are used, a module could have already been initialized in
 
8952
       a different interpreter, but not yet have a pointer in this interpreter.
 
8953
       In this case, we do not want to continue adding types... everything should be
 
8954
       set up already */
 
8955
  if (init == 0) return;
 
8956
  
 
8957
  /* Now work on filling in swig_module.types */
 
8958
#ifdef SWIGRUNTIME_DEBUG
 
8959
  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
 
8960
#endif
 
8961
  for (i = 0; i < swig_module.size; ++i) {
 
8962
    swig_type_info *type = 0;
 
8963
    swig_type_info *ret;
 
8964
    swig_cast_info *cast;
 
8965
    
 
8966
#ifdef SWIGRUNTIME_DEBUG
 
8967
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
 
8968
#endif
 
8969
    
 
8970
    /* if there is another module already loaded */
 
8971
    if (swig_module.next != &swig_module) {
 
8972
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
 
8973
    }
 
8974
    if (type) {
 
8975
      /* Overwrite clientdata field */
 
8976
#ifdef SWIGRUNTIME_DEBUG
 
8977
      printf("SWIG_InitializeModule: found type %s\n", type->name);
 
8978
#endif
 
8979
      if (swig_module.type_initial[i]->clientdata) {
 
8980
        type->clientdata = swig_module.type_initial[i]->clientdata;
 
8981
#ifdef SWIGRUNTIME_DEBUG
 
8982
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
 
8983
#endif
 
8984
      }
 
8985
    } else {
 
8986
      type = swig_module.type_initial[i];
 
8987
    }
 
8988
    
 
8989
    /* Insert casting types */
 
8990
    cast = swig_module.cast_initial[i];
 
8991
    while (cast->type) {
 
8992
      /* Don't need to add information already in the list */
 
8993
      ret = 0;
 
8994
#ifdef SWIGRUNTIME_DEBUG
 
8995
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
 
8996
#endif
 
8997
      if (swig_module.next != &swig_module) {
 
8998
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
 
8999
#ifdef SWIGRUNTIME_DEBUG
 
9000
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
 
9001
#endif
 
9002
      }
 
9003
      if (ret) {
 
9004
        if (type == swig_module.type_initial[i]) {
 
9005
#ifdef SWIGRUNTIME_DEBUG
 
9006
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
 
9007
#endif
 
9008
          cast->type = ret;
 
9009
          ret = 0;
 
9010
        } else {
 
9011
          /* Check for casting already in the list */
 
9012
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
 
9013
#ifdef SWIGRUNTIME_DEBUG
 
9014
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
 
9015
#endif
 
9016
          if (!ocast) ret = 0;
 
9017
        }
 
9018
      }
 
9019
      
 
9020
      if (!ret) {
 
9021
#ifdef SWIGRUNTIME_DEBUG
 
9022
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
 
9023
#endif
 
9024
        if (type->cast) {
 
9025
          type->cast->prev = cast;
 
9026
          cast->next = type->cast;
 
9027
        }
 
9028
        type->cast = cast;
 
9029
      }
 
9030
      cast++;
 
9031
    }
 
9032
    /* Set entry in modules->types array equal to the type */
 
9033
    swig_module.types[i] = type;
 
9034
  }
 
9035
  swig_module.types[i] = 0;
 
9036
  
 
9037
#ifdef SWIGRUNTIME_DEBUG
 
9038
  printf("**** SWIG_InitializeModule: Cast List ******\n");
 
9039
  for (i = 0; i < swig_module.size; ++i) {
 
9040
    int j = 0;
 
9041
    swig_cast_info *cast = swig_module.cast_initial[i];
 
9042
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
 
9043
    while (cast->type) {
 
9044
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
 
9045
      cast++;
 
9046
      ++j;
 
9047
    }
 
9048
    printf("---- Total casts: %d\n",j);
 
9049
  }
 
9050
  printf("**** SWIG_InitializeModule: Cast List ******\n");
 
9051
#endif
 
9052
}
 
9053
 
 
9054
/* This function will propagate the clientdata field of type to
 
9055
* any new swig_type_info structures that have been added into the list
 
9056
* of equivalent types.  It is like calling
 
9057
* SWIG_TypeClientData(type, clientdata) a second time.
 
9058
*/
 
9059
SWIGRUNTIME void
 
9060
SWIG_PropagateClientData(void) {
 
9061
  size_t i;
 
9062
  swig_cast_info *equiv;
 
9063
  static int init_run = 0;
 
9064
  
 
9065
  if (init_run) return;
 
9066
  init_run = 1;
 
9067
  
 
9068
  for (i = 0; i < swig_module.size; i++) {
 
9069
    if (swig_module.types[i]->clientdata) {
 
9070
      equiv = swig_module.types[i]->cast;
 
9071
      while (equiv) {
 
9072
        if (!equiv->converter) {
 
9073
          if (equiv->type && !equiv->type->clientdata)
 
9074
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
 
9075
        }
 
9076
        equiv = equiv->next;
 
9077
      }
 
9078
    }
 
9079
  }
 
9080
}
 
9081
 
 
9082
#ifdef __cplusplus
 
9083
#if 0
 
9084
{
 
9085
  /* c-mode */
 
9086
#endif
 
9087
}
 
9088
#endif
 
9089
 
 
9090
 
 
9091
 
 
9092
#ifdef __cplusplus
 
9093
extern "C" {
 
9094
#endif
 
9095
  
 
9096
  /* Python-specific SWIG API */
 
9097
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
 
9098
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
 
9099
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
 
9100
  
 
9101
  /* -----------------------------------------------------------------------------
 
9102
   * global variable support code.
 
9103
   * ----------------------------------------------------------------------------- */
 
9104
  
 
9105
  typedef struct swig_globalvar {
 
9106
    char       *name;                  /* Name of global variable */
 
9107
    PyObject *(*get_attr)(void);       /* Return the current value */
 
9108
    int       (*set_attr)(PyObject *); /* Set the value */
 
9109
    struct swig_globalvar *next;
 
9110
  } swig_globalvar;
 
9111
  
 
9112
  typedef struct swig_varlinkobject {
 
9113
    PyObject_HEAD
 
9114
    swig_globalvar *vars;
 
9115
  } swig_varlinkobject;
 
9116
  
 
9117
  SWIGINTERN PyObject *
 
9118
  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
 
9119
    return PyString_FromString("<Swig global variables>");
 
9120
  }
 
9121
  
 
9122
  SWIGINTERN PyObject *
 
9123
  swig_varlink_str(swig_varlinkobject *v) {
 
9124
    PyObject *str = PyString_FromString("(");
 
9125
    swig_globalvar  *var;
 
9126
    for (var = v->vars; var; var=var->next) {
 
9127
      PyString_ConcatAndDel(&str,PyString_FromString(var->name));
 
9128
      if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
 
9129
    }
 
9130
    PyString_ConcatAndDel(&str,PyString_FromString(")"));
 
9131
    return str;
 
9132
  }
 
9133
  
 
9134
  SWIGINTERN int
 
9135
  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
 
9136
    PyObject *str = swig_varlink_str(v);
 
9137
    fprintf(fp,"Swig global variables ");
 
9138
    fprintf(fp,"%s\n", PyString_AsString(str));
 
9139
    Py_DECREF(str);
 
9140
    return 0;
 
9141
  }
 
9142
  
 
9143
  SWIGINTERN void
 
9144
  swig_varlink_dealloc(swig_varlinkobject *v) {
 
9145
    swig_globalvar *var = v->vars;
 
9146
    while (var) {
 
9147
      swig_globalvar *n = var->next;
 
9148
      free(var->name);
 
9149
      free(var);
 
9150
      var = n;
 
9151
    }
 
9152
  }
 
9153
  
 
9154
  SWIGINTERN PyObject *
 
9155
  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
 
9156
    PyObject *res = NULL;
 
9157
    swig_globalvar *var = v->vars;
 
9158
    while (var) {
 
9159
      if (strcmp(var->name,n) == 0) {
 
9160
        res = (*var->get_attr)();
 
9161
        break;
 
9162
      }
 
9163
      var = var->next;
 
9164
    }
 
9165
    if (res == NULL && !PyErr_Occurred()) {
 
9166
      PyErr_SetString(PyExc_NameError,"Unknown C global variable");
 
9167
    }
 
9168
    return res;
 
9169
  }
 
9170
  
 
9171
  SWIGINTERN int
 
9172
  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
 
9173
    int res = 1;
 
9174
    swig_globalvar *var = v->vars;
 
9175
    while (var) {
 
9176
      if (strcmp(var->name,n) == 0) {
 
9177
        res = (*var->set_attr)(p);
 
9178
        break;
 
9179
      }
 
9180
      var = var->next;
 
9181
    }
 
9182
    if (res == 1 && !PyErr_Occurred()) {
 
9183
      PyErr_SetString(PyExc_NameError,"Unknown C global variable");
 
9184
    }
 
9185
    return res;
 
9186
  }
 
9187
  
 
9188
  SWIGINTERN PyTypeObject*
 
9189
  swig_varlink_type(void) {
 
9190
    static char varlink__doc__[] = "Swig var link object";
 
9191
    static PyTypeObject varlink_type;
 
9192
    static int type_init = 0;  
 
9193
    if (!type_init) {
 
9194
      const PyTypeObject tmp
 
9195
      = {
 
9196
        PyObject_HEAD_INIT(NULL)
 
9197
        0,                                  /* Number of items in variable part (ob_size) */
 
9198
        (char *)"swigvarlink",              /* Type name (tp_name) */
 
9199
        sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
 
9200
        0,                                  /* Itemsize (tp_itemsize) */
 
9201
        (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */ 
 
9202
        (printfunc) swig_varlink_print,     /* Print (tp_print) */
 
9203
        (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
 
9204
        (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
 
9205
        0,                                  /* tp_compare */
 
9206
        (reprfunc) swig_varlink_repr,       /* tp_repr */
 
9207
        0,                                  /* tp_as_number */
 
9208
        0,                                  /* tp_as_sequence */
 
9209
        0,                                  /* tp_as_mapping */
 
9210
        0,                                  /* tp_hash */
 
9211
        0,                                  /* tp_call */
 
9212
        (reprfunc)swig_varlink_str,        /* tp_str */
 
9213
        0,                                  /* tp_getattro */
 
9214
        0,                                  /* tp_setattro */
 
9215
        0,                                  /* tp_as_buffer */
 
9216
        0,                                  /* tp_flags */
 
9217
        varlink__doc__,                     /* tp_doc */
 
9218
        0,                                  /* tp_traverse */
 
9219
        0,                                  /* tp_clear */
 
9220
        0,                                  /* tp_richcompare */
 
9221
        0,                                  /* tp_weaklistoffset */
 
9222
#if PY_VERSION_HEX >= 0x02020000
 
9223
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
 
9224
#endif
 
9225
#if PY_VERSION_HEX >= 0x02030000
 
9226
        0,                                  /* tp_del */
 
9227
#endif
 
9228
#ifdef COUNT_ALLOCS
 
9229
        0,0,0,0                             /* tp_alloc -> tp_next */
 
9230
#endif
 
9231
      };
 
9232
      varlink_type = tmp;
 
9233
      varlink_type.ob_type = &PyType_Type;
 
9234
      type_init = 1;
 
9235
    }
 
9236
    return &varlink_type;
 
9237
  }
 
9238
  
 
9239
  /* Create a variable linking object for use later */
 
9240
  SWIGINTERN PyObject *
 
9241
  SWIG_Python_newvarlink(void) {
 
9242
    swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
 
9243
    if (result) {
 
9244
      result->vars = 0;
 
9245
    }
 
9246
    return ((PyObject*) result);
 
9247
  }
 
9248
  
 
9249
  SWIGINTERN void 
 
9250
  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
 
9251
    swig_varlinkobject *v = (swig_varlinkobject *) p;
 
9252
    swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
 
9253
    if (gv) {
 
9254
      size_t size = strlen(name)+1;
 
9255
      gv->name = (char *)malloc(size);
 
9256
      if (gv->name) {
 
9257
        strncpy(gv->name,name,size);
 
9258
        gv->get_attr = get_attr;
 
9259
        gv->set_attr = set_attr;
 
9260
        gv->next = v->vars;
 
9261
      }
 
9262
    }
 
9263
    v->vars = gv;
 
9264
  }
 
9265
  
 
9266
  SWIGINTERN PyObject *
 
9267
  SWIG_globals(void) {
 
9268
    static PyObject *_SWIG_globals = 0; 
 
9269
    if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
 
9270
    return _SWIG_globals;
 
9271
  }
 
9272
  
 
9273
  /* -----------------------------------------------------------------------------
 
9274
   * constants/methods manipulation
 
9275
   * ----------------------------------------------------------------------------- */
 
9276
  
 
9277
  /* Install Constants */
 
9278
  SWIGINTERN void
 
9279
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
 
9280
    PyObject *obj = 0;
 
9281
    size_t i;
 
9282
    for (i = 0; constants[i].type; ++i) {
 
9283
      switch(constants[i].type) {
 
9284
      case SWIG_PY_POINTER:
 
9285
        obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
 
9286
        break;
 
9287
      case SWIG_PY_BINARY:
 
9288
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
 
9289
        break;
 
9290
      default:
 
9291
        obj = 0;
 
9292
        break;
 
9293
      }
 
9294
      if (obj) {
 
9295
        PyDict_SetItemString(d, constants[i].name, obj);
 
9296
        Py_DECREF(obj);
 
9297
      }
 
9298
    }
 
9299
  }
 
9300
  
 
9301
  /* -----------------------------------------------------------------------------*/
 
9302
  /* Fix SwigMethods to carry the callback ptrs when needed */
 
9303
  /* -----------------------------------------------------------------------------*/
 
9304
  
 
9305
  SWIGINTERN void
 
9306
  SWIG_Python_FixMethods(PyMethodDef *methods,
 
9307
    swig_const_info *const_table,
 
9308
    swig_type_info **types,
 
9309
    swig_type_info **types_initial) {
 
9310
    size_t i;
 
9311
    for (i = 0; methods[i].ml_name; ++i) {
 
9312
      const char *c = methods[i].ml_doc;
 
9313
      if (c && (c = strstr(c, "swig_ptr: "))) {
 
9314
        int j;
 
9315
        swig_const_info *ci = 0;
 
9316
        const char *name = c + 10;
 
9317
        for (j = 0; const_table[j].type; ++j) {
 
9318
          if (strncmp(const_table[j].name, name, 
 
9319
              strlen(const_table[j].name)) == 0) {
 
9320
            ci = &(const_table[j]);
 
9321
            break;
 
9322
          }
 
9323
        }
 
9324
        if (ci) {
 
9325
          size_t shift = (ci->ptype) - types;
 
9326
          swig_type_info *ty = types_initial[shift];
 
9327
          size_t ldoc = (c - methods[i].ml_doc);
 
9328
          size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
 
9329
          char *ndoc = (char*)malloc(ldoc + lptr + 10);
 
9330
          if (ndoc) {
 
9331
            char *buff = ndoc;
 
9332
            void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
 
9333
            if (ptr) {
 
9334
              strncpy(buff, methods[i].ml_doc, ldoc);
 
9335
              buff += ldoc;
 
9336
              strncpy(buff, "swig_ptr: ", 10);
 
9337
              buff += 10;
 
9338
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
 
9339
              methods[i].ml_doc = ndoc;
 
9340
            }
 
9341
          }
 
9342
        }
 
9343
      }
 
9344
    }
 
9345
  } 
 
9346
  
 
9347
#ifdef __cplusplus
 
9348
}
 
9349
#endif
 
9350
 
 
9351
/* -----------------------------------------------------------------------------*
 
9352
 *  Partial Init method
 
9353
 * -----------------------------------------------------------------------------*/
 
9354
 
 
9355
#ifdef __cplusplus
 
9356
extern "C"
 
9357
#endif
 
9358
SWIGEXPORT void SWIG_init(void) {
 
9359
  PyObject *m, *d;
 
9360
  
 
9361
  /* Fix SwigMethods to carry the callback ptrs when needed */
 
9362
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
 
9363
  
 
9364
  m = Py_InitModule((char *) SWIG_name, SwigMethods);
 
9365
  d = PyModule_GetDict(m);
 
9366
  
 
9367
  SWIG_InitializeModule(0);
 
9368
  SWIG_InstallConstants(d,swig_const_table);
 
9369
  
 
9370
  
 
9371
  PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
 
9372
  SWIG_addvarlink(SWIG_globals(),(char*)"CenteredFiniteDifferenceGradient_DefaultEpsilon",Swig_var_CenteredFiniteDifferenceGradient_DefaultEpsilon_get, Swig_var_CenteredFiniteDifferenceGradient_DefaultEpsilon_set);
 
9373
  SWIG_addvarlink(SWIG_globals(),(char*)"CenteredFiniteDifferenceHessian_DefaultEpsilon",Swig_var_CenteredFiniteDifferenceHessian_DefaultEpsilon_get, Swig_var_CenteredFiniteDifferenceHessian_DefaultEpsilon_set);
 
9374
  SWIG_addvarlink(SWIG_globals(),(char*)"NonCenteredFiniteDifferenceGradient_DefaultEpsilon",Swig_var_NonCenteredFiniteDifferenceGradient_DefaultEpsilon_get, Swig_var_NonCenteredFiniteDifferenceGradient_DefaultEpsilon_set);
 
9375
}
 
9376