1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 4.0.1
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
12 #ifndef SWIGPERL
13 #define SWIGPERL
14 #endif
15
16 #define SWIG_CASTRANK_MODE
17
18 /* -----------------------------------------------------------------------------
19 * This section contains generic SWIG labels for method/variable
20 * declarations/attributes, and other compiler dependent labels.
21 * ----------------------------------------------------------------------------- */
22
23 /* template workaround for compilers that cannot correctly implement the C++ standard */
24 #ifndef SWIGTEMPLATEDISAMBIGUATOR
25 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
26 # define SWIGTEMPLATEDISAMBIGUATOR template
27 # elif defined(__HP_aCC)
28 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
29 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
30 # define SWIGTEMPLATEDISAMBIGUATOR template
31 # else
32 # define SWIGTEMPLATEDISAMBIGUATOR
33 # endif
34 #endif
35
36 /* inline attribute */
37 #ifndef SWIGINLINE
38 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
39 # define SWIGINLINE inline
40 # else
41 # define SWIGINLINE
42 # endif
43 #endif
44
45 /* attribute recognised by some compilers to avoid 'unused' warnings */
46 #ifndef SWIGUNUSED
47 # if defined(__GNUC__)
48 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
49 # define SWIGUNUSED __attribute__ ((__unused__))
50 # else
51 # define SWIGUNUSED
52 # endif
53 # elif defined(__ICC)
54 # define SWIGUNUSED __attribute__ ((__unused__))
55 # else
56 # define SWIGUNUSED
57 # endif
58 #endif
59
60 #ifndef SWIG_MSC_UNSUPPRESS_4505
61 # if defined(_MSC_VER)
62 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
63 # endif
64 #endif
65
66 #ifndef SWIGUNUSEDPARM
67 # ifdef __cplusplus
68 # define SWIGUNUSEDPARM(p)
69 # else
70 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
71 # endif
72 #endif
73
74 /* internal SWIG method */
75 #ifndef SWIGINTERN
76 # define SWIGINTERN static SWIGUNUSED
77 #endif
78
79 /* internal inline SWIG method */
80 #ifndef SWIGINTERNINLINE
81 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
82 #endif
83
84 /* exporting methods */
85 #if defined(__GNUC__)
86 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
87 # ifndef GCC_HASCLASSVISIBILITY
88 # define GCC_HASCLASSVISIBILITY
89 # endif
90 # endif
91 #endif
92
93 #ifndef SWIGEXPORT
94 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
95 # if defined(STATIC_LINKED)
96 # define SWIGEXPORT
97 # else
98 # define SWIGEXPORT __declspec(dllexport)
99 # endif
100 # else
101 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
102 # define SWIGEXPORT __attribute__ ((visibility("default")))
103 # else
104 # define SWIGEXPORT
105 # endif
106 # endif
107 #endif
108
109 /* calling conventions for Windows */
110 #ifndef SWIGSTDCALL
111 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
112 # define SWIGSTDCALL __stdcall
113 # else
114 # define SWIGSTDCALL
115 # endif
116 #endif
117
118 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
119 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
120 # define _CRT_SECURE_NO_DEPRECATE
121 #endif
122
123 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
124 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
125 # define _SCL_SECURE_NO_DEPRECATE
126 #endif
127
128 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
129 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
130 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
131 #endif
132
133 /* Intel's compiler complains if a variable which was never initialised is
134 * cast to void, which is a common idiom which we use to indicate that we
135 * are aware a variable isn't used. So we just silence that warning.
136 * See: https://github.com/swig/swig/issues/192 for more discussion.
137 */
138 #ifdef __INTEL_COMPILER
139 # pragma warning disable 592
140 #endif
141
142 /* -----------------------------------------------------------------------------
143 * swigrun.swg
144 *
145 * This file contains generic C API SWIG runtime support for pointer
146 * type checking.
147 * ----------------------------------------------------------------------------- */
148
149 /* This should only be incremented when either the layout of swig_type_info changes,
150 or for whatever reason, the runtime changes incompatibly */
151 #define SWIG_RUNTIME_VERSION "4"
152
153 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
154 #ifdef SWIG_TYPE_TABLE
155 # define SWIG_QUOTE_STRING(x) #x
156 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
157 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
158 #else
159 # define SWIG_TYPE_TABLE_NAME
160 #endif
161
162 /*
163 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
164 creating a static or dynamic library from the SWIG runtime code.
165 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
166
167 But only do this if strictly necessary, ie, if you have problems
168 with your compiler or suchlike.
169 */
170
171 #ifndef SWIGRUNTIME
172 # define SWIGRUNTIME SWIGINTERN
173 #endif
174
175 #ifndef SWIGRUNTIMEINLINE
176 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
177 #endif
178
179 /* Generic buffer size */
180 #ifndef SWIG_BUFFER_SIZE
181 # define SWIG_BUFFER_SIZE 1024
182 #endif
183
184 /* Flags for pointer conversions */
185 #define SWIG_POINTER_DISOWN 0x1
186 #define SWIG_CAST_NEW_MEMORY 0x2
187 #define SWIG_POINTER_NO_NULL 0x4
188
189 /* Flags for new pointer objects */
190 #define SWIG_POINTER_OWN 0x1
191
192
193 /*
194 Flags/methods for returning states.
195
196 The SWIG conversion methods, as ConvertPtr, return an integer
197 that tells if the conversion was successful or not. And if not,
198 an error code can be returned (see swigerrors.swg for the codes).
199
200 Use the following macros/flags to set or process the returning
201 states.
202
203 In old versions of SWIG, code such as the following was usually written:
204
205 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
206 // success code
207 } else {
208 //fail code
209 }
210
211 Now you can be more explicit:
212
213 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
214 if (SWIG_IsOK(res)) {
215 // success code
216 } else {
217 // fail code
218 }
219
220 which is the same really, but now you can also do
221
222 Type *ptr;
223 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
224 if (SWIG_IsOK(res)) {
225 // success code
226 if (SWIG_IsNewObj(res) {
227 ...
228 delete *ptr;
229 } else {
230 ...
231 }
232 } else {
233 // fail code
234 }
235
236 I.e., now SWIG_ConvertPtr can return new objects and you can
237 identify the case and take care of the deallocation. Of course that
238 also requires SWIG_ConvertPtr to return new result values, such as
239
240 int SWIG_ConvertPtr(obj, ptr,...) {
241 if (<obj is ok>) {
242 if (<need new object>) {
243 *ptr = <ptr to new allocated object>;
244 return SWIG_NEWOBJ;
245 } else {
246 *ptr = <ptr to old object>;
247 return SWIG_OLDOBJ;
248 }
249 } else {
250 return SWIG_BADOBJ;
251 }
252 }
253
254 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
255 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
256 SWIG errors code.
257
258 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
259 allows to return the 'cast rank', for example, if you have this
260
261 int food(double)
262 int fooi(int);
263
264 and you call
265
266 food(1) // cast rank '1' (1 -> 1.0)
267 fooi(1) // cast rank '0'
268
269 just use the SWIG_AddCast()/SWIG_CheckState()
270 */
271
272 #define SWIG_OK (0)
273 #define SWIG_ERROR (-1)
274 #define SWIG_IsOK(r) (r >= 0)
275 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
276
277 /* The CastRankLimit says how many bits are used for the cast rank */
278 #define SWIG_CASTRANKLIMIT (1 << 8)
279 /* The NewMask denotes the object was created (using new/malloc) */
280 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
281 /* The TmpMask is for in/out typemaps that use temporal objects */
282 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
283 /* Simple returning values */
284 #define SWIG_BADOBJ (SWIG_ERROR)
285 #define SWIG_OLDOBJ (SWIG_OK)
286 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
287 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
288 /* Check, add and del mask methods */
289 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
290 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
291 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
292 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
293 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
294 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
295
296 /* Cast-Rank Mode */
297 #if defined(SWIG_CASTRANK_MODE)
298 # ifndef SWIG_TypeRank
299 # define SWIG_TypeRank unsigned long
300 # endif
301 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
302 # define SWIG_MAXCASTRANK (2)
303 # endif
304 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
305 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIG_AddCast(int r)306 SWIGINTERNINLINE int SWIG_AddCast(int r) {
307 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
308 }
SWIG_CheckState(int r)309 SWIGINTERNINLINE int SWIG_CheckState(int r) {
310 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
311 }
312 #else /* no cast-rank mode */
313 # define SWIG_AddCast(r) (r)
314 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
315 #endif
316
317
318 #include <string.h>
319
320 #ifdef __cplusplus
321 extern "C" {
322 #endif
323
324 typedef void *(*swig_converter_func)(void *, int *);
325 typedef struct swig_type_info *(*swig_dycast_func)(void **);
326
327 /* Structure to store information on one type */
328 typedef struct swig_type_info {
329 const char *name; /* mangled name of this type */
330 const char *str; /* human readable name of this type */
331 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
332 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
333 void *clientdata; /* language specific type data */
334 int owndata; /* flag if the structure owns the clientdata */
335 } swig_type_info;
336
337 /* Structure to store a type and conversion function used for casting */
338 typedef struct swig_cast_info {
339 swig_type_info *type; /* pointer to type that is equivalent to this type */
340 swig_converter_func converter; /* function to cast the void pointers */
341 struct swig_cast_info *next; /* pointer to next cast in linked list */
342 struct swig_cast_info *prev; /* pointer to the previous cast */
343 } swig_cast_info;
344
345 /* Structure used to store module information
346 * Each module generates one structure like this, and the runtime collects
347 * all of these structures and stores them in a circularly linked list.*/
348 typedef struct swig_module_info {
349 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
350 size_t size; /* Number of types in this module */
351 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
352 swig_type_info **type_initial; /* Array of initially generated type structures */
353 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
354 void *clientdata; /* Language specific module data */
355 } swig_module_info;
356
357 /*
358 Compare two type names skipping the space characters, therefore
359 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
360
361 Return 0 when the two name types are equivalent, as in
362 strncmp, but skipping ' '.
363 */
364 SWIGRUNTIME int
SWIG_TypeNameComp(const char * f1,const char * l1,const char * f2,const char * l2)365 SWIG_TypeNameComp(const char *f1, const char *l1,
366 const char *f2, const char *l2) {
367 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
368 while ((*f1 == ' ') && (f1 != l1)) ++f1;
369 while ((*f2 == ' ') && (f2 != l2)) ++f2;
370 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
371 }
372 return (int)((l1 - f1) - (l2 - f2));
373 }
374
375 /*
376 Check type equivalence in a name list like <name1>|<name2>|...
377 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
378 */
379 SWIGRUNTIME int
SWIG_TypeCmp(const char * nb,const char * tb)380 SWIG_TypeCmp(const char *nb, const char *tb) {
381 int equiv = 1;
382 const char* te = tb + strlen(tb);
383 const char* ne = nb;
384 while (equiv != 0 && *ne) {
385 for (nb = ne; *ne; ++ne) {
386 if (*ne == '|') break;
387 }
388 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
389 if (*ne) ++ne;
390 }
391 return equiv;
392 }
393
394 /*
395 Check type equivalence in a name list like <name1>|<name2>|...
396 Return 0 if not equal, 1 if equal
397 */
398 SWIGRUNTIME int
SWIG_TypeEquiv(const char * nb,const char * tb)399 SWIG_TypeEquiv(const char *nb, const char *tb) {
400 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
401 }
402
403 /*
404 Check the typename
405 */
406 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char * c,swig_type_info * ty)407 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
408 if (ty) {
409 swig_cast_info *iter = ty->cast;
410 while (iter) {
411 if (strcmp(iter->type->name, c) == 0) {
412 if (iter == ty->cast)
413 return iter;
414 /* Move iter to the top of the linked list */
415 iter->prev->next = iter->next;
416 if (iter->next)
417 iter->next->prev = iter->prev;
418 iter->next = ty->cast;
419 iter->prev = 0;
420 if (ty->cast) ty->cast->prev = iter;
421 ty->cast = iter;
422 return iter;
423 }
424 iter = iter->next;
425 }
426 }
427 return 0;
428 }
429
430 /*
431 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
432 */
433 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info * from,swig_type_info * ty)434 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
435 if (ty) {
436 swig_cast_info *iter = ty->cast;
437 while (iter) {
438 if (iter->type == from) {
439 if (iter == ty->cast)
440 return iter;
441 /* Move iter to the top of the linked list */
442 iter->prev->next = iter->next;
443 if (iter->next)
444 iter->next->prev = iter->prev;
445 iter->next = ty->cast;
446 iter->prev = 0;
447 if (ty->cast) ty->cast->prev = iter;
448 ty->cast = iter;
449 return iter;
450 }
451 iter = iter->next;
452 }
453 }
454 return 0;
455 }
456
457 /*
458 Cast a pointer up an inheritance hierarchy
459 */
460 SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info * ty,void * ptr,int * newmemory)461 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
462 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
463 }
464
465 /*
466 Dynamic pointer casting. Down an inheritance hierarchy
467 */
468 SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info * ty,void ** ptr)469 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
470 swig_type_info *lastty = ty;
471 if (!ty || !ty->dcast) return ty;
472 while (ty && (ty->dcast)) {
473 ty = (*ty->dcast)(ptr);
474 if (ty) lastty = ty;
475 }
476 return lastty;
477 }
478
479 /*
480 Return the name associated with this type
481 */
482 SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info * ty)483 SWIG_TypeName(const swig_type_info *ty) {
484 return ty->name;
485 }
486
487 /*
488 Return the pretty name associated with this type,
489 that is an unmangled type name in a form presentable to the user.
490 */
491 SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info * type)492 SWIG_TypePrettyName(const swig_type_info *type) {
493 /* The "str" field contains the equivalent pretty names of the
494 type, separated by vertical-bar characters. We choose
495 to print the last name, as it is often (?) the most
496 specific. */
497 if (!type) return NULL;
498 if (type->str != NULL) {
499 const char *last_name = type->str;
500 const char *s;
501 for (s = type->str; *s; s++)
502 if (*s == '|') last_name = s+1;
503 return last_name;
504 }
505 else
506 return type->name;
507 }
508
509 /*
510 Set the clientdata field for a type
511 */
512 SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info * ti,void * clientdata)513 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
514 swig_cast_info *cast = ti->cast;
515 /* if (ti->clientdata == clientdata) return; */
516 ti->clientdata = clientdata;
517
518 while (cast) {
519 if (!cast->converter) {
520 swig_type_info *tc = cast->type;
521 if (!tc->clientdata) {
522 SWIG_TypeClientData(tc, clientdata);
523 }
524 }
525 cast = cast->next;
526 }
527 }
528 SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info * ti,void * clientdata)529 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
530 SWIG_TypeClientData(ti, clientdata);
531 ti->owndata = 1;
532 }
533
534 /*
535 Search for a swig_type_info structure only by mangled name
536 Search is a O(log #types)
537
538 We start searching at module start, and finish searching when start == end.
539 Note: if start == end at the beginning of the function, we go all the way around
540 the circular list.
541 */
542 SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)543 SWIG_MangledTypeQueryModule(swig_module_info *start,
544 swig_module_info *end,
545 const char *name) {
546 swig_module_info *iter = start;
547 do {
548 if (iter->size) {
549 size_t l = 0;
550 size_t r = iter->size - 1;
551 do {
552 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
553 size_t i = (l + r) >> 1;
554 const char *iname = iter->types[i]->name;
555 if (iname) {
556 int compare = strcmp(name, iname);
557 if (compare == 0) {
558 return iter->types[i];
559 } else if (compare < 0) {
560 if (i) {
561 r = i - 1;
562 } else {
563 break;
564 }
565 } else if (compare > 0) {
566 l = i + 1;
567 }
568 } else {
569 break; /* should never happen */
570 }
571 } while (l <= r);
572 }
573 iter = iter->next;
574 } while (iter != end);
575 return 0;
576 }
577
578 /*
579 Search for a swig_type_info structure for either a mangled name or a human readable name.
580 It first searches the mangled names of the types, which is a O(log #types)
581 If a type is not found it then searches the human readable names, which is O(#types).
582
583 We start searching at module start, and finish searching when start == end.
584 Note: if start == end at the beginning of the function, we go all the way around
585 the circular list.
586 */
587 SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)588 SWIG_TypeQueryModule(swig_module_info *start,
589 swig_module_info *end,
590 const char *name) {
591 /* STEP 1: Search the name field using binary search */
592 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
593 if (ret) {
594 return ret;
595 } else {
596 /* STEP 2: If the type hasn't been found, do a complete search
597 of the str field (the human readable name) */
598 swig_module_info *iter = start;
599 do {
600 size_t i = 0;
601 for (; i < iter->size; ++i) {
602 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
603 return iter->types[i];
604 }
605 iter = iter->next;
606 } while (iter != end);
607 }
608
609 /* neither found a match */
610 return 0;
611 }
612
613 /*
614 Pack binary data into a string
615 */
616 SWIGRUNTIME char *
SWIG_PackData(char * c,void * ptr,size_t sz)617 SWIG_PackData(char *c, void *ptr, size_t sz) {
618 static const char hex[17] = "0123456789abcdef";
619 const unsigned char *u = (unsigned char *) ptr;
620 const unsigned char *eu = u + sz;
621 for (; u != eu; ++u) {
622 unsigned char uu = *u;
623 *(c++) = hex[(uu & 0xf0) >> 4];
624 *(c++) = hex[uu & 0xf];
625 }
626 return c;
627 }
628
629 /*
630 Unpack binary data from a string
631 */
632 SWIGRUNTIME const char *
SWIG_UnpackData(const char * c,void * ptr,size_t sz)633 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
634 unsigned char *u = (unsigned char *) ptr;
635 const unsigned char *eu = u + sz;
636 for (; u != eu; ++u) {
637 char d = *(c++);
638 unsigned char uu;
639 if ((d >= '0') && (d <= '9'))
640 uu = (unsigned char)((d - '0') << 4);
641 else if ((d >= 'a') && (d <= 'f'))
642 uu = (unsigned char)((d - ('a'-10)) << 4);
643 else
644 return (char *) 0;
645 d = *(c++);
646 if ((d >= '0') && (d <= '9'))
647 uu |= (unsigned char)(d - '0');
648 else if ((d >= 'a') && (d <= 'f'))
649 uu |= (unsigned char)(d - ('a'-10));
650 else
651 return (char *) 0;
652 *u = uu;
653 }
654 return c;
655 }
656
657 /*
658 Pack 'void *' into a string buffer.
659 */
660 SWIGRUNTIME char *
SWIG_PackVoidPtr(char * buff,void * ptr,const char * name,size_t bsz)661 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
662 char *r = buff;
663 if ((2*sizeof(void *) + 2) > bsz) return 0;
664 *(r++) = '_';
665 r = SWIG_PackData(r,&ptr,sizeof(void *));
666 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
667 strcpy(r,name);
668 return buff;
669 }
670
671 SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char * c,void ** ptr,const char * name)672 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
673 if (*c != '_') {
674 if (strcmp(c,"NULL") == 0) {
675 *ptr = (void *) 0;
676 return name;
677 } else {
678 return 0;
679 }
680 }
681 return SWIG_UnpackData(++c,ptr,sizeof(void *));
682 }
683
684 SWIGRUNTIME char *
SWIG_PackDataName(char * buff,void * ptr,size_t sz,const char * name,size_t bsz)685 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
686 char *r = buff;
687 size_t lname = (name ? strlen(name) : 0);
688 if ((2*sz + 2 + lname) > bsz) return 0;
689 *(r++) = '_';
690 r = SWIG_PackData(r,ptr,sz);
691 if (lname) {
692 strncpy(r,name,lname+1);
693 } else {
694 *r = 0;
695 }
696 return buff;
697 }
698
699 SWIGRUNTIME const char *
SWIG_UnpackDataName(const char * c,void * ptr,size_t sz,const char * name)700 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
701 if (*c != '_') {
702 if (strcmp(c,"NULL") == 0) {
703 memset(ptr,0,sz);
704 return name;
705 } else {
706 return 0;
707 }
708 }
709 return SWIG_UnpackData(++c,ptr,sz);
710 }
711
712 #ifdef __cplusplus
713 }
714 #endif
715
716 /* Errors in SWIG */
717 #define SWIG_UnknownError -1
718 #define SWIG_IOError -2
719 #define SWIG_RuntimeError -3
720 #define SWIG_IndexError -4
721 #define SWIG_TypeError -5
722 #define SWIG_DivisionByZero -6
723 #define SWIG_OverflowError -7
724 #define SWIG_SyntaxError -8
725 #define SWIG_ValueError -9
726 #define SWIG_SystemError -10
727 #define SWIG_AttributeError -11
728 #define SWIG_MemoryError -12
729 #define SWIG_NullReferenceError -13
730
731
732
733 #ifdef __cplusplus
734 /* Needed on some windows machines---since MS plays funny games with the header files under C++ */
735 #include <math.h>
736 #include <stdlib.h>
737 extern "C" {
738 #endif
739 #include "EXTERN.h"
740 #include "perl.h"
741 #include "XSUB.h"
742
743 /* Add in functionality missing in older versions of Perl. Much of this is based on Devel-PPPort on cpan. */
744
745 /* Add PERL_REVISION, PERL_VERSION, PERL_SUBVERSION if missing */
746 #ifndef PERL_REVISION
747 # if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
748 # define PERL_PATCHLEVEL_H_IMPLICIT
749 # include <patchlevel.h>
750 # endif
751 # if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
752 # include <could_not_find_Perl_patchlevel.h>
753 # endif
754 # ifndef PERL_REVISION
755 # define PERL_REVISION (5)
756 # define PERL_VERSION PATCHLEVEL
757 # define PERL_SUBVERSION SUBVERSION
758 # endif
759 #endif
760
761 #if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
762 #define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
763 #endif
764
765 #ifndef SvIOK_UV
766 # define SvIOK_UV(sv) (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv)))
767 #endif
768
769 #ifndef SvUOK
770 # define SvUOK(sv) SvIOK_UV(sv)
771 #endif
772
773 #if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
774 # define PL_sv_undef sv_undef
775 # define PL_na na
776 # define PL_errgv errgv
777 # define PL_sv_no sv_no
778 # define PL_sv_yes sv_yes
779 # define PL_markstack_ptr markstack_ptr
780 #endif
781
782 #ifndef IVSIZE
783 # ifdef LONGSIZE
784 # define IVSIZE LONGSIZE
785 # else
786 # define IVSIZE 4 /* A bold guess, but the best we can make. */
787 # endif
788 #endif
789
790 #ifndef INT2PTR
791 # if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
792 # define PTRV UV
793 # define INT2PTR(any,d) (any)(d)
794 # else
795 # if PTRSIZE == LONGSIZE
796 # define PTRV unsigned long
797 # else
798 # define PTRV unsigned
799 # endif
800 # define INT2PTR(any,d) (any)(PTRV)(d)
801 # endif
802
803 # define NUM2PTR(any,d) (any)(PTRV)(d)
804 # define PTR2IV(p) INT2PTR(IV,p)
805 # define PTR2UV(p) INT2PTR(UV,p)
806 # define PTR2NV(p) NUM2PTR(NV,p)
807
808 # if PTRSIZE == LONGSIZE
809 # define PTR2ul(p) (unsigned long)(p)
810 # else
811 # define PTR2ul(p) INT2PTR(unsigned long,p)
812 # endif
813 #endif /* !INT2PTR */
814
815 #ifndef SvPV_nolen
816 # define SvPV_nolen(x) SvPV(x,PL_na)
817 #endif
818
819 #ifndef get_sv
820 # define get_sv perl_get_sv
821 #endif
822
823 #ifndef ERRSV
824 # define ERRSV get_sv("@",FALSE)
825 #endif
826
827 #ifndef pTHX_
828 #define pTHX_
829 #endif
830
831 #include <string.h>
832 #ifdef __cplusplus
833 }
834 #endif
835
836 /* -----------------------------------------------------------------------------
837 * error manipulation
838 * ----------------------------------------------------------------------------- */
839
840 SWIGINTERN const char*
SWIG_Perl_ErrorType(int code)841 SWIG_Perl_ErrorType(int code) {
842 switch(code) {
843 case SWIG_MemoryError:
844 return "MemoryError";
845 case SWIG_IOError:
846 return "IOError";
847 case SWIG_RuntimeError:
848 return "RuntimeError";
849 case SWIG_IndexError:
850 return "IndexError";
851 case SWIG_TypeError:
852 return "TypeError";
853 case SWIG_DivisionByZero:
854 return "ZeroDivisionError";
855 case SWIG_OverflowError:
856 return "OverflowError";
857 case SWIG_SyntaxError:
858 return "SyntaxError";
859 case SWIG_ValueError:
860 return "ValueError";
861 case SWIG_SystemError:
862 return "SystemError";
863 case SWIG_AttributeError:
864 return "AttributeError";
865 default:
866 return "RuntimeError";
867 }
868 }
869
870
871 /* -----------------------------------------------------------------------------
872 * perlrun.swg
873 *
874 * This file contains the runtime support for Perl modules
875 * and includes code for managing global variables and pointer
876 * type checking.
877 * ----------------------------------------------------------------------------- */
878
879 #ifdef PERL_OBJECT
880 #define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
881 #define SWIG_PERL_OBJECT_CALL pPerl,
882 #else
883 #define SWIG_PERL_OBJECT_DECL
884 #define SWIG_PERL_OBJECT_CALL
885 #endif
886
887 /* Common SWIG API */
888
889 /* for raw pointers */
890 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
891 #define SWIG_ConvertPtrAndOwn(obj, pp, type, flags,own) SWIG_Perl_ConvertPtrAndOwn(SWIG_PERL_OBJECT_CALL obj, pp, type, flags, own)
892 #define SWIG_NewPointerObj(p, type, flags) SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
893 #define SWIG_AcquirePtr(ptr, src) SWIG_Perl_AcquirePtr(ptr, src)
894 #define swig_owntype int
895
896 /* for raw packed data */
897 #define SWIG_ConvertPacked(obj, p, s, type) SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
898 #define SWIG_NewPackedObj(p, s, type) SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
899
900 /* for class or struct pointers */
901 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
902 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
903
904 /* for C or C++ function pointers */
905 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
906 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
907
908 /* for C++ member pointers, ie, member methods */
909 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_ConvertPacked(obj, ptr, sz, ty)
910 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_NewPackedObj(ptr, sz, type)
911
912
913 /* Runtime API */
914
915 #define SWIG_GetModule(clientdata) SWIG_Perl_GetModule(clientdata)
916 #define SWIG_SetModule(clientdata, pointer) SWIG_Perl_SetModule(pointer)
917
918
919 /* Error manipulation */
920
921 #define SWIG_ErrorType(code) SWIG_Perl_ErrorType(code)
922 #define SWIG_Error(code, msg) sv_setpvf(get_sv("@", GV_ADD), "%s %s", SWIG_ErrorType(code), msg)
923 #define SWIG_fail goto fail
924
925 /* Perl-specific SWIG API */
926
927 #define SWIG_MakePtr(sv, ptr, type, flags) SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
928 #define SWIG_MakePackedObj(sv, p, s, type) SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
929 #define SWIG_SetError(str) SWIG_Error(SWIG_RuntimeError, str)
930
931
932 #define SWIG_PERL_DECL_ARGS_1(arg1) (SWIG_PERL_OBJECT_DECL arg1)
933 #define SWIG_PERL_CALL_ARGS_1(arg1) (SWIG_PERL_OBJECT_CALL arg1)
934 #define SWIG_PERL_DECL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_DECL arg1, arg2)
935 #define SWIG_PERL_CALL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_CALL arg1, arg2)
936
937 /* -----------------------------------------------------------------------------
938 * pointers/data manipulation
939 * ----------------------------------------------------------------------------- */
940
941 /* For backward compatibility only */
942 #define SWIG_POINTER_EXCEPTION 0
943
944 #ifdef __cplusplus
945 extern "C" {
946 #endif
947
948 #define SWIG_OWNER SWIG_POINTER_OWN
949 #define SWIG_SHADOW SWIG_OWNER << 1
950
951 #define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
952
953 /* SWIG Perl macros */
954
955 /* Macro to declare an XS function */
956 #ifndef XSPROTO
957 # define XSPROTO(name) void name(pTHX_ CV* cv)
958 #endif
959
960 /* Macro to call an XS function */
961 #ifdef PERL_OBJECT
962 # define SWIG_CALLXS(_name) _name(cv,pPerl)
963 #else
964 # ifndef MULTIPLICITY
965 # define SWIG_CALLXS(_name) _name(cv)
966 # else
967 # define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
968 # endif
969 #endif
970
971 #ifdef PERL_OBJECT
972 #define MAGIC_PPERL CPerlObj *pPerl = (CPerlObj *) this;
973
974 #ifdef __cplusplus
975 extern "C" {
976 #endif
977 typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
978 #ifdef __cplusplus
979 }
980 #endif
981
982 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
983 #define SWIGCLASS_STATIC
984
985 #else /* PERL_OBJECT */
986
987 #define MAGIC_PPERL
988 #define SWIGCLASS_STATIC static SWIGUNUSED
989
990 #ifndef MULTIPLICITY
991 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
992
993 #ifdef __cplusplus
994 extern "C" {
995 #endif
996 typedef int (*SwigMagicFunc)(SV *, MAGIC *);
997 #ifdef __cplusplus
998 }
999 #endif
1000
1001 #else /* MULTIPLICITY */
1002
1003 #define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
1004
1005 #ifdef __cplusplus
1006 extern "C" {
1007 #endif
1008 typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
1009 #ifdef __cplusplus
1010 }
1011 #endif
1012
1013 #endif /* MULTIPLICITY */
1014 #endif /* PERL_OBJECT */
1015
1016 # ifdef PERL_OBJECT
1017 # define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
SWIG_Perl_croak_null(CPerlObj * pPerl)1018 static void SWIGUNUSED SWIG_Perl_croak_null(CPerlObj *pPerl)
1019 # else
1020 static void SWIGUNUSED SWIG_croak_null()
1021 # endif
1022 {
1023 SV *err = get_sv("@", GV_ADD);
1024 # if (PERL_VERSION < 6)
1025 croak("%_", err);
1026 # else
1027 if (sv_isobject(err))
1028 croak(0);
1029 else
1030 croak("%s", SvPV_nolen(err));
1031 # endif
1032 }
1033
1034
1035 /*
1036 Define how strict is the cast between strings and integers/doubles
1037 when overloading between these types occurs.
1038
1039 The default is making it as strict as possible by using SWIG_AddCast
1040 when needed.
1041
1042 You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
1043 disable the SWIG_AddCast, making the casting between string and
1044 numbers less strict.
1045
1046 In the end, we try to solve the overloading between strings and
1047 numerical types in the more natural way, but if you can avoid it,
1048 well, avoid it using %rename, for example.
1049 */
1050 #ifndef SWIG_PERL_NO_STRICT_STR2NUM
1051 # ifndef SWIG_PERL_STRICT_STR2NUM
1052 # define SWIG_PERL_STRICT_STR2NUM
1053 # endif
1054 #endif
1055 #ifdef SWIG_PERL_STRICT_STR2NUM
1056 /* string takes precedence */
1057 #define SWIG_Str2NumCast(x) SWIG_AddCast(x)
1058 #else
1059 /* number takes precedence */
1060 #define SWIG_Str2NumCast(x) x
1061 #endif
1062
1063
1064
1065 #include <stdlib.h>
1066
1067 SWIGRUNTIME const char *
SWIG_Perl_TypeProxyName(const swig_type_info * type)1068 SWIG_Perl_TypeProxyName(const swig_type_info *type) {
1069 if (!type) return NULL;
1070 if (type->clientdata != NULL) {
1071 return (const char*) type->clientdata;
1072 }
1073 else {
1074 return type->name;
1075 }
1076 }
1077
1078 /* Identical to SWIG_TypeCheck, except for strcmp comparison */
1079 SWIGRUNTIME swig_cast_info *
SWIG_TypeProxyCheck(const char * c,swig_type_info * ty)1080 SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
1081 if (ty) {
1082 swig_cast_info *iter = ty->cast;
1083 while (iter) {
1084 if (strcmp(SWIG_Perl_TypeProxyName(iter->type), c) == 0) {
1085 if (iter == ty->cast)
1086 return iter;
1087 /* Move iter to the top of the linked list */
1088 iter->prev->next = iter->next;
1089 if (iter->next)
1090 iter->next->prev = iter->prev;
1091 iter->next = ty->cast;
1092 iter->prev = 0;
1093 if (ty->cast) ty->cast->prev = iter;
1094 ty->cast = iter;
1095 return iter;
1096 }
1097 iter = iter->next;
1098 }
1099 }
1100 return 0;
1101 }
1102
1103 /* Acquire a pointer value */
1104
1105 SWIGRUNTIME int
SWIG_Perl_AcquirePtr(SWIG_MAYBE_PERL_OBJECT SV * sv,int own)1106 SWIG_Perl_AcquirePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, int own) {
1107 /* TODO */
1108 return 0;
1109 }
1110
1111 /* Function for getting a pointer value */
1112
1113 SWIGRUNTIME int
SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV * sv,void ** ptr,swig_type_info * _t,int flags,int * own)1114 SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags, int *own) {
1115 swig_cast_info *tc;
1116 void *voidptr = (void *)0;
1117 SV *tsv = 0;
1118
1119 if (own)
1120 *own = 0;
1121
1122 /* If magical, apply more magic */
1123 if (SvGMAGICAL(sv))
1124 mg_get(sv);
1125
1126 /* Check to see if this is an object */
1127 if (sv_isobject(sv)) {
1128 IV tmp = 0;
1129 tsv = (SV*) SvRV(sv);
1130 if ((SvTYPE(tsv) == SVt_PVHV)) {
1131 MAGIC *mg;
1132 if (SvMAGICAL(tsv)) {
1133 mg = mg_find(tsv,'P');
1134 if (mg) {
1135 sv = mg->mg_obj;
1136 if (sv_isobject(sv)) {
1137 tsv = (SV*)SvRV(sv);
1138 tmp = SvIV(tsv);
1139 }
1140 }
1141 } else {
1142 return SWIG_ERROR;
1143 }
1144 } else {
1145 tmp = SvIV(tsv);
1146 }
1147 voidptr = INT2PTR(void *,tmp);
1148 } else if (! SvOK(sv)) { /* Check for undef */
1149 *(ptr) = (void *) 0;
1150 return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
1151 } else if (SvTYPE(sv) == SVt_RV) { /* Check for NULL pointer */
1152 if (!SvROK(sv)) {
1153 /* In Perl 5.12 and later, SVt_RV == SVt_IV, so sv could be a valid integer value. */
1154 if (SvIOK(sv)) {
1155 return SWIG_ERROR;
1156 } else {
1157 /* NULL pointer (reference to undef). */
1158 *(ptr) = (void *) 0;
1159 return SWIG_OK;
1160 }
1161 } else {
1162 return SWIG_ERROR;
1163 }
1164 } else { /* Don't know what it is */
1165 return SWIG_ERROR;
1166 }
1167 if (_t) {
1168 /* Now see if the types match */
1169 char *_c = HvNAME(SvSTASH(SvRV(sv)));
1170 tc = SWIG_TypeProxyCheck(_c,_t);
1171 #ifdef SWIG_DIRECTORS
1172 if (!tc && !sv_derived_from(sv,SWIG_Perl_TypeProxyName(_t))) {
1173 #else
1174 if (!tc) {
1175 #endif
1176 return SWIG_ERROR;
1177 }
1178 {
1179 int newmemory = 0;
1180 *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
1181 if (newmemory == SWIG_CAST_NEW_MEMORY) {
1182 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1183 if (own)
1184 *own = *own | SWIG_CAST_NEW_MEMORY;
1185 }
1186 }
1187 } else {
1188 *ptr = voidptr;
1189 }
1190
1191 /*
1192 * DISOWN implementation: we need a perl guru to check this one.
1193 */
1194 if (tsv && (flags & SWIG_POINTER_DISOWN)) {
1195 /*
1196 * almost copy paste code from below SWIG_POINTER_OWN setting
1197 */
1198 SV *obj = sv;
1199 HV *stash = SvSTASH(SvRV(obj));
1200 GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1201 if (isGV(gv)) {
1202 HV *hv = GvHVn(gv);
1203 /*
1204 * To set ownership (see below), a newSViv(1) entry is added.
1205 * Hence, to remove ownership, we delete the entry.
1206 */
1207 if (hv_exists_ent(hv, obj, 0)) {
1208 hv_delete_ent(hv, obj, 0, 0);
1209 }
1210 }
1211 }
1212 return SWIG_OK;
1213 }
1214
1215 SWIGRUNTIME int
1216 SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
1217 return SWIG_Perl_ConvertPtrAndOwn(sv, ptr, _t, flags, 0);
1218 }
1219
1220 SWIGRUNTIME void
1221 SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
1222 if (ptr && (flags & (SWIG_SHADOW | SWIG_POINTER_OWN))) {
1223 SV *self;
1224 SV *obj=newSV(0);
1225 HV *hash=newHV();
1226 HV *stash;
1227 sv_setref_pv(obj, SWIG_Perl_TypeProxyName(t), ptr);
1228 stash=SvSTASH(SvRV(obj));
1229 if (flags & SWIG_POINTER_OWN) {
1230 HV *hv;
1231 GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1232 if (!isGV(gv))
1233 gv_init(gv, stash, "OWNER", 5, FALSE);
1234 hv=GvHVn(gv);
1235 hv_store_ent(hv, obj, newSViv(1), 0);
1236 }
1237 sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
1238 SvREFCNT_dec(obj);
1239 self=newRV_noinc((SV *)hash);
1240 sv_setsv(sv, self);
1241 SvREFCNT_dec((SV *)self);
1242 sv_bless(sv, stash);
1243 }
1244 else {
1245 sv_setref_pv(sv, SWIG_Perl_TypeProxyName(t), ptr);
1246 }
1247 }
1248
1249 SWIGRUNTIMEINLINE SV *
1250 SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
1251 SV *result = sv_newmortal();
1252 SWIG_MakePtr(result, ptr, t, flags);
1253 return result;
1254 }
1255
1256 SWIGRUNTIME void
1257 SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
1258 char result[1024];
1259 char *r = result;
1260 if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
1261 *(r++) = '_';
1262 r = SWIG_PackData(r,ptr,sz);
1263 strcpy(r,SWIG_Perl_TypeProxyName(type));
1264 sv_setpv(sv, result);
1265 }
1266
1267 SWIGRUNTIME SV *
1268 SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
1269 SV *result = sv_newmortal();
1270 SWIG_Perl_MakePackedObj(result, ptr, sz, type);
1271 return result;
1272 }
1273
1274 /* Convert a packed pointer value */
1275 SWIGRUNTIME int
1276 SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
1277 swig_cast_info *tc;
1278 const char *c = 0;
1279
1280 if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
1281 c = SvPV_nolen(obj);
1282 /* Pointer values must start with leading underscore */
1283 if (*c != '_') return SWIG_ERROR;
1284 c++;
1285 c = SWIG_UnpackData(c,ptr,sz);
1286 if (ty) {
1287 tc = SWIG_TypeCheck(c,ty);
1288 if (!tc) return SWIG_ERROR;
1289 }
1290 return SWIG_OK;
1291 }
1292
1293
1294 /* Macros for low-level exception handling */
1295 #define SWIG_croak(x) { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
1296
1297
1298 typedef XSPROTO(SwigPerlWrapper);
1299 typedef SwigPerlWrapper *SwigPerlWrapperPtr;
1300
1301 /* Structure for command table */
1302 typedef struct {
1303 const char *name;
1304 SwigPerlWrapperPtr wrapper;
1305 } swig_command_info;
1306
1307 /* Information for constant table */
1308
1309 #define SWIG_INT 1
1310 #define SWIG_FLOAT 2
1311 #define SWIG_STRING 3
1312 #define SWIG_POINTER 4
1313 #define SWIG_BINARY 5
1314
1315 /* Constant information structure */
1316 typedef struct swig_constant_info {
1317 int type;
1318 const char *name;
1319 long lvalue;
1320 double dvalue;
1321 void *pvalue;
1322 swig_type_info **ptype;
1323 } swig_constant_info;
1324
1325
1326 /* Structure for variable table */
1327 typedef struct {
1328 const char *name;
1329 SwigMagicFunc set;
1330 SwigMagicFunc get;
1331 swig_type_info **type;
1332 } swig_variable_info;
1333
1334 /* Magic variable code */
1335 #ifndef PERL_OBJECT
1336 # ifdef __cplusplus
1337 # define swig_create_magic(s,a,b,c) _swig_create_magic(s,const_cast<char*>(a),b,c)
1338 # else
1339 # define swig_create_magic(s,a,b,c) _swig_create_magic(s,(char*)(a),b,c)
1340 # endif
1341 # ifndef MULTIPLICITY
1342 SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *))
1343 # else
1344 SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *))
1345 # endif
1346 #else
1347 # define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
1348 SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *))
1349 #endif
1350 {
1351 MAGIC *mg;
1352 sv_magic(sv,sv,'U',name,strlen(name));
1353 mg = mg_find(sv,'U');
1354 mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
1355 mg->mg_virtual->svt_get = (SwigMagicFunc) get;
1356 mg->mg_virtual->svt_set = (SwigMagicFunc) set;
1357 mg->mg_virtual->svt_len = 0;
1358 mg->mg_virtual->svt_clear = 0;
1359 mg->mg_virtual->svt_free = 0;
1360 }
1361
1362
1363 SWIGRUNTIME swig_module_info *
1364 SWIG_Perl_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
1365 static void *type_pointer = (void *)0;
1366 SV *pointer;
1367
1368 /* first check if pointer already created */
1369 if (!type_pointer) {
1370 pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
1371 if (pointer && SvOK(pointer)) {
1372 type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
1373 }
1374 }
1375
1376 return (swig_module_info *) type_pointer;
1377 }
1378
1379 SWIGRUNTIME void
1380 SWIG_Perl_SetModule(swig_module_info *module) {
1381 SV *pointer;
1382
1383 /* create a new pointer */
1384 pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
1385 sv_setiv(pointer, PTR2IV(module));
1386 }
1387
1388 #ifdef __cplusplus
1389 }
1390 #endif
1391
1392 /* Workaround perl5 global namespace pollution. Note that undefining library
1393 * functions like fopen will not solve the problem on all platforms as fopen
1394 * might be a macro on Windows but not necessarily on other operating systems. */
1395 #ifdef do_open
1396 #undef do_open
1397 #endif
1398 #ifdef do_close
1399 #undef do_close
1400 #endif
1401 #ifdef do_exec
1402 #undef do_exec
1403 #endif
1404 #ifdef scalar
1405 #undef scalar
1406 #endif
1407 #ifdef list
1408 #undef list
1409 #endif
1410 #ifdef apply
1411 #undef apply
1412 #endif
1413 #ifdef convert
1414 #undef convert
1415 #endif
1416 #ifdef Error
1417 #undef Error
1418 #endif
1419 #ifdef form
1420 #undef form
1421 #endif
1422 #ifdef vform
1423 #undef vform
1424 #endif
1425 #ifdef LABEL
1426 #undef LABEL
1427 #endif
1428 #ifdef METHOD
1429 #undef METHOD
1430 #endif
1431 #ifdef Move
1432 #undef Move
1433 #endif
1434 #ifdef yylex
1435 #undef yylex
1436 #endif
1437 #ifdef yyparse
1438 #undef yyparse
1439 #endif
1440 #ifdef yyerror
1441 #undef yyerror
1442 #endif
1443 #ifdef invert
1444 #undef invert
1445 #endif
1446 #ifdef ref
1447 #undef ref
1448 #endif
1449 #ifdef read
1450 #undef read
1451 #endif
1452 #ifdef write
1453 #undef write
1454 #endif
1455 #ifdef eof
1456 #undef eof
1457 #endif
1458 #ifdef close
1459 #undef close
1460 #endif
1461 #ifdef rewind
1462 #undef rewind
1463 #endif
1464 #ifdef free
1465 #undef free
1466 #endif
1467 #ifdef malloc
1468 #undef malloc
1469 #endif
1470 #ifdef calloc
1471 #undef calloc
1472 #endif
1473 #ifdef Stat
1474 #undef Stat
1475 #endif
1476 #ifdef check
1477 #undef check
1478 #endif
1479 #ifdef seekdir
1480 #undef seekdir
1481 #endif
1482 #ifdef open
1483 #undef open
1484 #endif
1485 #ifdef readdir
1486 #undef readdir
1487 #endif
1488 #ifdef bind
1489 #undef bind
1490 #endif
1491 #ifdef access
1492 #undef access
1493 #endif
1494 #ifdef stat
1495 #undef stat
1496 #endif
1497 #ifdef seed
1498 #undef seed
1499 #endif
1500
1501 #ifdef bool
1502 /* Leave if macro is from C99 stdbool.h */
1503 #ifndef __bool_true_false_are_defined
1504 #undef bool
1505 #endif
1506 #endif
1507
1508
1509
1510
1511 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1512
1513 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1514
1515
1516
1517 /* -------- TYPES TABLE (BEGIN) -------- */
1518
1519 #define SWIGTYPE_p_FILE swig_types[0]
1520 #define SWIGTYPE_p_char swig_types[1]
1521 #define SWIGTYPE_p_double swig_types[2]
1522 #define SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void swig_types[3]
1523 #define SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void swig_types[4]
1524 #define SWIGTYPE_p_gsl_matrix swig_types[5]
1525 #define SWIGTYPE_p_gsl_wavelet swig_types[6]
1526 #define SWIGTYPE_p_gsl_wavelet_direction swig_types[7]
1527 #define SWIGTYPE_p_gsl_wavelet_workspace swig_types[8]
1528 static swig_type_info *swig_types[10];
1529 static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
1530 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1531 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1532
1533 /* -------- TYPES TABLE (END) -------- */
1534
1535 #define SWIG_init boot_Math__GSL__Wavelet2D
1536
1537 #define SWIG_name "Math::GSL::Wavelet2Dc::boot_Math__GSL__Wavelet2D"
1538 #define SWIG_prefix "Math::GSL::Wavelet2Dc::"
1539
1540 #define SWIGVERSION 0x040001
1541 #define SWIG_VERSION SWIGVERSION
1542
1543
1544 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1545 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1546
1547
1548 #ifdef __cplusplus
1549 extern "C"
1550 #endif
1551 #ifndef PERL_OBJECT
1552 #ifndef MULTIPLICITY
1553 SWIGEXPORT void SWIG_init (CV* cv);
1554 #else
1555 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1556 #endif
1557 #else
1558 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1559 #endif
1560
1561
1562 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(double value)1563 SWIG_From_double SWIG_PERL_DECL_ARGS_1(double value)
1564 {
1565 return sv_2mortal(newSVnv(value));
1566 }
1567
1568
1569 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(long value)1570 SWIG_From_long SWIG_PERL_DECL_ARGS_1(long value)
1571 {
1572 SV *sv;
1573 if (IVSIZE >= sizeof(value) || (value >= IV_MIN && value <= IV_MAX))
1574 sv = newSViv(value);
1575 else
1576 sv = newSVpvf("%ld", value);
1577 return sv_2mortal(sv);
1578 }
1579
1580
1581 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(int value)1582 SWIG_From_int SWIG_PERL_DECL_ARGS_1(int value)
1583 {
1584 return SWIG_From_long SWIG_PERL_CALL_ARGS_1(value);
1585 }
1586
1587
1588 SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)1589 SWIG_pchar_descriptor(void)
1590 {
1591 static int init = 0;
1592 static swig_type_info* info = 0;
1593 if (!init) {
1594 info = SWIG_TypeQuery("_p_char");
1595 init = 1;
1596 }
1597 return info;
1598 }
1599
1600
1601 SWIGINTERN int
SWIG_AsCharPtrAndSize(SV * obj,char ** cptr,size_t * psize,int * alloc)1602 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1603 {
1604 if (SvMAGICAL(obj)) {
1605 SV *tmp = sv_newmortal();
1606 SvSetSV(tmp, obj);
1607 obj = tmp;
1608 }
1609 if (SvPOK(obj)) {
1610 STRLEN len = 0;
1611 char *cstr = SvPV(obj, len);
1612 size_t size = len + 1;
1613 if (cptr) {
1614 if (alloc) {
1615 if (*alloc == SWIG_NEWOBJ) {
1616 *cptr = (char *)memcpy(malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1617 } else {
1618 *cptr = cstr;
1619 *alloc = SWIG_OLDOBJ;
1620 }
1621 }
1622 }
1623 if (psize) *psize = size;
1624 return SWIG_OK;
1625 } else {
1626 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1627 if (pchar_descriptor) {
1628 char* vptr = 0;
1629 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1630 if (cptr) *cptr = vptr;
1631 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1632 if (alloc) *alloc = SWIG_OLDOBJ;
1633 return SWIG_OK;
1634 }
1635 }
1636 }
1637 return SWIG_TypeError;
1638 }
1639
1640
1641
1642
1643
1644 #include <limits.h>
1645 #if !defined(SWIG_NO_LLONG_MAX)
1646 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1647 # define LLONG_MAX __LONG_LONG_MAX__
1648 # define LLONG_MIN (-LLONG_MAX - 1LL)
1649 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1650 # endif
1651 #endif
1652
1653
1654 #include <stdlib.h>
1655 #ifdef _MSC_VER
1656 # ifndef strtoull
1657 # define strtoull _strtoui64
1658 # endif
1659 # ifndef strtoll
1660 # define strtoll _strtoi64
1661 # endif
1662 #endif
1663
1664
1665 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,double * val)1666 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1667 {
1668 if (SvNIOK(obj)) {
1669 if (val) *val = SvNV(obj);
1670 return SWIG_OK;
1671 } else if (SvIOK(obj)) {
1672 if (val) *val = (double) SvIV(obj);
1673 return SWIG_AddCast(SWIG_OK);
1674 } else {
1675 const char *nptr = SvPV_nolen(obj);
1676 if (nptr) {
1677 char *endptr;
1678 double v;
1679 errno = 0;
1680 v = strtod(nptr, &endptr);
1681 if (errno == ERANGE) {
1682 errno = 0;
1683 return SWIG_OverflowError;
1684 } else {
1685 if (*endptr == '\0') {
1686 if (val) *val = v;
1687 return SWIG_Str2NumCast(SWIG_OK);
1688 }
1689 }
1690 }
1691 }
1692 return SWIG_TypeError;
1693 }
1694
1695
1696 #include <float.h>
1697
1698
1699 #include <math.h>
1700
1701
1702 SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double * d,double min,double max)1703 SWIG_CanCastAsInteger(double *d, double min, double max) {
1704 double x = *d;
1705 if ((min <= x && x <= max)) {
1706 double fx = floor(x);
1707 double cx = ceil(x);
1708 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1709 if ((errno == EDOM) || (errno == ERANGE)) {
1710 errno = 0;
1711 } else {
1712 double summ, reps, diff;
1713 if (rd < x) {
1714 diff = x - rd;
1715 } else if (rd > x) {
1716 diff = rd - x;
1717 } else {
1718 return 1;
1719 }
1720 summ = rd + x;
1721 reps = diff/summ;
1722 if (reps < 8*DBL_EPSILON) {
1723 *d = rd;
1724 return 1;
1725 }
1726 }
1727 }
1728 return 0;
1729 }
1730
1731
1732 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,long * val)1733 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1734 {
1735 if (SvUOK(obj)) {
1736 UV v = SvUV(obj);
1737 if (UVSIZE < sizeof(*val) || v <= LONG_MAX) {
1738 if (val) *val = v;
1739 return SWIG_OK;
1740 }
1741 return SWIG_OverflowError;
1742 } else if (SvIOK(obj)) {
1743 IV v = SvIV(obj);
1744 if (IVSIZE <= sizeof(*val) || (v >= LONG_MIN && v <= LONG_MAX)) {
1745 if(val) *val = v;
1746 return SWIG_OK;
1747 }
1748 return SWIG_OverflowError;
1749 } else {
1750 int dispatch = 0;
1751 const char *nptr = SvPV_nolen(obj);
1752 if (nptr) {
1753 char *endptr;
1754 long v;
1755 errno = 0;
1756 v = strtol(nptr, &endptr,0);
1757 if (errno == ERANGE) {
1758 errno = 0;
1759 return SWIG_OverflowError;
1760 } else {
1761 if (*endptr == '\0') {
1762 if (val) *val = v;
1763 return SWIG_Str2NumCast(SWIG_OK);
1764 }
1765 }
1766 }
1767 if (!dispatch) {
1768 double d;
1769 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1770 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1771 if (val) *val = (long)(d);
1772 return res;
1773 }
1774 }
1775 }
1776 return SWIG_TypeError;
1777 }
1778
1779
1780 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,int * val)1781 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1782 {
1783 long v;
1784 int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1785 if (SWIG_IsOK(res)) {
1786 if ((v < INT_MIN || v > INT_MAX)) {
1787 return SWIG_OverflowError;
1788 } else {
1789 if (val) *val = (int)(v);
1790 }
1791 }
1792 return res;
1793 }
1794
1795
1796 SWIGINTERNINLINE SV *
SWIG_FromCharPtrAndSize(const char * carray,size_t size)1797 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1798 {
1799 SV *obj = sv_newmortal();
1800 if (carray) {
1801 sv_setpvn(obj, carray, size);
1802 } else {
1803 sv_setsv(obj, &PL_sv_undef);
1804 }
1805 return obj;
1806 }
1807
1808
1809 SWIGINTERNINLINE SV *
SWIG_FromCharPtr(const char * cptr)1810 SWIG_FromCharPtr(const char *cptr)
1811 {
1812 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1813 }
1814
1815
1816 #include "gsl/gsl_nan.h"
1817 #include "gsl/gsl_errno.h"
1818 #include "gsl/gsl_math.h"
1819 #include "gsl/gsl_monte.h"
1820
1821
1822 struct perl_array {
1823 I32 len;
1824 AV *array;
1825 };
1826
1827
1828
1829 enum awType { awDouble, awFloat, awInt, awUnsigned };
1830
1831 typedef struct {
1832 I32 size;
1833 enum awType type;
1834 void * data;
1835 } array_wrapper;
1836
array_wrapper_alloc(int numelem,enum awType type)1837 array_wrapper * array_wrapper_alloc(int numelem, enum awType type){
1838 array_wrapper * rv = malloc(sizeof(array_wrapper));
1839
1840 if (rv == NULL)
1841 croak("array_wrapper_alloc: can't malloc wrapper\n");
1842
1843 switch (type){
1844 case awDouble:
1845 rv->data = malloc(sizeof(double) * numelem);
1846 break;
1847 case awFloat:
1848 rv->data = malloc(sizeof(float) * numelem);
1849 break;
1850 case awInt:
1851 rv->data = malloc(sizeof(int) * numelem);
1852 break;
1853 case awUnsigned:
1854 rv->data = malloc(sizeof(unsigned int) * numelem);
1855 break;
1856 default:
1857 croak("array_wrapper_alloc: type should be awDouble, awFloat, awInt, or awUnsigned");
1858 }
1859
1860 if (rv->data == NULL)
1861 croak("array_wrapper_alloc: can't malloc data");
1862
1863 rv->size = numelem;
1864 rv->type = type;
1865 return rv;
1866 }
1867
array_wrapper_free(array_wrapper * daw)1868 void array_wrapper_free(array_wrapper * daw){
1869 free(daw->data);
1870 free(daw);
1871 }
1872
1873
1874 /* structure to hold required information while the gsl function call
1875 for each callback
1876 */
1877 struct gsl_function_perl {
1878 gsl_function C_gsl_function;
1879 SV * function;
1880 SV * params;
1881 };
1882
1883 struct gsl_function_fdf_perl {
1884 gsl_function_fdf C_gsl_function_fdf;
1885 SV * f;
1886 SV * df;
1887 SV * fdf;
1888 SV * params;
1889 };
1890
1891 struct gsl_monte_function_perl {
1892 gsl_monte_function C_gsl_monte_function;
1893 SV * f;
1894 SV * dim;
1895 SV * params;
1896 };
1897
gsl_function_perl_free(struct gsl_function_perl * perl_f)1898 void gsl_function_perl_free(struct gsl_function_perl * perl_f){
1899 if (perl_f != NULL) {
1900 SvREFCNT_dec(perl_f->function);
1901 SvREFCNT_dec(perl_f->params);
1902 Safefree(perl_f);
1903 }
1904 }
1905
gsl_function_fdf_perl_free(struct gsl_function_fdf_perl * perl_fdf)1906 void gsl_function_fdf_perl_free(struct gsl_function_fdf_perl * perl_fdf){
1907 if (perl_fdf != NULL) {
1908 SvREFCNT_dec(perl_fdf->f);
1909 SvREFCNT_dec(perl_fdf->df);
1910 SvREFCNT_dec(perl_fdf->fdf);
1911 SvREFCNT_dec(perl_fdf->params);
1912 Safefree(perl_fdf);
1913 }
1914 }
1915
1916 /* These functions (C callbacks) calls the perl callbacks.
1917 Info for perl callback can be found using the 'void*params' parameter
1918 */
call_gsl_function_x_params(SV * function,double x,SV * params)1919 double call_gsl_function_x_params(SV* function, double x, SV *params){
1920 unsigned int count;
1921 double y;
1922 dSP;
1923
1924 //fprintf(stderr, "LOOKUP CALLBACK\n");
1925 ENTER;
1926 SAVETMPS;
1927
1928 PUSHMARK(SP);
1929 XPUSHs(sv_2mortal(newSVnv((double)x)));
1930 XPUSHs(params);
1931 PUTBACK; /* make local stack pointer global */
1932
1933 count = call_sv(function, G_SCALAR);
1934 SPAGAIN;
1935
1936 if (count != 1)
1937 croak("Expected to call subroutine in scalar context!");
1938
1939 y = POPn;
1940
1941 PUTBACK; /* make local stack pointer global */
1942 FREETMPS;
1943 LEAVE;
1944
1945 return y;
1946 }
1947
call_gsl_function(double x,void * params)1948 double call_gsl_function(double x , void *params){
1949 struct gsl_function_perl *F=(struct gsl_function_perl*)params;
1950 return call_gsl_function_x_params( F->function, x, F->params );
1951 }
1952
call_gsl_function_fdf_f(double x,void * params)1953 double call_gsl_function_fdf_f(double x , void *params){
1954 struct gsl_function_fdf_perl *F=(struct gsl_function_fdf_perl*)params;
1955 return call_gsl_function_x_params( F->f, x, F->params );
1956 }
1957
call_gsl_function_fdf_df(double x,void * params)1958 double call_gsl_function_fdf_df(double x , void *params){
1959 struct gsl_function_fdf_perl *F=(struct gsl_function_fdf_perl*)params;
1960 return call_gsl_function_x_params( F->df, x, F->params );
1961 }
1962
call_gsl_function_fdf_fdf(double x,void * params,double * f,double * df)1963 void call_gsl_function_fdf_fdf(double x , void *params, double *f, double *df ){
1964 struct gsl_function_fdf_perl *F=(struct gsl_function_fdf_perl*)params;
1965
1966 dSP;
1967
1968 ENTER;
1969 SAVETMPS;
1970
1971 PUSHMARK(SP);
1972 EXTEND(SP, 2);
1973 PUSHs(sv_2mortal(newSVnv((double)x)));
1974 PUSHs(F->params);
1975 PUTBACK; /* make local stack pointer global */
1976
1977 {
1978 unsigned int count = call_sv(F->fdf, G_ARRAY);
1979 SPAGAIN;
1980
1981 if (count != 2)
1982 croak( "Expected two return values, got %d", count );
1983 }
1984
1985 *df = POPn;
1986 *f = POPn;
1987
1988 PUTBACK; /* make local stack pointer global */
1989 FREETMPS;
1990 LEAVE;
1991 }
1992
call_gsl_monte_function(double * x_array,size_t dim,void * params)1993 double call_gsl_monte_function(double *x_array , size_t dim, void *params){
1994 struct gsl_monte_function_perl *F=(struct gsl_monte_function_perl*)params;
1995 unsigned int count;
1996 unsigned int i;
1997 AV* perl_array;
1998 double y;
1999 dSP;
2000
2001 //fprintf(stderr, "LOOKUP CALLBACK\n");
2002 ENTER;
2003 SAVETMPS;
2004
2005 PUSHMARK(SP);
2006 perl_array=newAV();
2007 sv_2mortal((SV*)perl_array);
2008 XPUSHs(sv_2mortal(newRV((SV *)perl_array)));
2009 for(i=0; i<dim; i++) {
2010 /* no mortal : it is referenced by the array */
2011 av_push(perl_array, newSVnv(x_array[i]));
2012 }
2013 XPUSHs(sv_2mortal(newSViv(dim)));
2014 XPUSHs(F->params);
2015 PUTBACK; /* make local stack pointer global */
2016
2017 count = call_sv(F->f, G_SCALAR);
2018 SPAGAIN;
2019
2020 if (count != 1)
2021 croak("Expected to call subroutine in scalar context!");
2022
2023 y = POPn;
2024
2025 PUTBACK; /* make local stack pointer global */
2026 FREETMPS;
2027 LEAVE;
2028
2029 return y;
2030 }
2031
2032
gsl_function_fdf_extract(char * param_name,HV * hash,SV * func[])2033 void gsl_function_fdf_extract( char* param_name, HV* hash, SV* func[] ) {
2034 static const char *keys[3] = { "f", "df", "fdf" };
2035
2036 int ikey;
2037
2038 for ( ikey = 0 ; ikey < 3 ; ++ikey ) {
2039 func[ikey] = 0;
2040 const char* key = keys[ikey];
2041 /* it just so happens that strlen(keys[ikey]) == ikey + 1 */
2042 SV** pp_sv = hv_fetch( hash, key, ikey+1, 0 );
2043 SV* function;
2044
2045 if ( !pp_sv )
2046 croak("Math::GSL : %s: missing key %s!", param_name, key);
2047
2048 function = *pp_sv;
2049
2050 if ( SvPOK(function) || ( SvROK( function ) && SvTYPE(SvRV(function)) == SVt_PVCV ) ) {
2051 /* hold on to SV after the enclosing hash goes away */
2052 SvREFCNT_inc( function );
2053 func[ikey] = function;
2054 }
2055 else {
2056 croak( "Math::GSL : %s: key %s is not a reference to code!", param_name, key);
2057 }
2058 }
2059 }
2060
2061
2062
2063 #include "gsl/gsl_types.h"
2064 #include "gsl/gsl_wavelet2d.h"
2065
2066
2067 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,unsigned long * val)2068 SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
2069 {
2070 if (SvUOK(obj)) {
2071 UV v = SvUV(obj);
2072 if (UVSIZE <= sizeof(*val) || v <= ULONG_MAX) {
2073 if (val) *val = v;
2074 return SWIG_OK;
2075 }
2076 return SWIG_OverflowError;
2077 } else if (SvIOK(obj)) {
2078 IV v = SvIV(obj);
2079 if (v >= 0 && (IVSIZE <= sizeof(*val) || v <= ULONG_MAX)) {
2080 if (val) *val = v;
2081 return SWIG_OK;
2082 }
2083 return SWIG_OverflowError;
2084 } else {
2085 int dispatch = 0;
2086 const char *nptr = SvPV_nolen(obj);
2087 if (nptr) {
2088 char *endptr;
2089 unsigned long v;
2090 errno = 0;
2091 v = strtoul(nptr, &endptr,0);
2092 if (errno == ERANGE) {
2093 errno = 0;
2094 return SWIG_OverflowError;
2095 } else {
2096 if (*endptr == '\0') {
2097 if (val) *val = v;
2098 return SWIG_Str2NumCast(SWIG_OK);
2099 }
2100 }
2101 }
2102 if (!dispatch) {
2103 double d;
2104 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
2105 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2106 if (val) *val = (unsigned long)(d);
2107 return res;
2108 }
2109 }
2110 }
2111 return SWIG_TypeError;
2112 }
2113
2114
2115 #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
2116 # define SWIG_LONG_LONG_AVAILABLE
2117 #endif
2118
2119
2120 #ifdef SWIG_LONG_LONG_AVAILABLE
2121 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,unsigned long long * val)2122 SWIG_AsVal_unsigned_SS_long_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long long *val)
2123 {
2124 if (SvUOK(obj)) {
2125 /* pretty sure this should be conditional on
2126 * (UVSIZE <= sizeof(*val) || v <= ULLONG_MAX) */
2127 if (val) *val = SvUV(obj);
2128 return SWIG_OK;
2129 } else if (SvIOK(obj)) {
2130 IV v = SvIV(obj);
2131 if (v >= 0 && (IVSIZE <= sizeof(*val) || v <= ULLONG_MAX)) {
2132 if (val) *val = v;
2133 return SWIG_OK;
2134 } else {
2135 return SWIG_OverflowError;
2136 }
2137 } else {
2138 int dispatch = 0;
2139 const char *nptr = SvPV_nolen(obj);
2140 if (nptr) {
2141 char *endptr;
2142 unsigned long long v;
2143 errno = 0;
2144 v = strtoull(nptr, &endptr,0);
2145 if (errno == ERANGE) {
2146 errno = 0;
2147 return SWIG_OverflowError;
2148 } else {
2149 if (*endptr == '\0') {
2150 if (val) *val = v;
2151 return SWIG_Str2NumCast(SWIG_OK);
2152 }
2153 }
2154 }
2155 if (!dispatch) {
2156 const double mant_max = 1LL << DBL_MANT_DIG;
2157 double d;
2158 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
2159 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
2160 if (val) *val = (unsigned long long)(d);
2161 return res;
2162 }
2163 }
2164 }
2165 return SWIG_TypeError;
2166 }
2167 #endif
2168
2169
2170 SWIGINTERNINLINE int
SWIG_PERL_DECL_ARGS_2(SV * obj,size_t * val)2171 SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
2172 {
2173 int res = SWIG_TypeError;
2174 #ifdef SWIG_LONG_LONG_AVAILABLE
2175 if (sizeof(size_t) <= sizeof(unsigned long)) {
2176 #endif
2177 unsigned long v;
2178 res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
2179 if (SWIG_IsOK(res) && val) *val = (size_t)(v);
2180 #ifdef SWIG_LONG_LONG_AVAILABLE
2181 } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
2182 unsigned long long v;
2183 res = SWIG_AsVal_unsigned_SS_long_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
2184 if (SWIG_IsOK(res) && val) *val = (size_t)(v);
2185 }
2186 #endif
2187 return res;
2188 }
2189
2190 #ifdef __cplusplus
2191 extern "C" {
2192 #endif
2193
2194 #ifdef PERL_OBJECT
2195 #define MAGIC_CLASS _wrap_Math__GSL__Wavelet2D_var::
2196 class _wrap_Math__GSL__Wavelet2D_var : public CPerlObj {
2197 public:
2198 #else
2199 #define MAGIC_CLASS
2200 #endif
swig_magic_readonly(pTHX_ SV * SWIGUNUSEDPARM (sv),MAGIC * SWIGUNUSEDPARM (mg))2201 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
2202 MAGIC_PPERL
2203 croak("Value is read-only.");
2204 return 0;
2205 }
2206
2207
2208 #ifdef PERL_OBJECT
2209 };
2210 #endif
2211
2212 #ifdef __cplusplus
2213 }
2214 #endif
2215
2216 #ifdef __cplusplus
2217 extern "C" {
2218 #endif
XS(_wrap_gsl_error)2219 XS(_wrap_gsl_error) {
2220 {
2221 char *arg1 = (char *) 0 ;
2222 char *arg2 = (char *) 0 ;
2223 int arg3 ;
2224 int arg4 ;
2225 int res1 ;
2226 char *buf1 = 0 ;
2227 int alloc1 = 0 ;
2228 int res2 ;
2229 char *buf2 = 0 ;
2230 int alloc2 = 0 ;
2231 int val3 ;
2232 int ecode3 = 0 ;
2233 int val4 ;
2234 int ecode4 = 0 ;
2235 int argvi = 0;
2236 dXSARGS;
2237
2238 if ((items < 4) || (items > 4)) {
2239 SWIG_croak("Usage: gsl_error(reason,file,line,gsl_errno);");
2240 }
2241 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2242 if (!SWIG_IsOK(res1)) {
2243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_error" "', argument " "1"" of type '" "char const *""'");
2244 }
2245 arg1 = (char *)(buf1);
2246 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2247 if (!SWIG_IsOK(res2)) {
2248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_error" "', argument " "2"" of type '" "char const *""'");
2249 }
2250 arg2 = (char *)(buf2);
2251 ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2252 if (!SWIG_IsOK(ecode3)) {
2253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_error" "', argument " "3"" of type '" "int""'");
2254 }
2255 arg3 = (int)(val3);
2256 ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
2257 if (!SWIG_IsOK(ecode4)) {
2258 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_error" "', argument " "4"" of type '" "int""'");
2259 }
2260 arg4 = (int)(val4);
2261 gsl_error((char const *)arg1,(char const *)arg2,arg3,arg4);
2262 ST(argvi) = &PL_sv_undef;
2263 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2264 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2265
2266
2267 XSRETURN(argvi);
2268 fail:
2269 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2270 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2271
2272
2273 SWIG_croak_null();
2274 }
2275 }
2276
2277
XS(_wrap_gsl_stream_printf)2278 XS(_wrap_gsl_stream_printf) {
2279 {
2280 char *arg1 = (char *) 0 ;
2281 char *arg2 = (char *) 0 ;
2282 int arg3 ;
2283 char *arg4 = (char *) 0 ;
2284 int res1 ;
2285 char *buf1 = 0 ;
2286 int alloc1 = 0 ;
2287 int res2 ;
2288 char *buf2 = 0 ;
2289 int alloc2 = 0 ;
2290 int val3 ;
2291 int ecode3 = 0 ;
2292 int res4 ;
2293 char *buf4 = 0 ;
2294 int alloc4 = 0 ;
2295 int argvi = 0;
2296 dXSARGS;
2297
2298 if ((items < 4) || (items > 4)) {
2299 SWIG_croak("Usage: gsl_stream_printf(label,file,line,reason);");
2300 }
2301 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2302 if (!SWIG_IsOK(res1)) {
2303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_stream_printf" "', argument " "1"" of type '" "char const *""'");
2304 }
2305 arg1 = (char *)(buf1);
2306 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2307 if (!SWIG_IsOK(res2)) {
2308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_stream_printf" "', argument " "2"" of type '" "char const *""'");
2309 }
2310 arg2 = (char *)(buf2);
2311 ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2312 if (!SWIG_IsOK(ecode3)) {
2313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_stream_printf" "', argument " "3"" of type '" "int""'");
2314 }
2315 arg3 = (int)(val3);
2316 res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
2317 if (!SWIG_IsOK(res4)) {
2318 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gsl_stream_printf" "', argument " "4"" of type '" "char const *""'");
2319 }
2320 arg4 = (char *)(buf4);
2321 gsl_stream_printf((char const *)arg1,(char const *)arg2,arg3,(char const *)arg4);
2322 ST(argvi) = &PL_sv_undef;
2323 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2324 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2325
2326 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2327 XSRETURN(argvi);
2328 fail:
2329 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2330 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2331
2332 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2333 SWIG_croak_null();
2334 }
2335 }
2336
2337
XS(_wrap_gsl_strerror)2338 XS(_wrap_gsl_strerror) {
2339 {
2340 int arg1 ;
2341 int val1 ;
2342 int ecode1 = 0 ;
2343 int argvi = 0;
2344 char *result = 0 ;
2345 dXSARGS;
2346
2347 if ((items < 1) || (items > 1)) {
2348 SWIG_croak("Usage: gsl_strerror(gsl_errno);");
2349 }
2350 ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2351 if (!SWIG_IsOK(ecode1)) {
2352 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_strerror" "', argument " "1"" of type '" "int""'");
2353 }
2354 arg1 = (int)(val1);
2355 result = (char *)gsl_strerror(arg1);
2356 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2357
2358 XSRETURN(argvi);
2359 fail:
2360
2361 SWIG_croak_null();
2362 }
2363 }
2364
2365
XS(_wrap_gsl_set_error_handler)2366 XS(_wrap_gsl_set_error_handler) {
2367 {
2368 gsl_error_handler_t *arg1 = (gsl_error_handler_t *) 0 ;
2369 int argvi = 0;
2370 gsl_error_handler_t *result = 0 ;
2371 dXSARGS;
2372
2373 if ((items < 1) || (items > 1)) {
2374 SWIG_croak("Usage: gsl_set_error_handler(new_handler);");
2375 }
2376 {
2377 int res = SWIG_ConvertFunctionPtr(ST(0), (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void);
2378 if (!SWIG_IsOK(res)) {
2379 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gsl_set_error_handler" "', argument " "1"" of type '" "gsl_error_handler_t *""'");
2380 }
2381 }
2382 result = (gsl_error_handler_t *)gsl_set_error_handler(arg1);
2383 ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void); argvi++ ;
2384
2385 XSRETURN(argvi);
2386 fail:
2387
2388 SWIG_croak_null();
2389 }
2390 }
2391
2392
XS(_wrap_gsl_set_error_handler_off)2393 XS(_wrap_gsl_set_error_handler_off) {
2394 {
2395 int argvi = 0;
2396 gsl_error_handler_t *result = 0 ;
2397 dXSARGS;
2398
2399 if ((items < 0) || (items > 0)) {
2400 SWIG_croak("Usage: gsl_set_error_handler_off();");
2401 }
2402 result = (gsl_error_handler_t *)gsl_set_error_handler_off();
2403 ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void); argvi++ ;
2404 XSRETURN(argvi);
2405 fail:
2406 SWIG_croak_null();
2407 }
2408 }
2409
2410
XS(_wrap_gsl_set_stream_handler)2411 XS(_wrap_gsl_set_stream_handler) {
2412 {
2413 gsl_stream_handler_t *arg1 = (gsl_stream_handler_t *) 0 ;
2414 int argvi = 0;
2415 gsl_stream_handler_t *result = 0 ;
2416 dXSARGS;
2417
2418 if ((items < 1) || (items > 1)) {
2419 SWIG_croak("Usage: gsl_set_stream_handler(new_handler);");
2420 }
2421 {
2422 int res = SWIG_ConvertFunctionPtr(ST(0), (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void);
2423 if (!SWIG_IsOK(res)) {
2424 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gsl_set_stream_handler" "', argument " "1"" of type '" "gsl_stream_handler_t *""'");
2425 }
2426 }
2427 result = (gsl_stream_handler_t *)gsl_set_stream_handler(arg1);
2428 ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void); argvi++ ;
2429
2430 XSRETURN(argvi);
2431 fail:
2432
2433 SWIG_croak_null();
2434 }
2435 }
2436
2437
XS(_wrap_gsl_set_stream)2438 XS(_wrap_gsl_set_stream) {
2439 {
2440 FILE *arg1 = (FILE *) 0 ;
2441 void *argp1 = 0 ;
2442 int res1 = 0 ;
2443 int argvi = 0;
2444 FILE *result = 0 ;
2445 dXSARGS;
2446
2447 if ((items < 1) || (items > 1)) {
2448 SWIG_croak("Usage: gsl_set_stream(new_stream);");
2449 }
2450 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_FILE, 0 | 0 );
2451 if (!SWIG_IsOK(res1)) {
2452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_set_stream" "', argument " "1"" of type '" "FILE *""'");
2453 }
2454 arg1 = (FILE *)(argp1);
2455 result = (FILE *)gsl_set_stream(arg1);
2456 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 | 0); argvi++ ;
2457
2458 XSRETURN(argvi);
2459 fail:
2460
2461 SWIG_croak_null();
2462 }
2463 }
2464
2465
XS(_wrap_gsl_wavelet2d_transform)2466 XS(_wrap_gsl_wavelet2d_transform) {
2467 {
2468 gsl_wavelet *arg1 = (gsl_wavelet *) 0 ;
2469 double *arg2 = (double *) 0 ;
2470 size_t arg3 ;
2471 size_t arg4 ;
2472 size_t arg5 ;
2473 gsl_wavelet_direction arg6 ;
2474 gsl_wavelet_workspace *arg7 = (gsl_wavelet_workspace *) 0 ;
2475 void *argp1 = 0 ;
2476 int res1 = 0 ;
2477 size_t val3 ;
2478 int ecode3 = 0 ;
2479 size_t val4 ;
2480 int ecode4 = 0 ;
2481 size_t val5 ;
2482 int ecode5 = 0 ;
2483 void *argp6 ;
2484 int res6 = 0 ;
2485 void *argp7 = 0 ;
2486 int res7 = 0 ;
2487 int argvi = 0;
2488 int result;
2489 dXSARGS;
2490
2491 if ((items < 7) || (items > 7)) {
2492 SWIG_croak("Usage: gsl_wavelet2d_transform(w,data,tda,size1,size2,dir,work);");
2493 }
2494 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_wavelet, 0 | 0 );
2495 if (!SWIG_IsOK(res1)) {
2496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_wavelet2d_transform" "', argument " "1"" of type '" "gsl_wavelet const *""'");
2497 }
2498 arg1 = (gsl_wavelet *)(argp1);
2499 {
2500 AV *tempav;
2501 I32 len;
2502 int i;
2503 SV **tv;
2504 if (!SvROK(ST(1)))
2505 croak("Math::GSL : $data is not a reference!");
2506 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
2507 croak("Math::GSL : $data is not an array ref!");
2508
2509 tempav = (AV*)SvRV(ST(1));
2510 len = av_len(tempav);
2511 arg2 = (double *) malloc((len+2)*sizeof(double));
2512 for (i = 0; i <= len; i++) {
2513 tv = av_fetch(tempav, i, 0);
2514 arg2[i] = (double) SvNV(*tv);
2515 }
2516 }
2517 ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2518 if (!SWIG_IsOK(ecode3)) {
2519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_wavelet2d_transform" "', argument " "3"" of type '" "size_t""'");
2520 }
2521 arg3 = (size_t)(val3);
2522 ecode4 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
2523 if (!SWIG_IsOK(ecode4)) {
2524 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_wavelet2d_transform" "', argument " "4"" of type '" "size_t""'");
2525 }
2526 arg4 = (size_t)(val4);
2527 ecode5 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
2528 if (!SWIG_IsOK(ecode5)) {
2529 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gsl_wavelet2d_transform" "', argument " "5"" of type '" "size_t""'");
2530 }
2531 arg5 = (size_t)(val5);
2532 {
2533 res6 = SWIG_ConvertPtr(ST(5), &argp6, SWIGTYPE_p_gsl_wavelet_direction, 0 );
2534 if (!SWIG_IsOK(res6)) {
2535 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gsl_wavelet2d_transform" "', argument " "6"" of type '" "gsl_wavelet_direction""'");
2536 }
2537 if (!argp6) {
2538 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gsl_wavelet2d_transform" "', argument " "6"" of type '" "gsl_wavelet_direction""'");
2539 } else {
2540 arg6 = *((gsl_wavelet_direction *)(argp6));
2541 }
2542 }
2543 res7 = SWIG_ConvertPtr(ST(6), &argp7,SWIGTYPE_p_gsl_wavelet_workspace, 0 | 0 );
2544 if (!SWIG_IsOK(res7)) {
2545 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "gsl_wavelet2d_transform" "', argument " "7"" of type '" "gsl_wavelet_workspace *""'");
2546 }
2547 arg7 = (gsl_wavelet_workspace *)(argp7);
2548 result = (int)gsl_wavelet2d_transform((gsl_wavelet const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
2549 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2550
2551 {
2552 if (arg2) free(arg2);
2553 }
2554
2555
2556
2557
2558 XSRETURN(argvi);
2559 fail:
2560
2561 {
2562 if (arg2) free(arg2);
2563 }
2564
2565
2566
2567
2568 SWIG_croak_null();
2569 }
2570 }
2571
2572
XS(_wrap_gsl_wavelet2d_transform_forward)2573 XS(_wrap_gsl_wavelet2d_transform_forward) {
2574 {
2575 gsl_wavelet *arg1 = (gsl_wavelet *) 0 ;
2576 double *arg2 = (double *) 0 ;
2577 size_t arg3 ;
2578 size_t arg4 ;
2579 size_t arg5 ;
2580 gsl_wavelet_workspace *arg6 = (gsl_wavelet_workspace *) 0 ;
2581 void *argp1 = 0 ;
2582 int res1 = 0 ;
2583 size_t val3 ;
2584 int ecode3 = 0 ;
2585 size_t val4 ;
2586 int ecode4 = 0 ;
2587 size_t val5 ;
2588 int ecode5 = 0 ;
2589 void *argp6 = 0 ;
2590 int res6 = 0 ;
2591 int argvi = 0;
2592 int result;
2593 dXSARGS;
2594
2595 if ((items < 6) || (items > 6)) {
2596 SWIG_croak("Usage: gsl_wavelet2d_transform_forward(w,data,tda,size1,size2,work);");
2597 }
2598 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_wavelet, 0 | 0 );
2599 if (!SWIG_IsOK(res1)) {
2600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_wavelet2d_transform_forward" "', argument " "1"" of type '" "gsl_wavelet const *""'");
2601 }
2602 arg1 = (gsl_wavelet *)(argp1);
2603 {
2604 AV *tempav;
2605 I32 len;
2606 int i;
2607 SV **tv;
2608 if (!SvROK(ST(1)))
2609 croak("Math::GSL : $data is not a reference!");
2610 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
2611 croak("Math::GSL : $data is not an array ref!");
2612
2613 tempav = (AV*)SvRV(ST(1));
2614 len = av_len(tempav);
2615 arg2 = (double *) malloc((len+2)*sizeof(double));
2616 for (i = 0; i <= len; i++) {
2617 tv = av_fetch(tempav, i, 0);
2618 arg2[i] = (double) SvNV(*tv);
2619 }
2620 }
2621 ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2622 if (!SWIG_IsOK(ecode3)) {
2623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_wavelet2d_transform_forward" "', argument " "3"" of type '" "size_t""'");
2624 }
2625 arg3 = (size_t)(val3);
2626 ecode4 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
2627 if (!SWIG_IsOK(ecode4)) {
2628 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_wavelet2d_transform_forward" "', argument " "4"" of type '" "size_t""'");
2629 }
2630 arg4 = (size_t)(val4);
2631 ecode5 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
2632 if (!SWIG_IsOK(ecode5)) {
2633 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gsl_wavelet2d_transform_forward" "', argument " "5"" of type '" "size_t""'");
2634 }
2635 arg5 = (size_t)(val5);
2636 res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_gsl_wavelet_workspace, 0 | 0 );
2637 if (!SWIG_IsOK(res6)) {
2638 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gsl_wavelet2d_transform_forward" "', argument " "6"" of type '" "gsl_wavelet_workspace *""'");
2639 }
2640 arg6 = (gsl_wavelet_workspace *)(argp6);
2641 result = (int)gsl_wavelet2d_transform_forward((gsl_wavelet const *)arg1,arg2,arg3,arg4,arg5,arg6);
2642 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2643
2644 {
2645 if (arg2) free(arg2);
2646 }
2647
2648
2649
2650
2651 XSRETURN(argvi);
2652 fail:
2653
2654 {
2655 if (arg2) free(arg2);
2656 }
2657
2658
2659
2660
2661 SWIG_croak_null();
2662 }
2663 }
2664
2665
XS(_wrap_gsl_wavelet2d_transform_inverse)2666 XS(_wrap_gsl_wavelet2d_transform_inverse) {
2667 {
2668 gsl_wavelet *arg1 = (gsl_wavelet *) 0 ;
2669 double *arg2 = (double *) 0 ;
2670 size_t arg3 ;
2671 size_t arg4 ;
2672 size_t arg5 ;
2673 gsl_wavelet_workspace *arg6 = (gsl_wavelet_workspace *) 0 ;
2674 void *argp1 = 0 ;
2675 int res1 = 0 ;
2676 size_t val3 ;
2677 int ecode3 = 0 ;
2678 size_t val4 ;
2679 int ecode4 = 0 ;
2680 size_t val5 ;
2681 int ecode5 = 0 ;
2682 void *argp6 = 0 ;
2683 int res6 = 0 ;
2684 int argvi = 0;
2685 int result;
2686 dXSARGS;
2687
2688 if ((items < 6) || (items > 6)) {
2689 SWIG_croak("Usage: gsl_wavelet2d_transform_inverse(w,data,tda,size1,size2,work);");
2690 }
2691 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_wavelet, 0 | 0 );
2692 if (!SWIG_IsOK(res1)) {
2693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_wavelet2d_transform_inverse" "', argument " "1"" of type '" "gsl_wavelet const *""'");
2694 }
2695 arg1 = (gsl_wavelet *)(argp1);
2696 {
2697 AV *tempav;
2698 I32 len;
2699 int i;
2700 SV **tv;
2701 if (!SvROK(ST(1)))
2702 croak("Math::GSL : $data is not a reference!");
2703 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
2704 croak("Math::GSL : $data is not an array ref!");
2705
2706 tempav = (AV*)SvRV(ST(1));
2707 len = av_len(tempav);
2708 arg2 = (double *) malloc((len+2)*sizeof(double));
2709 for (i = 0; i <= len; i++) {
2710 tv = av_fetch(tempav, i, 0);
2711 arg2[i] = (double) SvNV(*tv);
2712 }
2713 }
2714 ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2715 if (!SWIG_IsOK(ecode3)) {
2716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_wavelet2d_transform_inverse" "', argument " "3"" of type '" "size_t""'");
2717 }
2718 arg3 = (size_t)(val3);
2719 ecode4 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
2720 if (!SWIG_IsOK(ecode4)) {
2721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_wavelet2d_transform_inverse" "', argument " "4"" of type '" "size_t""'");
2722 }
2723 arg4 = (size_t)(val4);
2724 ecode5 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
2725 if (!SWIG_IsOK(ecode5)) {
2726 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gsl_wavelet2d_transform_inverse" "', argument " "5"" of type '" "size_t""'");
2727 }
2728 arg5 = (size_t)(val5);
2729 res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_gsl_wavelet_workspace, 0 | 0 );
2730 if (!SWIG_IsOK(res6)) {
2731 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gsl_wavelet2d_transform_inverse" "', argument " "6"" of type '" "gsl_wavelet_workspace *""'");
2732 }
2733 arg6 = (gsl_wavelet_workspace *)(argp6);
2734 result = (int)gsl_wavelet2d_transform_inverse((gsl_wavelet const *)arg1,arg2,arg3,arg4,arg5,arg6);
2735 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2736
2737 {
2738 if (arg2) free(arg2);
2739 }
2740
2741
2742
2743
2744 XSRETURN(argvi);
2745 fail:
2746
2747 {
2748 if (arg2) free(arg2);
2749 }
2750
2751
2752
2753
2754 SWIG_croak_null();
2755 }
2756 }
2757
2758
XS(_wrap_gsl_wavelet2d_nstransform)2759 XS(_wrap_gsl_wavelet2d_nstransform) {
2760 {
2761 gsl_wavelet *arg1 = (gsl_wavelet *) 0 ;
2762 double *arg2 = (double *) 0 ;
2763 size_t arg3 ;
2764 size_t arg4 ;
2765 size_t arg5 ;
2766 gsl_wavelet_direction arg6 ;
2767 gsl_wavelet_workspace *arg7 = (gsl_wavelet_workspace *) 0 ;
2768 void *argp1 = 0 ;
2769 int res1 = 0 ;
2770 size_t val3 ;
2771 int ecode3 = 0 ;
2772 size_t val4 ;
2773 int ecode4 = 0 ;
2774 size_t val5 ;
2775 int ecode5 = 0 ;
2776 void *argp6 ;
2777 int res6 = 0 ;
2778 void *argp7 = 0 ;
2779 int res7 = 0 ;
2780 int argvi = 0;
2781 int result;
2782 dXSARGS;
2783
2784 if ((items < 7) || (items > 7)) {
2785 SWIG_croak("Usage: gsl_wavelet2d_nstransform(w,data,tda,size1,size2,dir,work);");
2786 }
2787 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_wavelet, 0 | 0 );
2788 if (!SWIG_IsOK(res1)) {
2789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_wavelet2d_nstransform" "', argument " "1"" of type '" "gsl_wavelet const *""'");
2790 }
2791 arg1 = (gsl_wavelet *)(argp1);
2792 {
2793 AV *tempav;
2794 I32 len;
2795 int i;
2796 SV **tv;
2797 if (!SvROK(ST(1)))
2798 croak("Math::GSL : $data is not a reference!");
2799 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
2800 croak("Math::GSL : $data is not an array ref!");
2801
2802 tempav = (AV*)SvRV(ST(1));
2803 len = av_len(tempav);
2804 arg2 = (double *) malloc((len+2)*sizeof(double));
2805 for (i = 0; i <= len; i++) {
2806 tv = av_fetch(tempav, i, 0);
2807 arg2[i] = (double) SvNV(*tv);
2808 }
2809 }
2810 ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2811 if (!SWIG_IsOK(ecode3)) {
2812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_wavelet2d_nstransform" "', argument " "3"" of type '" "size_t""'");
2813 }
2814 arg3 = (size_t)(val3);
2815 ecode4 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
2816 if (!SWIG_IsOK(ecode4)) {
2817 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_wavelet2d_nstransform" "', argument " "4"" of type '" "size_t""'");
2818 }
2819 arg4 = (size_t)(val4);
2820 ecode5 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
2821 if (!SWIG_IsOK(ecode5)) {
2822 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gsl_wavelet2d_nstransform" "', argument " "5"" of type '" "size_t""'");
2823 }
2824 arg5 = (size_t)(val5);
2825 {
2826 res6 = SWIG_ConvertPtr(ST(5), &argp6, SWIGTYPE_p_gsl_wavelet_direction, 0 );
2827 if (!SWIG_IsOK(res6)) {
2828 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gsl_wavelet2d_nstransform" "', argument " "6"" of type '" "gsl_wavelet_direction""'");
2829 }
2830 if (!argp6) {
2831 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gsl_wavelet2d_nstransform" "', argument " "6"" of type '" "gsl_wavelet_direction""'");
2832 } else {
2833 arg6 = *((gsl_wavelet_direction *)(argp6));
2834 }
2835 }
2836 res7 = SWIG_ConvertPtr(ST(6), &argp7,SWIGTYPE_p_gsl_wavelet_workspace, 0 | 0 );
2837 if (!SWIG_IsOK(res7)) {
2838 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "gsl_wavelet2d_nstransform" "', argument " "7"" of type '" "gsl_wavelet_workspace *""'");
2839 }
2840 arg7 = (gsl_wavelet_workspace *)(argp7);
2841 result = (int)gsl_wavelet2d_nstransform((gsl_wavelet const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
2842 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2843
2844 {
2845 if (arg2) free(arg2);
2846 }
2847
2848
2849
2850
2851 XSRETURN(argvi);
2852 fail:
2853
2854 {
2855 if (arg2) free(arg2);
2856 }
2857
2858
2859
2860
2861 SWIG_croak_null();
2862 }
2863 }
2864
2865
XS(_wrap_gsl_wavelet2d_nstransform_forward)2866 XS(_wrap_gsl_wavelet2d_nstransform_forward) {
2867 {
2868 gsl_wavelet *arg1 = (gsl_wavelet *) 0 ;
2869 double *arg2 = (double *) 0 ;
2870 size_t arg3 ;
2871 size_t arg4 ;
2872 size_t arg5 ;
2873 gsl_wavelet_workspace *arg6 = (gsl_wavelet_workspace *) 0 ;
2874 void *argp1 = 0 ;
2875 int res1 = 0 ;
2876 size_t val3 ;
2877 int ecode3 = 0 ;
2878 size_t val4 ;
2879 int ecode4 = 0 ;
2880 size_t val5 ;
2881 int ecode5 = 0 ;
2882 void *argp6 = 0 ;
2883 int res6 = 0 ;
2884 int argvi = 0;
2885 int result;
2886 dXSARGS;
2887
2888 if ((items < 6) || (items > 6)) {
2889 SWIG_croak("Usage: gsl_wavelet2d_nstransform_forward(w,data,tda,size1,size2,work);");
2890 }
2891 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_wavelet, 0 | 0 );
2892 if (!SWIG_IsOK(res1)) {
2893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_wavelet2d_nstransform_forward" "', argument " "1"" of type '" "gsl_wavelet const *""'");
2894 }
2895 arg1 = (gsl_wavelet *)(argp1);
2896 {
2897 AV *tempav;
2898 I32 len;
2899 int i;
2900 SV **tv;
2901 if (!SvROK(ST(1)))
2902 croak("Math::GSL : $data is not a reference!");
2903 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
2904 croak("Math::GSL : $data is not an array ref!");
2905
2906 tempav = (AV*)SvRV(ST(1));
2907 len = av_len(tempav);
2908 arg2 = (double *) malloc((len+2)*sizeof(double));
2909 for (i = 0; i <= len; i++) {
2910 tv = av_fetch(tempav, i, 0);
2911 arg2[i] = (double) SvNV(*tv);
2912 }
2913 }
2914 ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2915 if (!SWIG_IsOK(ecode3)) {
2916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_wavelet2d_nstransform_forward" "', argument " "3"" of type '" "size_t""'");
2917 }
2918 arg3 = (size_t)(val3);
2919 ecode4 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
2920 if (!SWIG_IsOK(ecode4)) {
2921 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_wavelet2d_nstransform_forward" "', argument " "4"" of type '" "size_t""'");
2922 }
2923 arg4 = (size_t)(val4);
2924 ecode5 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
2925 if (!SWIG_IsOK(ecode5)) {
2926 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gsl_wavelet2d_nstransform_forward" "', argument " "5"" of type '" "size_t""'");
2927 }
2928 arg5 = (size_t)(val5);
2929 res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_gsl_wavelet_workspace, 0 | 0 );
2930 if (!SWIG_IsOK(res6)) {
2931 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gsl_wavelet2d_nstransform_forward" "', argument " "6"" of type '" "gsl_wavelet_workspace *""'");
2932 }
2933 arg6 = (gsl_wavelet_workspace *)(argp6);
2934 result = (int)gsl_wavelet2d_nstransform_forward((gsl_wavelet const *)arg1,arg2,arg3,arg4,arg5,arg6);
2935 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2936
2937 {
2938 if (arg2) free(arg2);
2939 }
2940
2941
2942
2943
2944 XSRETURN(argvi);
2945 fail:
2946
2947 {
2948 if (arg2) free(arg2);
2949 }
2950
2951
2952
2953
2954 SWIG_croak_null();
2955 }
2956 }
2957
2958
XS(_wrap_gsl_wavelet2d_nstransform_inverse)2959 XS(_wrap_gsl_wavelet2d_nstransform_inverse) {
2960 {
2961 gsl_wavelet *arg1 = (gsl_wavelet *) 0 ;
2962 double *arg2 = (double *) 0 ;
2963 size_t arg3 ;
2964 size_t arg4 ;
2965 size_t arg5 ;
2966 gsl_wavelet_workspace *arg6 = (gsl_wavelet_workspace *) 0 ;
2967 void *argp1 = 0 ;
2968 int res1 = 0 ;
2969 size_t val3 ;
2970 int ecode3 = 0 ;
2971 size_t val4 ;
2972 int ecode4 = 0 ;
2973 size_t val5 ;
2974 int ecode5 = 0 ;
2975 void *argp6 = 0 ;
2976 int res6 = 0 ;
2977 int argvi = 0;
2978 int result;
2979 dXSARGS;
2980
2981 if ((items < 6) || (items > 6)) {
2982 SWIG_croak("Usage: gsl_wavelet2d_nstransform_inverse(w,data,tda,size1,size2,work);");
2983 }
2984 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_wavelet, 0 | 0 );
2985 if (!SWIG_IsOK(res1)) {
2986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_wavelet2d_nstransform_inverse" "', argument " "1"" of type '" "gsl_wavelet const *""'");
2987 }
2988 arg1 = (gsl_wavelet *)(argp1);
2989 {
2990 AV *tempav;
2991 I32 len;
2992 int i;
2993 SV **tv;
2994 if (!SvROK(ST(1)))
2995 croak("Math::GSL : $data is not a reference!");
2996 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
2997 croak("Math::GSL : $data is not an array ref!");
2998
2999 tempav = (AV*)SvRV(ST(1));
3000 len = av_len(tempav);
3001 arg2 = (double *) malloc((len+2)*sizeof(double));
3002 for (i = 0; i <= len; i++) {
3003 tv = av_fetch(tempav, i, 0);
3004 arg2[i] = (double) SvNV(*tv);
3005 }
3006 }
3007 ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
3008 if (!SWIG_IsOK(ecode3)) {
3009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_wavelet2d_nstransform_inverse" "', argument " "3"" of type '" "size_t""'");
3010 }
3011 arg3 = (size_t)(val3);
3012 ecode4 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
3013 if (!SWIG_IsOK(ecode4)) {
3014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_wavelet2d_nstransform_inverse" "', argument " "4"" of type '" "size_t""'");
3015 }
3016 arg4 = (size_t)(val4);
3017 ecode5 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
3018 if (!SWIG_IsOK(ecode5)) {
3019 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gsl_wavelet2d_nstransform_inverse" "', argument " "5"" of type '" "size_t""'");
3020 }
3021 arg5 = (size_t)(val5);
3022 res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_gsl_wavelet_workspace, 0 | 0 );
3023 if (!SWIG_IsOK(res6)) {
3024 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gsl_wavelet2d_nstransform_inverse" "', argument " "6"" of type '" "gsl_wavelet_workspace *""'");
3025 }
3026 arg6 = (gsl_wavelet_workspace *)(argp6);
3027 result = (int)gsl_wavelet2d_nstransform_inverse((gsl_wavelet const *)arg1,arg2,arg3,arg4,arg5,arg6);
3028 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3029
3030 {
3031 if (arg2) free(arg2);
3032 }
3033
3034
3035
3036
3037 XSRETURN(argvi);
3038 fail:
3039
3040 {
3041 if (arg2) free(arg2);
3042 }
3043
3044
3045
3046
3047 SWIG_croak_null();
3048 }
3049 }
3050
3051
XS(_wrap_gsl_wavelet2d_transform_matrix)3052 XS(_wrap_gsl_wavelet2d_transform_matrix) {
3053 {
3054 gsl_wavelet *arg1 = (gsl_wavelet *) 0 ;
3055 gsl_matrix *arg2 = (gsl_matrix *) 0 ;
3056 gsl_wavelet_direction arg3 ;
3057 gsl_wavelet_workspace *arg4 = (gsl_wavelet_workspace *) 0 ;
3058 void *argp1 = 0 ;
3059 int res1 = 0 ;
3060 void *argp2 = 0 ;
3061 int res2 = 0 ;
3062 void *argp3 ;
3063 int res3 = 0 ;
3064 void *argp4 = 0 ;
3065 int res4 = 0 ;
3066 int argvi = 0;
3067 int result;
3068 dXSARGS;
3069
3070 if ((items < 4) || (items > 4)) {
3071 SWIG_croak("Usage: gsl_wavelet2d_transform_matrix(w,a,dir,work);");
3072 }
3073 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_wavelet, 0 | 0 );
3074 if (!SWIG_IsOK(res1)) {
3075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_wavelet2d_transform_matrix" "', argument " "1"" of type '" "gsl_wavelet const *""'");
3076 }
3077 arg1 = (gsl_wavelet *)(argp1);
3078 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_gsl_matrix, 0 | 0 );
3079 if (!SWIG_IsOK(res2)) {
3080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_wavelet2d_transform_matrix" "', argument " "2"" of type '" "gsl_matrix *""'");
3081 }
3082 arg2 = (gsl_matrix *)(argp2);
3083 {
3084 res3 = SWIG_ConvertPtr(ST(2), &argp3, SWIGTYPE_p_gsl_wavelet_direction, 0 );
3085 if (!SWIG_IsOK(res3)) {
3086 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gsl_wavelet2d_transform_matrix" "', argument " "3"" of type '" "gsl_wavelet_direction""'");
3087 }
3088 if (!argp3) {
3089 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gsl_wavelet2d_transform_matrix" "', argument " "3"" of type '" "gsl_wavelet_direction""'");
3090 } else {
3091 arg3 = *((gsl_wavelet_direction *)(argp3));
3092 }
3093 }
3094 res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_gsl_wavelet_workspace, 0 | 0 );
3095 if (!SWIG_IsOK(res4)) {
3096 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gsl_wavelet2d_transform_matrix" "', argument " "4"" of type '" "gsl_wavelet_workspace *""'");
3097 }
3098 arg4 = (gsl_wavelet_workspace *)(argp4);
3099 result = (int)gsl_wavelet2d_transform_matrix((gsl_wavelet const *)arg1,arg2,arg3,arg4);
3100 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3101
3102
3103
3104 XSRETURN(argvi);
3105 fail:
3106
3107
3108
3109 SWIG_croak_null();
3110 }
3111 }
3112
3113
XS(_wrap_gsl_wavelet2d_transform_matrix_forward)3114 XS(_wrap_gsl_wavelet2d_transform_matrix_forward) {
3115 {
3116 gsl_wavelet *arg1 = (gsl_wavelet *) 0 ;
3117 gsl_matrix *arg2 = (gsl_matrix *) 0 ;
3118 gsl_wavelet_workspace *arg3 = (gsl_wavelet_workspace *) 0 ;
3119 void *argp1 = 0 ;
3120 int res1 = 0 ;
3121 void *argp2 = 0 ;
3122 int res2 = 0 ;
3123 void *argp3 = 0 ;
3124 int res3 = 0 ;
3125 int argvi = 0;
3126 int result;
3127 dXSARGS;
3128
3129 if ((items < 3) || (items > 3)) {
3130 SWIG_croak("Usage: gsl_wavelet2d_transform_matrix_forward(w,a,work);");
3131 }
3132 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_wavelet, 0 | 0 );
3133 if (!SWIG_IsOK(res1)) {
3134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_wavelet2d_transform_matrix_forward" "', argument " "1"" of type '" "gsl_wavelet const *""'");
3135 }
3136 arg1 = (gsl_wavelet *)(argp1);
3137 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_gsl_matrix, 0 | 0 );
3138 if (!SWIG_IsOK(res2)) {
3139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_wavelet2d_transform_matrix_forward" "', argument " "2"" of type '" "gsl_matrix *""'");
3140 }
3141 arg2 = (gsl_matrix *)(argp2);
3142 res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_gsl_wavelet_workspace, 0 | 0 );
3143 if (!SWIG_IsOK(res3)) {
3144 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gsl_wavelet2d_transform_matrix_forward" "', argument " "3"" of type '" "gsl_wavelet_workspace *""'");
3145 }
3146 arg3 = (gsl_wavelet_workspace *)(argp3);
3147 result = (int)gsl_wavelet2d_transform_matrix_forward((gsl_wavelet const *)arg1,arg2,arg3);
3148 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3149
3150
3151
3152 XSRETURN(argvi);
3153 fail:
3154
3155
3156
3157 SWIG_croak_null();
3158 }
3159 }
3160
3161
XS(_wrap_gsl_wavelet2d_transform_matrix_inverse)3162 XS(_wrap_gsl_wavelet2d_transform_matrix_inverse) {
3163 {
3164 gsl_wavelet *arg1 = (gsl_wavelet *) 0 ;
3165 gsl_matrix *arg2 = (gsl_matrix *) 0 ;
3166 gsl_wavelet_workspace *arg3 = (gsl_wavelet_workspace *) 0 ;
3167 void *argp1 = 0 ;
3168 int res1 = 0 ;
3169 void *argp2 = 0 ;
3170 int res2 = 0 ;
3171 void *argp3 = 0 ;
3172 int res3 = 0 ;
3173 int argvi = 0;
3174 int result;
3175 dXSARGS;
3176
3177 if ((items < 3) || (items > 3)) {
3178 SWIG_croak("Usage: gsl_wavelet2d_transform_matrix_inverse(w,a,work);");
3179 }
3180 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_wavelet, 0 | 0 );
3181 if (!SWIG_IsOK(res1)) {
3182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_wavelet2d_transform_matrix_inverse" "', argument " "1"" of type '" "gsl_wavelet const *""'");
3183 }
3184 arg1 = (gsl_wavelet *)(argp1);
3185 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_gsl_matrix, 0 | 0 );
3186 if (!SWIG_IsOK(res2)) {
3187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_wavelet2d_transform_matrix_inverse" "', argument " "2"" of type '" "gsl_matrix *""'");
3188 }
3189 arg2 = (gsl_matrix *)(argp2);
3190 res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_gsl_wavelet_workspace, 0 | 0 );
3191 if (!SWIG_IsOK(res3)) {
3192 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gsl_wavelet2d_transform_matrix_inverse" "', argument " "3"" of type '" "gsl_wavelet_workspace *""'");
3193 }
3194 arg3 = (gsl_wavelet_workspace *)(argp3);
3195 result = (int)gsl_wavelet2d_transform_matrix_inverse((gsl_wavelet const *)arg1,arg2,arg3);
3196 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3197
3198
3199
3200 XSRETURN(argvi);
3201 fail:
3202
3203
3204
3205 SWIG_croak_null();
3206 }
3207 }
3208
3209
XS(_wrap_gsl_wavelet2d_nstransform_matrix)3210 XS(_wrap_gsl_wavelet2d_nstransform_matrix) {
3211 {
3212 gsl_wavelet *arg1 = (gsl_wavelet *) 0 ;
3213 gsl_matrix *arg2 = (gsl_matrix *) 0 ;
3214 gsl_wavelet_direction arg3 ;
3215 gsl_wavelet_workspace *arg4 = (gsl_wavelet_workspace *) 0 ;
3216 void *argp1 = 0 ;
3217 int res1 = 0 ;
3218 void *argp2 = 0 ;
3219 int res2 = 0 ;
3220 void *argp3 ;
3221 int res3 = 0 ;
3222 void *argp4 = 0 ;
3223 int res4 = 0 ;
3224 int argvi = 0;
3225 int result;
3226 dXSARGS;
3227
3228 if ((items < 4) || (items > 4)) {
3229 SWIG_croak("Usage: gsl_wavelet2d_nstransform_matrix(w,a,dir,work);");
3230 }
3231 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_wavelet, 0 | 0 );
3232 if (!SWIG_IsOK(res1)) {
3233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_wavelet2d_nstransform_matrix" "', argument " "1"" of type '" "gsl_wavelet const *""'");
3234 }
3235 arg1 = (gsl_wavelet *)(argp1);
3236 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_gsl_matrix, 0 | 0 );
3237 if (!SWIG_IsOK(res2)) {
3238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_wavelet2d_nstransform_matrix" "', argument " "2"" of type '" "gsl_matrix *""'");
3239 }
3240 arg2 = (gsl_matrix *)(argp2);
3241 {
3242 res3 = SWIG_ConvertPtr(ST(2), &argp3, SWIGTYPE_p_gsl_wavelet_direction, 0 );
3243 if (!SWIG_IsOK(res3)) {
3244 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gsl_wavelet2d_nstransform_matrix" "', argument " "3"" of type '" "gsl_wavelet_direction""'");
3245 }
3246 if (!argp3) {
3247 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gsl_wavelet2d_nstransform_matrix" "', argument " "3"" of type '" "gsl_wavelet_direction""'");
3248 } else {
3249 arg3 = *((gsl_wavelet_direction *)(argp3));
3250 }
3251 }
3252 res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_gsl_wavelet_workspace, 0 | 0 );
3253 if (!SWIG_IsOK(res4)) {
3254 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gsl_wavelet2d_nstransform_matrix" "', argument " "4"" of type '" "gsl_wavelet_workspace *""'");
3255 }
3256 arg4 = (gsl_wavelet_workspace *)(argp4);
3257 result = (int)gsl_wavelet2d_nstransform_matrix((gsl_wavelet const *)arg1,arg2,arg3,arg4);
3258 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3259
3260
3261
3262 XSRETURN(argvi);
3263 fail:
3264
3265
3266
3267 SWIG_croak_null();
3268 }
3269 }
3270
3271
XS(_wrap_gsl_wavelet2d_nstransform_matrix_forward)3272 XS(_wrap_gsl_wavelet2d_nstransform_matrix_forward) {
3273 {
3274 gsl_wavelet *arg1 = (gsl_wavelet *) 0 ;
3275 gsl_matrix *arg2 = (gsl_matrix *) 0 ;
3276 gsl_wavelet_workspace *arg3 = (gsl_wavelet_workspace *) 0 ;
3277 void *argp1 = 0 ;
3278 int res1 = 0 ;
3279 void *argp2 = 0 ;
3280 int res2 = 0 ;
3281 void *argp3 = 0 ;
3282 int res3 = 0 ;
3283 int argvi = 0;
3284 int result;
3285 dXSARGS;
3286
3287 if ((items < 3) || (items > 3)) {
3288 SWIG_croak("Usage: gsl_wavelet2d_nstransform_matrix_forward(w,a,work);");
3289 }
3290 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_wavelet, 0 | 0 );
3291 if (!SWIG_IsOK(res1)) {
3292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_wavelet2d_nstransform_matrix_forward" "', argument " "1"" of type '" "gsl_wavelet const *""'");
3293 }
3294 arg1 = (gsl_wavelet *)(argp1);
3295 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_gsl_matrix, 0 | 0 );
3296 if (!SWIG_IsOK(res2)) {
3297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_wavelet2d_nstransform_matrix_forward" "', argument " "2"" of type '" "gsl_matrix *""'");
3298 }
3299 arg2 = (gsl_matrix *)(argp2);
3300 res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_gsl_wavelet_workspace, 0 | 0 );
3301 if (!SWIG_IsOK(res3)) {
3302 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gsl_wavelet2d_nstransform_matrix_forward" "', argument " "3"" of type '" "gsl_wavelet_workspace *""'");
3303 }
3304 arg3 = (gsl_wavelet_workspace *)(argp3);
3305 result = (int)gsl_wavelet2d_nstransform_matrix_forward((gsl_wavelet const *)arg1,arg2,arg3);
3306 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3307
3308
3309
3310 XSRETURN(argvi);
3311 fail:
3312
3313
3314
3315 SWIG_croak_null();
3316 }
3317 }
3318
3319
XS(_wrap_gsl_wavelet2d_nstransform_matrix_inverse)3320 XS(_wrap_gsl_wavelet2d_nstransform_matrix_inverse) {
3321 {
3322 gsl_wavelet *arg1 = (gsl_wavelet *) 0 ;
3323 gsl_matrix *arg2 = (gsl_matrix *) 0 ;
3324 gsl_wavelet_workspace *arg3 = (gsl_wavelet_workspace *) 0 ;
3325 void *argp1 = 0 ;
3326 int res1 = 0 ;
3327 void *argp2 = 0 ;
3328 int res2 = 0 ;
3329 void *argp3 = 0 ;
3330 int res3 = 0 ;
3331 int argvi = 0;
3332 int result;
3333 dXSARGS;
3334
3335 if ((items < 3) || (items > 3)) {
3336 SWIG_croak("Usage: gsl_wavelet2d_nstransform_matrix_inverse(w,a,work);");
3337 }
3338 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_wavelet, 0 | 0 );
3339 if (!SWIG_IsOK(res1)) {
3340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_wavelet2d_nstransform_matrix_inverse" "', argument " "1"" of type '" "gsl_wavelet const *""'");
3341 }
3342 arg1 = (gsl_wavelet *)(argp1);
3343 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_gsl_matrix, 0 | 0 );
3344 if (!SWIG_IsOK(res2)) {
3345 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_wavelet2d_nstransform_matrix_inverse" "', argument " "2"" of type '" "gsl_matrix *""'");
3346 }
3347 arg2 = (gsl_matrix *)(argp2);
3348 res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_gsl_wavelet_workspace, 0 | 0 );
3349 if (!SWIG_IsOK(res3)) {
3350 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gsl_wavelet2d_nstransform_matrix_inverse" "', argument " "3"" of type '" "gsl_wavelet_workspace *""'");
3351 }
3352 arg3 = (gsl_wavelet_workspace *)(argp3);
3353 result = (int)gsl_wavelet2d_nstransform_matrix_inverse((gsl_wavelet const *)arg1,arg2,arg3);
3354 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3355
3356
3357
3358 XSRETURN(argvi);
3359 fail:
3360
3361
3362
3363 SWIG_croak_null();
3364 }
3365 }
3366
3367
3368
3369 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
3370
3371 static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
3372 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
3373 static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
3374 static swig_type_info _swigt__p_f_p_q_const__char_p_q_const__char_int_int__void = {"_p_f_p_q_const__char_p_q_const__char_int_int__void", "void (*)(char const *,char const *,int,int)|gsl_error_handler_t *", 0, 0, (void*)0, 0};
3375 static swig_type_info _swigt__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void = {"_p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void", "gsl_stream_handler_t *|void (*)(char const *,char const *,int,char const *)", 0, 0, (void*)0, 0};
3376 static swig_type_info _swigt__p_gsl_matrix = {"_p_gsl_matrix", "gsl_matrix *", 0, 0, (void*)0, 0};
3377 static swig_type_info _swigt__p_gsl_wavelet = {"_p_gsl_wavelet", "gsl_wavelet *", 0, 0, (void*)0, 0};
3378 static swig_type_info _swigt__p_gsl_wavelet_direction = {"_p_gsl_wavelet_direction", "gsl_wavelet_direction *", 0, 0, (void*)0, 0};
3379 static swig_type_info _swigt__p_gsl_wavelet_workspace = {"_p_gsl_wavelet_workspace", "gsl_wavelet_workspace *", 0, 0, (void*)0, 0};
3380
3381 static swig_type_info *swig_type_initial[] = {
3382 &_swigt__p_FILE,
3383 &_swigt__p_char,
3384 &_swigt__p_double,
3385 &_swigt__p_f_p_q_const__char_p_q_const__char_int_int__void,
3386 &_swigt__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void,
3387 &_swigt__p_gsl_matrix,
3388 &_swigt__p_gsl_wavelet,
3389 &_swigt__p_gsl_wavelet_direction,
3390 &_swigt__p_gsl_wavelet_workspace,
3391 };
3392
3393 static swig_cast_info _swigc__p_FILE[] = { {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
3394 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
3395 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
3396 static swig_cast_info _swigc__p_f_p_q_const__char_p_q_const__char_int_int__void[] = { {&_swigt__p_f_p_q_const__char_p_q_const__char_int_int__void, 0, 0, 0},{0, 0, 0, 0}};
3397 static swig_cast_info _swigc__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void[] = { {&_swigt__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void, 0, 0, 0},{0, 0, 0, 0}};
3398 static swig_cast_info _swigc__p_gsl_matrix[] = { {&_swigt__p_gsl_matrix, 0, 0, 0},{0, 0, 0, 0}};
3399 static swig_cast_info _swigc__p_gsl_wavelet[] = { {&_swigt__p_gsl_wavelet, 0, 0, 0},{0, 0, 0, 0}};
3400 static swig_cast_info _swigc__p_gsl_wavelet_direction[] = { {&_swigt__p_gsl_wavelet_direction, 0, 0, 0},{0, 0, 0, 0}};
3401 static swig_cast_info _swigc__p_gsl_wavelet_workspace[] = { {&_swigt__p_gsl_wavelet_workspace, 0, 0, 0},{0, 0, 0, 0}};
3402
3403 static swig_cast_info *swig_cast_initial[] = {
3404 _swigc__p_FILE,
3405 _swigc__p_char,
3406 _swigc__p_double,
3407 _swigc__p_f_p_q_const__char_p_q_const__char_int_int__void,
3408 _swigc__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void,
3409 _swigc__p_gsl_matrix,
3410 _swigc__p_gsl_wavelet,
3411 _swigc__p_gsl_wavelet_direction,
3412 _swigc__p_gsl_wavelet_workspace,
3413 };
3414
3415
3416 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
3417
3418 static swig_constant_info swig_constants[] = {
3419 {0,0,0,0,0,0}
3420 };
3421 #ifdef __cplusplus
3422 }
3423 #endif
3424 static swig_variable_info swig_variables[] = {
3425 {0,0,0,0}
3426 };
3427 static swig_command_info swig_commands[] = {
3428 {"Math::GSL::Wavelet2Dc::gsl_error", _wrap_gsl_error},
3429 {"Math::GSL::Wavelet2Dc::gsl_stream_printf", _wrap_gsl_stream_printf},
3430 {"Math::GSL::Wavelet2Dc::gsl_strerror", _wrap_gsl_strerror},
3431 {"Math::GSL::Wavelet2Dc::gsl_set_error_handler", _wrap_gsl_set_error_handler},
3432 {"Math::GSL::Wavelet2Dc::gsl_set_error_handler_off", _wrap_gsl_set_error_handler_off},
3433 {"Math::GSL::Wavelet2Dc::gsl_set_stream_handler", _wrap_gsl_set_stream_handler},
3434 {"Math::GSL::Wavelet2Dc::gsl_set_stream", _wrap_gsl_set_stream},
3435 {"Math::GSL::Wavelet2Dc::gsl_wavelet2d_transform", _wrap_gsl_wavelet2d_transform},
3436 {"Math::GSL::Wavelet2Dc::gsl_wavelet2d_transform_forward", _wrap_gsl_wavelet2d_transform_forward},
3437 {"Math::GSL::Wavelet2Dc::gsl_wavelet2d_transform_inverse", _wrap_gsl_wavelet2d_transform_inverse},
3438 {"Math::GSL::Wavelet2Dc::gsl_wavelet2d_nstransform", _wrap_gsl_wavelet2d_nstransform},
3439 {"Math::GSL::Wavelet2Dc::gsl_wavelet2d_nstransform_forward", _wrap_gsl_wavelet2d_nstransform_forward},
3440 {"Math::GSL::Wavelet2Dc::gsl_wavelet2d_nstransform_inverse", _wrap_gsl_wavelet2d_nstransform_inverse},
3441 {"Math::GSL::Wavelet2Dc::gsl_wavelet2d_transform_matrix", _wrap_gsl_wavelet2d_transform_matrix},
3442 {"Math::GSL::Wavelet2Dc::gsl_wavelet2d_transform_matrix_forward", _wrap_gsl_wavelet2d_transform_matrix_forward},
3443 {"Math::GSL::Wavelet2Dc::gsl_wavelet2d_transform_matrix_inverse", _wrap_gsl_wavelet2d_transform_matrix_inverse},
3444 {"Math::GSL::Wavelet2Dc::gsl_wavelet2d_nstransform_matrix", _wrap_gsl_wavelet2d_nstransform_matrix},
3445 {"Math::GSL::Wavelet2Dc::gsl_wavelet2d_nstransform_matrix_forward", _wrap_gsl_wavelet2d_nstransform_matrix_forward},
3446 {"Math::GSL::Wavelet2Dc::gsl_wavelet2d_nstransform_matrix_inverse", _wrap_gsl_wavelet2d_nstransform_matrix_inverse},
3447 {0,0}
3448 };
3449 /* -----------------------------------------------------------------------------
3450 * Type initialization:
3451 * This problem is tough by the requirement that no dynamic
3452 * memory is used. Also, since swig_type_info structures store pointers to
3453 * swig_cast_info structures and swig_cast_info structures store pointers back
3454 * to swig_type_info structures, we need some lookup code at initialization.
3455 * The idea is that swig generates all the structures that are needed.
3456 * The runtime then collects these partially filled structures.
3457 * The SWIG_InitializeModule function takes these initial arrays out of
3458 * swig_module, and does all the lookup, filling in the swig_module.types
3459 * array with the correct data and linking the correct swig_cast_info
3460 * structures together.
3461 *
3462 * The generated swig_type_info structures are assigned statically to an initial
3463 * array. We just loop through that array, and handle each type individually.
3464 * First we lookup if this type has been already loaded, and if so, use the
3465 * loaded structure instead of the generated one. Then we have to fill in the
3466 * cast linked list. The cast data is initially stored in something like a
3467 * two-dimensional array. Each row corresponds to a type (there are the same
3468 * number of rows as there are in the swig_type_initial array). Each entry in
3469 * a column is one of the swig_cast_info structures for that type.
3470 * The cast_initial array is actually an array of arrays, because each row has
3471 * a variable number of columns. So to actually build the cast linked list,
3472 * we find the array of casts associated with the type, and loop through it
3473 * adding the casts to the list. The one last trick we need to do is making
3474 * sure the type pointer in the swig_cast_info struct is correct.
3475 *
3476 * First off, we lookup the cast->type name to see if it is already loaded.
3477 * There are three cases to handle:
3478 * 1) If the cast->type has already been loaded AND the type we are adding
3479 * casting info to has not been loaded (it is in this module), THEN we
3480 * replace the cast->type pointer with the type pointer that has already
3481 * been loaded.
3482 * 2) If BOTH types (the one we are adding casting info to, and the
3483 * cast->type) are loaded, THEN the cast info has already been loaded by
3484 * the previous module so we just ignore it.
3485 * 3) Finally, if cast->type has not already been loaded, then we add that
3486 * swig_cast_info to the linked list (because the cast->type) pointer will
3487 * be correct.
3488 * ----------------------------------------------------------------------------- */
3489
3490 #ifdef __cplusplus
3491 extern "C" {
3492 #if 0
3493 } /* c-mode */
3494 #endif
3495 #endif
3496
3497 #if 0
3498 #define SWIGRUNTIME_DEBUG
3499 #endif
3500
3501
3502 SWIGRUNTIME void
SWIG_InitializeModule(void * clientdata)3503 SWIG_InitializeModule(void *clientdata) {
3504 size_t i;
3505 swig_module_info *module_head, *iter;
3506 int init;
3507
3508 /* check to see if the circular list has been setup, if not, set it up */
3509 if (swig_module.next==0) {
3510 /* Initialize the swig_module */
3511 swig_module.type_initial = swig_type_initial;
3512 swig_module.cast_initial = swig_cast_initial;
3513 swig_module.next = &swig_module;
3514 init = 1;
3515 } else {
3516 init = 0;
3517 }
3518
3519 /* Try and load any already created modules */
3520 module_head = SWIG_GetModule(clientdata);
3521 if (!module_head) {
3522 /* This is the first module loaded for this interpreter */
3523 /* so set the swig module into the interpreter */
3524 SWIG_SetModule(clientdata, &swig_module);
3525 } else {
3526 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
3527 iter=module_head;
3528 do {
3529 if (iter==&swig_module) {
3530 /* Our module is already in the list, so there's nothing more to do. */
3531 return;
3532 }
3533 iter=iter->next;
3534 } while (iter!= module_head);
3535
3536 /* otherwise we must add our module into the list */
3537 swig_module.next = module_head->next;
3538 module_head->next = &swig_module;
3539 }
3540
3541 /* When multiple interpreters are used, a module could have already been initialized in
3542 a different interpreter, but not yet have a pointer in this interpreter.
3543 In this case, we do not want to continue adding types... everything should be
3544 set up already */
3545 if (init == 0) return;
3546
3547 /* Now work on filling in swig_module.types */
3548 #ifdef SWIGRUNTIME_DEBUG
3549 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
3550 #endif
3551 for (i = 0; i < swig_module.size; ++i) {
3552 swig_type_info *type = 0;
3553 swig_type_info *ret;
3554 swig_cast_info *cast;
3555
3556 #ifdef SWIGRUNTIME_DEBUG
3557 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
3558 #endif
3559
3560 /* if there is another module already loaded */
3561 if (swig_module.next != &swig_module) {
3562 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
3563 }
3564 if (type) {
3565 /* Overwrite clientdata field */
3566 #ifdef SWIGRUNTIME_DEBUG
3567 printf("SWIG_InitializeModule: found type %s\n", type->name);
3568 #endif
3569 if (swig_module.type_initial[i]->clientdata) {
3570 type->clientdata = swig_module.type_initial[i]->clientdata;
3571 #ifdef SWIGRUNTIME_DEBUG
3572 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
3573 #endif
3574 }
3575 } else {
3576 type = swig_module.type_initial[i];
3577 }
3578
3579 /* Insert casting types */
3580 cast = swig_module.cast_initial[i];
3581 while (cast->type) {
3582 /* Don't need to add information already in the list */
3583 ret = 0;
3584 #ifdef SWIGRUNTIME_DEBUG
3585 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
3586 #endif
3587 if (swig_module.next != &swig_module) {
3588 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
3589 #ifdef SWIGRUNTIME_DEBUG
3590 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
3591 #endif
3592 }
3593 if (ret) {
3594 if (type == swig_module.type_initial[i]) {
3595 #ifdef SWIGRUNTIME_DEBUG
3596 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
3597 #endif
3598 cast->type = ret;
3599 ret = 0;
3600 } else {
3601 /* Check for casting already in the list */
3602 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
3603 #ifdef SWIGRUNTIME_DEBUG
3604 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
3605 #endif
3606 if (!ocast) ret = 0;
3607 }
3608 }
3609
3610 if (!ret) {
3611 #ifdef SWIGRUNTIME_DEBUG
3612 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
3613 #endif
3614 if (type->cast) {
3615 type->cast->prev = cast;
3616 cast->next = type->cast;
3617 }
3618 type->cast = cast;
3619 }
3620 cast++;
3621 }
3622 /* Set entry in modules->types array equal to the type */
3623 swig_module.types[i] = type;
3624 }
3625 swig_module.types[i] = 0;
3626
3627 #ifdef SWIGRUNTIME_DEBUG
3628 printf("**** SWIG_InitializeModule: Cast List ******\n");
3629 for (i = 0; i < swig_module.size; ++i) {
3630 int j = 0;
3631 swig_cast_info *cast = swig_module.cast_initial[i];
3632 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
3633 while (cast->type) {
3634 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
3635 cast++;
3636 ++j;
3637 }
3638 printf("---- Total casts: %d\n",j);
3639 }
3640 printf("**** SWIG_InitializeModule: Cast List ******\n");
3641 #endif
3642 }
3643
3644 /* This function will propagate the clientdata field of type to
3645 * any new swig_type_info structures that have been added into the list
3646 * of equivalent types. It is like calling
3647 * SWIG_TypeClientData(type, clientdata) a second time.
3648 */
3649 SWIGRUNTIME void
SWIG_PropagateClientData(void)3650 SWIG_PropagateClientData(void) {
3651 size_t i;
3652 swig_cast_info *equiv;
3653 static int init_run = 0;
3654
3655 if (init_run) return;
3656 init_run = 1;
3657
3658 for (i = 0; i < swig_module.size; i++) {
3659 if (swig_module.types[i]->clientdata) {
3660 equiv = swig_module.types[i]->cast;
3661 while (equiv) {
3662 if (!equiv->converter) {
3663 if (equiv->type && !equiv->type->clientdata)
3664 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
3665 }
3666 equiv = equiv->next;
3667 }
3668 }
3669 }
3670 }
3671
3672 #ifdef __cplusplus
3673 #if 0
3674 {
3675 /* c-mode */
3676 #endif
3677 }
3678 #endif
3679
3680
3681
3682 #if defined(__cplusplus) && ! defined(XSPROTO)
3683 extern "C"
3684 #endif
3685
XS(SWIG_init)3686 XS(SWIG_init) {
3687 dXSARGS;
3688 int i;
3689 (void)items;
3690
3691 SWIG_InitializeModule(0);
3692
3693 /* Install commands */
3694 for (i = 0; swig_commands[i].name; i++) {
3695 /* Casts only needed for Perl < 5.10. */
3696 #ifdef __cplusplus
3697 newXS(const_cast<char*>(swig_commands[i].name), swig_commands[i].wrapper, const_cast<char*>(__FILE__));
3698 #else
3699 newXS((char*)swig_commands[i].name, swig_commands[i].wrapper, (char*)__FILE__);
3700 #endif
3701 }
3702
3703 /* Install variables */
3704 for (i = 0; swig_variables[i].name; i++) {
3705 SV *sv;
3706 sv = get_sv(swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
3707 if (swig_variables[i].type) {
3708 SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
3709 } else {
3710 sv_setiv(sv,(IV) 0);
3711 }
3712 swig_create_magic(sv, swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
3713 }
3714
3715 /* Install constant */
3716 for (i = 0; swig_constants[i].type; i++) {
3717 SV *sv;
3718 sv = get_sv(swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
3719 switch(swig_constants[i].type) {
3720 case SWIG_INT:
3721 sv_setiv(sv, (IV) swig_constants[i].lvalue);
3722 break;
3723 case SWIG_FLOAT:
3724 sv_setnv(sv, (double) swig_constants[i].dvalue);
3725 break;
3726 case SWIG_STRING:
3727 sv_setpv(sv, (const char *) swig_constants[i].pvalue);
3728 break;
3729 case SWIG_POINTER:
3730 SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
3731 break;
3732 case SWIG_BINARY:
3733 SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
3734 break;
3735 default:
3736 break;
3737 }
3738 SvREADONLY_on(sv);
3739 }
3740
3741 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3742 SV *sv = get_sv((char*) SWIG_prefix "GSL_VERSION", TRUE | 0x2 | GV_ADDMULTI);
3743 sv_setsv(sv, SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(2.7)));
3744 SvREADONLY_on(sv);
3745 } while(0) /*@SWIG@*/;
3746 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3747 SV *sv = get_sv((char*) SWIG_prefix "GSL_MAJOR_VERSION", TRUE | 0x2 | GV_ADDMULTI);
3748 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(2)));
3749 SvREADONLY_on(sv);
3750 } while(0) /*@SWIG@*/;
3751 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3752 SV *sv = get_sv((char*) SWIG_prefix "GSL_MINOR_VERSION", TRUE | 0x2 | GV_ADDMULTI);
3753 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(7)));
3754 SvREADONLY_on(sv);
3755 } while(0) /*@SWIG@*/;
3756 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3757 SV *sv = get_sv((char*) SWIG_prefix "GSL_POSZERO", TRUE | 0x2 | GV_ADDMULTI);
3758 sv_setsv(sv, SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)((+0.0))));
3759 SvREADONLY_on(sv);
3760 } while(0) /*@SWIG@*/;
3761 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3762 SV *sv = get_sv((char*) SWIG_prefix "GSL_NEGZERO", TRUE | 0x2 | GV_ADDMULTI);
3763 sv_setsv(sv, SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)((-0.0))));
3764 SvREADONLY_on(sv);
3765 } while(0) /*@SWIG@*/;
3766 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3767 SV *sv = get_sv((char*) SWIG_prefix "GSL_SUCCESS", TRUE | 0x2 | GV_ADDMULTI);
3768 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_SUCCESS)));
3769 SvREADONLY_on(sv);
3770 } while(0) /*@SWIG@*/;
3771 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3772 SV *sv = get_sv((char*) SWIG_prefix "GSL_FAILURE", TRUE | 0x2 | GV_ADDMULTI);
3773 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_FAILURE)));
3774 SvREADONLY_on(sv);
3775 } while(0) /*@SWIG@*/;
3776 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3777 SV *sv = get_sv((char*) SWIG_prefix "GSL_CONTINUE", TRUE | 0x2 | GV_ADDMULTI);
3778 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_CONTINUE)));
3779 SvREADONLY_on(sv);
3780 } while(0) /*@SWIG@*/;
3781 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3782 SV *sv = get_sv((char*) SWIG_prefix "GSL_EDOM", TRUE | 0x2 | GV_ADDMULTI);
3783 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EDOM)));
3784 SvREADONLY_on(sv);
3785 } while(0) /*@SWIG@*/;
3786 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3787 SV *sv = get_sv((char*) SWIG_prefix "GSL_ERANGE", TRUE | 0x2 | GV_ADDMULTI);
3788 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ERANGE)));
3789 SvREADONLY_on(sv);
3790 } while(0) /*@SWIG@*/;
3791 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3792 SV *sv = get_sv((char*) SWIG_prefix "GSL_EFAULT", TRUE | 0x2 | GV_ADDMULTI);
3793 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EFAULT)));
3794 SvREADONLY_on(sv);
3795 } while(0) /*@SWIG@*/;
3796 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3797 SV *sv = get_sv((char*) SWIG_prefix "GSL_EINVAL", TRUE | 0x2 | GV_ADDMULTI);
3798 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EINVAL)));
3799 SvREADONLY_on(sv);
3800 } while(0) /*@SWIG@*/;
3801 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3802 SV *sv = get_sv((char*) SWIG_prefix "GSL_EFAILED", TRUE | 0x2 | GV_ADDMULTI);
3803 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EFAILED)));
3804 SvREADONLY_on(sv);
3805 } while(0) /*@SWIG@*/;
3806 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3807 SV *sv = get_sv((char*) SWIG_prefix "GSL_EFACTOR", TRUE | 0x2 | GV_ADDMULTI);
3808 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EFACTOR)));
3809 SvREADONLY_on(sv);
3810 } while(0) /*@SWIG@*/;
3811 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3812 SV *sv = get_sv((char*) SWIG_prefix "GSL_ESANITY", TRUE | 0x2 | GV_ADDMULTI);
3813 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ESANITY)));
3814 SvREADONLY_on(sv);
3815 } while(0) /*@SWIG@*/;
3816 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3817 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOMEM", TRUE | 0x2 | GV_ADDMULTI);
3818 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOMEM)));
3819 SvREADONLY_on(sv);
3820 } while(0) /*@SWIG@*/;
3821 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3822 SV *sv = get_sv((char*) SWIG_prefix "GSL_EBADFUNC", TRUE | 0x2 | GV_ADDMULTI);
3823 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EBADFUNC)));
3824 SvREADONLY_on(sv);
3825 } while(0) /*@SWIG@*/;
3826 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3827 SV *sv = get_sv((char*) SWIG_prefix "GSL_ERUNAWAY", TRUE | 0x2 | GV_ADDMULTI);
3828 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ERUNAWAY)));
3829 SvREADONLY_on(sv);
3830 } while(0) /*@SWIG@*/;
3831 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3832 SV *sv = get_sv((char*) SWIG_prefix "GSL_EMAXITER", TRUE | 0x2 | GV_ADDMULTI);
3833 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EMAXITER)));
3834 SvREADONLY_on(sv);
3835 } while(0) /*@SWIG@*/;
3836 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3837 SV *sv = get_sv((char*) SWIG_prefix "GSL_EZERODIV", TRUE | 0x2 | GV_ADDMULTI);
3838 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EZERODIV)));
3839 SvREADONLY_on(sv);
3840 } while(0) /*@SWIG@*/;
3841 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3842 SV *sv = get_sv((char*) SWIG_prefix "GSL_EBADTOL", TRUE | 0x2 | GV_ADDMULTI);
3843 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EBADTOL)));
3844 SvREADONLY_on(sv);
3845 } while(0) /*@SWIG@*/;
3846 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3847 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOL", TRUE | 0x2 | GV_ADDMULTI);
3848 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOL)));
3849 SvREADONLY_on(sv);
3850 } while(0) /*@SWIG@*/;
3851 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3852 SV *sv = get_sv((char*) SWIG_prefix "GSL_EUNDRFLW", TRUE | 0x2 | GV_ADDMULTI);
3853 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EUNDRFLW)));
3854 SvREADONLY_on(sv);
3855 } while(0) /*@SWIG@*/;
3856 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3857 SV *sv = get_sv((char*) SWIG_prefix "GSL_EOVRFLW", TRUE | 0x2 | GV_ADDMULTI);
3858 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EOVRFLW)));
3859 SvREADONLY_on(sv);
3860 } while(0) /*@SWIG@*/;
3861 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3862 SV *sv = get_sv((char*) SWIG_prefix "GSL_ELOSS", TRUE | 0x2 | GV_ADDMULTI);
3863 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ELOSS)));
3864 SvREADONLY_on(sv);
3865 } while(0) /*@SWIG@*/;
3866 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3867 SV *sv = get_sv((char*) SWIG_prefix "GSL_EROUND", TRUE | 0x2 | GV_ADDMULTI);
3868 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EROUND)));
3869 SvREADONLY_on(sv);
3870 } while(0) /*@SWIG@*/;
3871 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3872 SV *sv = get_sv((char*) SWIG_prefix "GSL_EBADLEN", TRUE | 0x2 | GV_ADDMULTI);
3873 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EBADLEN)));
3874 SvREADONLY_on(sv);
3875 } while(0) /*@SWIG@*/;
3876 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3877 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOTSQR", TRUE | 0x2 | GV_ADDMULTI);
3878 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOTSQR)));
3879 SvREADONLY_on(sv);
3880 } while(0) /*@SWIG@*/;
3881 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3882 SV *sv = get_sv((char*) SWIG_prefix "GSL_ESING", TRUE | 0x2 | GV_ADDMULTI);
3883 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ESING)));
3884 SvREADONLY_on(sv);
3885 } while(0) /*@SWIG@*/;
3886 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3887 SV *sv = get_sv((char*) SWIG_prefix "GSL_EDIVERGE", TRUE | 0x2 | GV_ADDMULTI);
3888 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EDIVERGE)));
3889 SvREADONLY_on(sv);
3890 } while(0) /*@SWIG@*/;
3891 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3892 SV *sv = get_sv((char*) SWIG_prefix "GSL_EUNSUP", TRUE | 0x2 | GV_ADDMULTI);
3893 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EUNSUP)));
3894 SvREADONLY_on(sv);
3895 } while(0) /*@SWIG@*/;
3896 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3897 SV *sv = get_sv((char*) SWIG_prefix "GSL_EUNIMPL", TRUE | 0x2 | GV_ADDMULTI);
3898 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EUNIMPL)));
3899 SvREADONLY_on(sv);
3900 } while(0) /*@SWIG@*/;
3901 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3902 SV *sv = get_sv((char*) SWIG_prefix "GSL_ECACHE", TRUE | 0x2 | GV_ADDMULTI);
3903 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ECACHE)));
3904 SvREADONLY_on(sv);
3905 } while(0) /*@SWIG@*/;
3906 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3907 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETABLE", TRUE | 0x2 | GV_ADDMULTI);
3908 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETABLE)));
3909 SvREADONLY_on(sv);
3910 } while(0) /*@SWIG@*/;
3911 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3912 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOPROG", TRUE | 0x2 | GV_ADDMULTI);
3913 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOPROG)));
3914 SvREADONLY_on(sv);
3915 } while(0) /*@SWIG@*/;
3916 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3917 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOPROGJ", TRUE | 0x2 | GV_ADDMULTI);
3918 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOPROGJ)));
3919 SvREADONLY_on(sv);
3920 } while(0) /*@SWIG@*/;
3921 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3922 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOLF", TRUE | 0x2 | GV_ADDMULTI);
3923 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOLF)));
3924 SvREADONLY_on(sv);
3925 } while(0) /*@SWIG@*/;
3926 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3927 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOLX", TRUE | 0x2 | GV_ADDMULTI);
3928 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOLX)));
3929 SvREADONLY_on(sv);
3930 } while(0) /*@SWIG@*/;
3931 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3932 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOLG", TRUE | 0x2 | GV_ADDMULTI);
3933 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOLG)));
3934 SvREADONLY_on(sv);
3935 } while(0) /*@SWIG@*/;
3936 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3937 SV *sv = get_sv((char*) SWIG_prefix "GSL_EOF", TRUE | 0x2 | GV_ADDMULTI);
3938 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EOF)));
3939 SvREADONLY_on(sv);
3940 } while(0) /*@SWIG@*/;
3941 ST(0) = &PL_sv_yes;
3942 XSRETURN(1);
3943 }
3944
3945