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_interp swig_types[5]
1525 #define SWIGTYPE_p_gsl_interp_accel swig_types[6]
1526 #define SWIGTYPE_p_gsl_interp_type swig_types[7]
1527 #define SWIGTYPE_p_void 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__Interp
1536
1537 #define SWIG_name "Math::GSL::Interpc::boot_Math__GSL__Interp"
1538 #define SWIG_prefix "Math::GSL::Interpc::"
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_inline.h"
2064 #include "gsl/gsl_types.h"
2065 #include "gsl/gsl_version.h"
2066 #include "gsl/gsl_interp.h"
2067
2068
2069 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,unsigned long * val)2070 SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
2071 {
2072 if (SvUOK(obj)) {
2073 UV v = SvUV(obj);
2074 if (UVSIZE <= sizeof(*val) || v <= ULONG_MAX) {
2075 if (val) *val = v;
2076 return SWIG_OK;
2077 }
2078 return SWIG_OverflowError;
2079 } else if (SvIOK(obj)) {
2080 IV v = SvIV(obj);
2081 if (v >= 0 && (IVSIZE <= sizeof(*val) || v <= ULONG_MAX)) {
2082 if (val) *val = v;
2083 return SWIG_OK;
2084 }
2085 return SWIG_OverflowError;
2086 } else {
2087 int dispatch = 0;
2088 const char *nptr = SvPV_nolen(obj);
2089 if (nptr) {
2090 char *endptr;
2091 unsigned long v;
2092 errno = 0;
2093 v = strtoul(nptr, &endptr,0);
2094 if (errno == ERANGE) {
2095 errno = 0;
2096 return SWIG_OverflowError;
2097 } else {
2098 if (*endptr == '\0') {
2099 if (val) *val = v;
2100 return SWIG_Str2NumCast(SWIG_OK);
2101 }
2102 }
2103 }
2104 if (!dispatch) {
2105 double d;
2106 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
2107 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2108 if (val) *val = (unsigned long)(d);
2109 return res;
2110 }
2111 }
2112 }
2113 return SWIG_TypeError;
2114 }
2115
2116
2117 #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
2118 # define SWIG_LONG_LONG_AVAILABLE
2119 #endif
2120
2121
2122 #ifdef SWIG_LONG_LONG_AVAILABLE
2123 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,unsigned long long * val)2124 SWIG_AsVal_unsigned_SS_long_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long long *val)
2125 {
2126 if (SvUOK(obj)) {
2127 /* pretty sure this should be conditional on
2128 * (UVSIZE <= sizeof(*val) || v <= ULLONG_MAX) */
2129 if (val) *val = SvUV(obj);
2130 return SWIG_OK;
2131 } else if (SvIOK(obj)) {
2132 IV v = SvIV(obj);
2133 if (v >= 0 && (IVSIZE <= sizeof(*val) || v <= ULLONG_MAX)) {
2134 if (val) *val = v;
2135 return SWIG_OK;
2136 } else {
2137 return SWIG_OverflowError;
2138 }
2139 } else {
2140 int dispatch = 0;
2141 const char *nptr = SvPV_nolen(obj);
2142 if (nptr) {
2143 char *endptr;
2144 unsigned long long v;
2145 errno = 0;
2146 v = strtoull(nptr, &endptr,0);
2147 if (errno == ERANGE) {
2148 errno = 0;
2149 return SWIG_OverflowError;
2150 } else {
2151 if (*endptr == '\0') {
2152 if (val) *val = v;
2153 return SWIG_Str2NumCast(SWIG_OK);
2154 }
2155 }
2156 }
2157 if (!dispatch) {
2158 const double mant_max = 1LL << DBL_MANT_DIG;
2159 double d;
2160 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
2161 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
2162 if (val) *val = (unsigned long long)(d);
2163 return res;
2164 }
2165 }
2166 }
2167 return SWIG_TypeError;
2168 }
2169 #endif
2170
2171
2172 SWIGINTERNINLINE int
SWIG_PERL_DECL_ARGS_2(SV * obj,size_t * val)2173 SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
2174 {
2175 int res = SWIG_TypeError;
2176 #ifdef SWIG_LONG_LONG_AVAILABLE
2177 if (sizeof(size_t) <= sizeof(unsigned long)) {
2178 #endif
2179 unsigned long v;
2180 res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
2181 if (SWIG_IsOK(res) && val) *val = (size_t)(v);
2182 #ifdef SWIG_LONG_LONG_AVAILABLE
2183 } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
2184 unsigned long long v;
2185 res = SWIG_AsVal_unsigned_SS_long_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
2186 if (SWIG_IsOK(res) && val) *val = (size_t)(v);
2187 }
2188 #endif
2189 return res;
2190 }
2191
2192
2193 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(unsigned long value)2194 SWIG_From_unsigned_SS_long SWIG_PERL_DECL_ARGS_1(unsigned long value)
2195 {
2196 SV *sv;
2197 if (UVSIZE >= sizeof(value) || value <= UV_MAX)
2198 sv = newSVuv(value);
2199 else
2200 sv = newSVpvf("%lu", value);
2201 return sv_2mortal(sv);
2202 }
2203
2204
2205 #include <stdio.h>
2206 #if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__BORLANDC__) || defined(_WATCOM)
2207 # ifndef snprintf
2208 # define snprintf _snprintf
2209 # endif
2210 #endif
2211
2212
2213 #ifdef SWIG_LONG_LONG_AVAILABLE
2214 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(unsigned long long value)2215 SWIG_From_unsigned_SS_long_SS_long SWIG_PERL_DECL_ARGS_1(unsigned long long value)
2216 {
2217 SV *sv;
2218 if (UVSIZE >= sizeof(value) || value <= UV_MAX)
2219 sv = newSVuv((UV)(value));
2220 else {
2221 //sv = newSVpvf("%llu", value); doesn't work in non 64bit Perl
2222 char temp[256];
2223 sprintf(temp, "%llu", value);
2224 sv = newSVpv(temp, 0);
2225 }
2226 return sv_2mortal(sv);
2227 }
2228 #endif
2229
2230
2231 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(size_t value)2232 SWIG_From_size_t SWIG_PERL_DECL_ARGS_1(size_t value)
2233 {
2234 #ifdef SWIG_LONG_LONG_AVAILABLE
2235 if (sizeof(size_t) <= sizeof(unsigned long)) {
2236 #endif
2237 return SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1((unsigned long)(value));
2238 #ifdef SWIG_LONG_LONG_AVAILABLE
2239 } else {
2240 /* assume sizeof(size_t) <= sizeof(unsigned long long) */
2241 return SWIG_From_unsigned_SS_long_SS_long SWIG_PERL_CALL_ARGS_1((unsigned long long)(value));
2242 }
2243 #endif
2244 }
2245
2246
2247 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(unsigned int value)2248 SWIG_From_unsigned_SS_int SWIG_PERL_DECL_ARGS_1(unsigned int value)
2249 {
2250 return SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1(value);
2251 }
2252
2253 #ifdef __cplusplus
2254 extern "C" {
2255 #endif
2256
2257 #ifdef PERL_OBJECT
2258 #define MAGIC_CLASS _wrap_Math__GSL__Interp_var::
2259 class _wrap_Math__GSL__Interp_var : public CPerlObj {
2260 public:
2261 #else
2262 #define MAGIC_CLASS
2263 #endif
swig_magic_readonly(pTHX_ SV * SWIGUNUSEDPARM (sv),MAGIC * SWIGUNUSEDPARM (mg))2264 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
2265 MAGIC_PPERL
2266 croak("Value is read-only.");
2267 return 0;
2268 }
_wrap_gsl_interp_linear_set(pTHX_ SV * sv,MAGIC * SWIGUNUSEDPARM (mg))2269 SWIGCLASS_STATIC int _wrap_gsl_interp_linear_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
2270 MAGIC_PPERL
2271 {
2272 void *argp = 0;
2273 int res = SWIG_ConvertPtr(sv, &argp, SWIGTYPE_p_gsl_interp_type, 0 );
2274 if (!SWIG_IsOK(res)) {
2275 SWIG_exception_fail(SWIG_ArgError(res), "in variable '""gsl_interp_linear""' of type '""gsl_interp_type const *""'");
2276 }
2277 gsl_interp_linear = (gsl_interp_type *)(argp);
2278 }
2279 fail:
2280 return 1;
2281 }
2282
2283
_wrap_gsl_interp_linear_get(pTHX_ SV * sv,MAGIC * SWIGUNUSEDPARM (mg))2284 SWIGCLASS_STATIC int _wrap_gsl_interp_linear_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
2285 MAGIC_PPERL
2286 sv_setiv(SvRV(sv),PTR2IV(gsl_interp_linear));
2287 return 1;
2288 }
2289
2290
_wrap_gsl_interp_polynomial_set(pTHX_ SV * sv,MAGIC * SWIGUNUSEDPARM (mg))2291 SWIGCLASS_STATIC int _wrap_gsl_interp_polynomial_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
2292 MAGIC_PPERL
2293 {
2294 void *argp = 0;
2295 int res = SWIG_ConvertPtr(sv, &argp, SWIGTYPE_p_gsl_interp_type, 0 );
2296 if (!SWIG_IsOK(res)) {
2297 SWIG_exception_fail(SWIG_ArgError(res), "in variable '""gsl_interp_polynomial""' of type '""gsl_interp_type const *""'");
2298 }
2299 gsl_interp_polynomial = (gsl_interp_type *)(argp);
2300 }
2301 fail:
2302 return 1;
2303 }
2304
2305
_wrap_gsl_interp_polynomial_get(pTHX_ SV * sv,MAGIC * SWIGUNUSEDPARM (mg))2306 SWIGCLASS_STATIC int _wrap_gsl_interp_polynomial_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
2307 MAGIC_PPERL
2308 sv_setiv(SvRV(sv),PTR2IV(gsl_interp_polynomial));
2309 return 1;
2310 }
2311
2312
_wrap_gsl_interp_cspline_set(pTHX_ SV * sv,MAGIC * SWIGUNUSEDPARM (mg))2313 SWIGCLASS_STATIC int _wrap_gsl_interp_cspline_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
2314 MAGIC_PPERL
2315 {
2316 void *argp = 0;
2317 int res = SWIG_ConvertPtr(sv, &argp, SWIGTYPE_p_gsl_interp_type, 0 );
2318 if (!SWIG_IsOK(res)) {
2319 SWIG_exception_fail(SWIG_ArgError(res), "in variable '""gsl_interp_cspline""' of type '""gsl_interp_type const *""'");
2320 }
2321 gsl_interp_cspline = (gsl_interp_type *)(argp);
2322 }
2323 fail:
2324 return 1;
2325 }
2326
2327
_wrap_gsl_interp_cspline_get(pTHX_ SV * sv,MAGIC * SWIGUNUSEDPARM (mg))2328 SWIGCLASS_STATIC int _wrap_gsl_interp_cspline_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
2329 MAGIC_PPERL
2330 sv_setiv(SvRV(sv),PTR2IV(gsl_interp_cspline));
2331 return 1;
2332 }
2333
2334
_wrap_gsl_interp_cspline_periodic_set(pTHX_ SV * sv,MAGIC * SWIGUNUSEDPARM (mg))2335 SWIGCLASS_STATIC int _wrap_gsl_interp_cspline_periodic_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
2336 MAGIC_PPERL
2337 {
2338 void *argp = 0;
2339 int res = SWIG_ConvertPtr(sv, &argp, SWIGTYPE_p_gsl_interp_type, 0 );
2340 if (!SWIG_IsOK(res)) {
2341 SWIG_exception_fail(SWIG_ArgError(res), "in variable '""gsl_interp_cspline_periodic""' of type '""gsl_interp_type const *""'");
2342 }
2343 gsl_interp_cspline_periodic = (gsl_interp_type *)(argp);
2344 }
2345 fail:
2346 return 1;
2347 }
2348
2349
_wrap_gsl_interp_cspline_periodic_get(pTHX_ SV * sv,MAGIC * SWIGUNUSEDPARM (mg))2350 SWIGCLASS_STATIC int _wrap_gsl_interp_cspline_periodic_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
2351 MAGIC_PPERL
2352 sv_setiv(SvRV(sv),PTR2IV(gsl_interp_cspline_periodic));
2353 return 1;
2354 }
2355
2356
_wrap_gsl_interp_akima_set(pTHX_ SV * sv,MAGIC * SWIGUNUSEDPARM (mg))2357 SWIGCLASS_STATIC int _wrap_gsl_interp_akima_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
2358 MAGIC_PPERL
2359 {
2360 void *argp = 0;
2361 int res = SWIG_ConvertPtr(sv, &argp, SWIGTYPE_p_gsl_interp_type, 0 );
2362 if (!SWIG_IsOK(res)) {
2363 SWIG_exception_fail(SWIG_ArgError(res), "in variable '""gsl_interp_akima""' of type '""gsl_interp_type const *""'");
2364 }
2365 gsl_interp_akima = (gsl_interp_type *)(argp);
2366 }
2367 fail:
2368 return 1;
2369 }
2370
2371
_wrap_gsl_interp_akima_get(pTHX_ SV * sv,MAGIC * SWIGUNUSEDPARM (mg))2372 SWIGCLASS_STATIC int _wrap_gsl_interp_akima_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
2373 MAGIC_PPERL
2374 sv_setiv(SvRV(sv),PTR2IV(gsl_interp_akima));
2375 return 1;
2376 }
2377
2378
_wrap_gsl_interp_akima_periodic_set(pTHX_ SV * sv,MAGIC * SWIGUNUSEDPARM (mg))2379 SWIGCLASS_STATIC int _wrap_gsl_interp_akima_periodic_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
2380 MAGIC_PPERL
2381 {
2382 void *argp = 0;
2383 int res = SWIG_ConvertPtr(sv, &argp, SWIGTYPE_p_gsl_interp_type, 0 );
2384 if (!SWIG_IsOK(res)) {
2385 SWIG_exception_fail(SWIG_ArgError(res), "in variable '""gsl_interp_akima_periodic""' of type '""gsl_interp_type const *""'");
2386 }
2387 gsl_interp_akima_periodic = (gsl_interp_type *)(argp);
2388 }
2389 fail:
2390 return 1;
2391 }
2392
2393
_wrap_gsl_interp_akima_periodic_get(pTHX_ SV * sv,MAGIC * SWIGUNUSEDPARM (mg))2394 SWIGCLASS_STATIC int _wrap_gsl_interp_akima_periodic_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
2395 MAGIC_PPERL
2396 sv_setiv(SvRV(sv),PTR2IV(gsl_interp_akima_periodic));
2397 return 1;
2398 }
2399
2400
2401
2402
2403 #ifdef PERL_OBJECT
2404 };
2405 #endif
2406
2407 #ifdef __cplusplus
2408 }
2409 #endif
2410
2411 #ifdef __cplusplus
2412 extern "C" {
2413 #endif
XS(_wrap_gsl_error)2414 XS(_wrap_gsl_error) {
2415 {
2416 char *arg1 = (char *) 0 ;
2417 char *arg2 = (char *) 0 ;
2418 int arg3 ;
2419 int arg4 ;
2420 int res1 ;
2421 char *buf1 = 0 ;
2422 int alloc1 = 0 ;
2423 int res2 ;
2424 char *buf2 = 0 ;
2425 int alloc2 = 0 ;
2426 int val3 ;
2427 int ecode3 = 0 ;
2428 int val4 ;
2429 int ecode4 = 0 ;
2430 int argvi = 0;
2431 dXSARGS;
2432
2433 if ((items < 4) || (items > 4)) {
2434 SWIG_croak("Usage: gsl_error(reason,file,line,gsl_errno);");
2435 }
2436 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2437 if (!SWIG_IsOK(res1)) {
2438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_error" "', argument " "1"" of type '" "char const *""'");
2439 }
2440 arg1 = (char *)(buf1);
2441 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2442 if (!SWIG_IsOK(res2)) {
2443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_error" "', argument " "2"" of type '" "char const *""'");
2444 }
2445 arg2 = (char *)(buf2);
2446 ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2447 if (!SWIG_IsOK(ecode3)) {
2448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_error" "', argument " "3"" of type '" "int""'");
2449 }
2450 arg3 = (int)(val3);
2451 ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
2452 if (!SWIG_IsOK(ecode4)) {
2453 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_error" "', argument " "4"" of type '" "int""'");
2454 }
2455 arg4 = (int)(val4);
2456 gsl_error((char const *)arg1,(char const *)arg2,arg3,arg4);
2457 ST(argvi) = &PL_sv_undef;
2458 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2459 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2460
2461
2462 XSRETURN(argvi);
2463 fail:
2464 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2465 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2466
2467
2468 SWIG_croak_null();
2469 }
2470 }
2471
2472
XS(_wrap_gsl_stream_printf)2473 XS(_wrap_gsl_stream_printf) {
2474 {
2475 char *arg1 = (char *) 0 ;
2476 char *arg2 = (char *) 0 ;
2477 int arg3 ;
2478 char *arg4 = (char *) 0 ;
2479 int res1 ;
2480 char *buf1 = 0 ;
2481 int alloc1 = 0 ;
2482 int res2 ;
2483 char *buf2 = 0 ;
2484 int alloc2 = 0 ;
2485 int val3 ;
2486 int ecode3 = 0 ;
2487 int res4 ;
2488 char *buf4 = 0 ;
2489 int alloc4 = 0 ;
2490 int argvi = 0;
2491 dXSARGS;
2492
2493 if ((items < 4) || (items > 4)) {
2494 SWIG_croak("Usage: gsl_stream_printf(label,file,line,reason);");
2495 }
2496 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2497 if (!SWIG_IsOK(res1)) {
2498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_stream_printf" "', argument " "1"" of type '" "char const *""'");
2499 }
2500 arg1 = (char *)(buf1);
2501 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2502 if (!SWIG_IsOK(res2)) {
2503 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_stream_printf" "', argument " "2"" of type '" "char const *""'");
2504 }
2505 arg2 = (char *)(buf2);
2506 ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2507 if (!SWIG_IsOK(ecode3)) {
2508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_stream_printf" "', argument " "3"" of type '" "int""'");
2509 }
2510 arg3 = (int)(val3);
2511 res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
2512 if (!SWIG_IsOK(res4)) {
2513 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gsl_stream_printf" "', argument " "4"" of type '" "char const *""'");
2514 }
2515 arg4 = (char *)(buf4);
2516 gsl_stream_printf((char const *)arg1,(char const *)arg2,arg3,(char const *)arg4);
2517 ST(argvi) = &PL_sv_undef;
2518 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2519 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2520
2521 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2522 XSRETURN(argvi);
2523 fail:
2524 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2525 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2526
2527 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2528 SWIG_croak_null();
2529 }
2530 }
2531
2532
XS(_wrap_gsl_strerror)2533 XS(_wrap_gsl_strerror) {
2534 {
2535 int arg1 ;
2536 int val1 ;
2537 int ecode1 = 0 ;
2538 int argvi = 0;
2539 char *result = 0 ;
2540 dXSARGS;
2541
2542 if ((items < 1) || (items > 1)) {
2543 SWIG_croak("Usage: gsl_strerror(gsl_errno);");
2544 }
2545 ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2546 if (!SWIG_IsOK(ecode1)) {
2547 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_strerror" "', argument " "1"" of type '" "int""'");
2548 }
2549 arg1 = (int)(val1);
2550 result = (char *)gsl_strerror(arg1);
2551 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2552
2553 XSRETURN(argvi);
2554 fail:
2555
2556 SWIG_croak_null();
2557 }
2558 }
2559
2560
XS(_wrap_gsl_set_error_handler)2561 XS(_wrap_gsl_set_error_handler) {
2562 {
2563 gsl_error_handler_t *arg1 = (gsl_error_handler_t *) 0 ;
2564 int argvi = 0;
2565 gsl_error_handler_t *result = 0 ;
2566 dXSARGS;
2567
2568 if ((items < 1) || (items > 1)) {
2569 SWIG_croak("Usage: gsl_set_error_handler(new_handler);");
2570 }
2571 {
2572 int res = SWIG_ConvertFunctionPtr(ST(0), (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void);
2573 if (!SWIG_IsOK(res)) {
2574 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gsl_set_error_handler" "', argument " "1"" of type '" "gsl_error_handler_t *""'");
2575 }
2576 }
2577 result = (gsl_error_handler_t *)gsl_set_error_handler(arg1);
2578 ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void); argvi++ ;
2579
2580 XSRETURN(argvi);
2581 fail:
2582
2583 SWIG_croak_null();
2584 }
2585 }
2586
2587
XS(_wrap_gsl_set_error_handler_off)2588 XS(_wrap_gsl_set_error_handler_off) {
2589 {
2590 int argvi = 0;
2591 gsl_error_handler_t *result = 0 ;
2592 dXSARGS;
2593
2594 if ((items < 0) || (items > 0)) {
2595 SWIG_croak("Usage: gsl_set_error_handler_off();");
2596 }
2597 result = (gsl_error_handler_t *)gsl_set_error_handler_off();
2598 ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void); argvi++ ;
2599 XSRETURN(argvi);
2600 fail:
2601 SWIG_croak_null();
2602 }
2603 }
2604
2605
XS(_wrap_gsl_set_stream_handler)2606 XS(_wrap_gsl_set_stream_handler) {
2607 {
2608 gsl_stream_handler_t *arg1 = (gsl_stream_handler_t *) 0 ;
2609 int argvi = 0;
2610 gsl_stream_handler_t *result = 0 ;
2611 dXSARGS;
2612
2613 if ((items < 1) || (items > 1)) {
2614 SWIG_croak("Usage: gsl_set_stream_handler(new_handler);");
2615 }
2616 {
2617 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);
2618 if (!SWIG_IsOK(res)) {
2619 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gsl_set_stream_handler" "', argument " "1"" of type '" "gsl_stream_handler_t *""'");
2620 }
2621 }
2622 result = (gsl_stream_handler_t *)gsl_set_stream_handler(arg1);
2623 ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void); argvi++ ;
2624
2625 XSRETURN(argvi);
2626 fail:
2627
2628 SWIG_croak_null();
2629 }
2630 }
2631
2632
XS(_wrap_gsl_set_stream)2633 XS(_wrap_gsl_set_stream) {
2634 {
2635 FILE *arg1 = (FILE *) 0 ;
2636 void *argp1 = 0 ;
2637 int res1 = 0 ;
2638 int argvi = 0;
2639 FILE *result = 0 ;
2640 dXSARGS;
2641
2642 if ((items < 1) || (items > 1)) {
2643 SWIG_croak("Usage: gsl_set_stream(new_stream);");
2644 }
2645 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_FILE, 0 | 0 );
2646 if (!SWIG_IsOK(res1)) {
2647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_set_stream" "', argument " "1"" of type '" "FILE *""'");
2648 }
2649 arg1 = (FILE *)(argp1);
2650 result = (FILE *)gsl_set_stream(arg1);
2651 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 | 0); argvi++ ;
2652
2653 XSRETURN(argvi);
2654 fail:
2655
2656 SWIG_croak_null();
2657 }
2658 }
2659
2660
XS(_wrap_gsl_interp_accel_cache_set)2661 XS(_wrap_gsl_interp_accel_cache_set) {
2662 {
2663 gsl_interp_accel *arg1 = (gsl_interp_accel *) 0 ;
2664 size_t arg2 ;
2665 void *argp1 = 0 ;
2666 int res1 = 0 ;
2667 size_t val2 ;
2668 int ecode2 = 0 ;
2669 int argvi = 0;
2670 dXSARGS;
2671
2672 if ((items < 2) || (items > 2)) {
2673 SWIG_croak("Usage: gsl_interp_accel_cache_set(self,cache);");
2674 }
2675 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
2676 if (!SWIG_IsOK(res1)) {
2677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_accel_cache_set" "', argument " "1"" of type '" "gsl_interp_accel *""'");
2678 }
2679 arg1 = (gsl_interp_accel *)(argp1);
2680 ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2681 if (!SWIG_IsOK(ecode2)) {
2682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_interp_accel_cache_set" "', argument " "2"" of type '" "size_t""'");
2683 }
2684 arg2 = (size_t)(val2);
2685 if (arg1) (arg1)->cache = arg2;
2686 ST(argvi) = &PL_sv_undef;
2687
2688
2689 XSRETURN(argvi);
2690 fail:
2691
2692
2693 SWIG_croak_null();
2694 }
2695 }
2696
2697
XS(_wrap_gsl_interp_accel_cache_get)2698 XS(_wrap_gsl_interp_accel_cache_get) {
2699 {
2700 gsl_interp_accel *arg1 = (gsl_interp_accel *) 0 ;
2701 void *argp1 = 0 ;
2702 int res1 = 0 ;
2703 int argvi = 0;
2704 size_t result;
2705 dXSARGS;
2706
2707 if ((items < 1) || (items > 1)) {
2708 SWIG_croak("Usage: gsl_interp_accel_cache_get(self);");
2709 }
2710 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
2711 if (!SWIG_IsOK(res1)) {
2712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_accel_cache_get" "', argument " "1"" of type '" "gsl_interp_accel *""'");
2713 }
2714 arg1 = (gsl_interp_accel *)(argp1);
2715 result = ((arg1)->cache);
2716 ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1((size_t)(result)); argvi++ ;
2717
2718 XSRETURN(argvi);
2719 fail:
2720
2721 SWIG_croak_null();
2722 }
2723 }
2724
2725
XS(_wrap_gsl_interp_accel_miss_count_set)2726 XS(_wrap_gsl_interp_accel_miss_count_set) {
2727 {
2728 gsl_interp_accel *arg1 = (gsl_interp_accel *) 0 ;
2729 size_t arg2 ;
2730 void *argp1 = 0 ;
2731 int res1 = 0 ;
2732 size_t val2 ;
2733 int ecode2 = 0 ;
2734 int argvi = 0;
2735 dXSARGS;
2736
2737 if ((items < 2) || (items > 2)) {
2738 SWIG_croak("Usage: gsl_interp_accel_miss_count_set(self,miss_count);");
2739 }
2740 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
2741 if (!SWIG_IsOK(res1)) {
2742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_accel_miss_count_set" "', argument " "1"" of type '" "gsl_interp_accel *""'");
2743 }
2744 arg1 = (gsl_interp_accel *)(argp1);
2745 ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2746 if (!SWIG_IsOK(ecode2)) {
2747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_interp_accel_miss_count_set" "', argument " "2"" of type '" "size_t""'");
2748 }
2749 arg2 = (size_t)(val2);
2750 if (arg1) (arg1)->miss_count = arg2;
2751 ST(argvi) = &PL_sv_undef;
2752
2753
2754 XSRETURN(argvi);
2755 fail:
2756
2757
2758 SWIG_croak_null();
2759 }
2760 }
2761
2762
XS(_wrap_gsl_interp_accel_miss_count_get)2763 XS(_wrap_gsl_interp_accel_miss_count_get) {
2764 {
2765 gsl_interp_accel *arg1 = (gsl_interp_accel *) 0 ;
2766 void *argp1 = 0 ;
2767 int res1 = 0 ;
2768 int argvi = 0;
2769 size_t result;
2770 dXSARGS;
2771
2772 if ((items < 1) || (items > 1)) {
2773 SWIG_croak("Usage: gsl_interp_accel_miss_count_get(self);");
2774 }
2775 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
2776 if (!SWIG_IsOK(res1)) {
2777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_accel_miss_count_get" "', argument " "1"" of type '" "gsl_interp_accel *""'");
2778 }
2779 arg1 = (gsl_interp_accel *)(argp1);
2780 result = ((arg1)->miss_count);
2781 ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1((size_t)(result)); argvi++ ;
2782
2783 XSRETURN(argvi);
2784 fail:
2785
2786 SWIG_croak_null();
2787 }
2788 }
2789
2790
XS(_wrap_gsl_interp_accel_hit_count_set)2791 XS(_wrap_gsl_interp_accel_hit_count_set) {
2792 {
2793 gsl_interp_accel *arg1 = (gsl_interp_accel *) 0 ;
2794 size_t arg2 ;
2795 void *argp1 = 0 ;
2796 int res1 = 0 ;
2797 size_t val2 ;
2798 int ecode2 = 0 ;
2799 int argvi = 0;
2800 dXSARGS;
2801
2802 if ((items < 2) || (items > 2)) {
2803 SWIG_croak("Usage: gsl_interp_accel_hit_count_set(self,hit_count);");
2804 }
2805 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
2806 if (!SWIG_IsOK(res1)) {
2807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_accel_hit_count_set" "', argument " "1"" of type '" "gsl_interp_accel *""'");
2808 }
2809 arg1 = (gsl_interp_accel *)(argp1);
2810 ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2811 if (!SWIG_IsOK(ecode2)) {
2812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_interp_accel_hit_count_set" "', argument " "2"" of type '" "size_t""'");
2813 }
2814 arg2 = (size_t)(val2);
2815 if (arg1) (arg1)->hit_count = arg2;
2816 ST(argvi) = &PL_sv_undef;
2817
2818
2819 XSRETURN(argvi);
2820 fail:
2821
2822
2823 SWIG_croak_null();
2824 }
2825 }
2826
2827
XS(_wrap_gsl_interp_accel_hit_count_get)2828 XS(_wrap_gsl_interp_accel_hit_count_get) {
2829 {
2830 gsl_interp_accel *arg1 = (gsl_interp_accel *) 0 ;
2831 void *argp1 = 0 ;
2832 int res1 = 0 ;
2833 int argvi = 0;
2834 size_t result;
2835 dXSARGS;
2836
2837 if ((items < 1) || (items > 1)) {
2838 SWIG_croak("Usage: gsl_interp_accel_hit_count_get(self);");
2839 }
2840 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
2841 if (!SWIG_IsOK(res1)) {
2842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_accel_hit_count_get" "', argument " "1"" of type '" "gsl_interp_accel *""'");
2843 }
2844 arg1 = (gsl_interp_accel *)(argp1);
2845 result = ((arg1)->hit_count);
2846 ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1((size_t)(result)); argvi++ ;
2847
2848 XSRETURN(argvi);
2849 fail:
2850
2851 SWIG_croak_null();
2852 }
2853 }
2854
2855
XS(_wrap_new_gsl_interp_accel)2856 XS(_wrap_new_gsl_interp_accel) {
2857 {
2858 int argvi = 0;
2859 gsl_interp_accel *result = 0 ;
2860 dXSARGS;
2861
2862 if ((items < 0) || (items > 0)) {
2863 SWIG_croak("Usage: new_gsl_interp_accel();");
2864 }
2865 result = (gsl_interp_accel *)calloc(1, sizeof(gsl_interp_accel));
2866 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gsl_interp_accel, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
2867 XSRETURN(argvi);
2868 fail:
2869 SWIG_croak_null();
2870 }
2871 }
2872
2873
XS(_wrap_delete_gsl_interp_accel)2874 XS(_wrap_delete_gsl_interp_accel) {
2875 {
2876 gsl_interp_accel *arg1 = (gsl_interp_accel *) 0 ;
2877 void *argp1 = 0 ;
2878 int res1 = 0 ;
2879 int argvi = 0;
2880 dXSARGS;
2881
2882 if ((items < 1) || (items > 1)) {
2883 SWIG_croak("Usage: delete_gsl_interp_accel(self);");
2884 }
2885 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp_accel, SWIG_POINTER_DISOWN | 0 );
2886 if (!SWIG_IsOK(res1)) {
2887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gsl_interp_accel" "', argument " "1"" of type '" "gsl_interp_accel *""'");
2888 }
2889 arg1 = (gsl_interp_accel *)(argp1);
2890 free((char *) arg1);
2891 ST(argvi) = &PL_sv_undef;
2892
2893 XSRETURN(argvi);
2894 fail:
2895
2896 SWIG_croak_null();
2897 }
2898 }
2899
2900
XS(_wrap_gsl_interp_type_set)2901 XS(_wrap_gsl_interp_type_set) {
2902 {
2903 gsl_interp *arg1 = (gsl_interp *) 0 ;
2904 gsl_interp_type *arg2 = (gsl_interp_type *) 0 ;
2905 void *argp1 = 0 ;
2906 int res1 = 0 ;
2907 void *argp2 = 0 ;
2908 int res2 = 0 ;
2909 int argvi = 0;
2910 dXSARGS;
2911
2912 if ((items < 2) || (items > 2)) {
2913 SWIG_croak("Usage: gsl_interp_type_set(self,type);");
2914 }
2915 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
2916 if (!SWIG_IsOK(res1)) {
2917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_type_set" "', argument " "1"" of type '" "gsl_interp *""'");
2918 }
2919 arg1 = (gsl_interp *)(argp1);
2920 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_gsl_interp_type, SWIG_POINTER_DISOWN | 0 );
2921 if (!SWIG_IsOK(res2)) {
2922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_interp_type_set" "', argument " "2"" of type '" "gsl_interp_type const *""'");
2923 }
2924 arg2 = (gsl_interp_type *)(argp2);
2925 if (arg1) (arg1)->type = (gsl_interp_type const *)arg2;
2926 ST(argvi) = &PL_sv_undef;
2927
2928
2929 XSRETURN(argvi);
2930 fail:
2931
2932
2933 SWIG_croak_null();
2934 }
2935 }
2936
2937
XS(_wrap_gsl_interp_type_get)2938 XS(_wrap_gsl_interp_type_get) {
2939 {
2940 gsl_interp *arg1 = (gsl_interp *) 0 ;
2941 void *argp1 = 0 ;
2942 int res1 = 0 ;
2943 int argvi = 0;
2944 gsl_interp_type *result = 0 ;
2945 dXSARGS;
2946
2947 if ((items < 1) || (items > 1)) {
2948 SWIG_croak("Usage: gsl_interp_type_get(self);");
2949 }
2950 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
2951 if (!SWIG_IsOK(res1)) {
2952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_type_get" "', argument " "1"" of type '" "gsl_interp *""'");
2953 }
2954 arg1 = (gsl_interp *)(argp1);
2955 result = (gsl_interp_type *) ((arg1)->type);
2956 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gsl_interp_type, 0 | 0); argvi++ ;
2957
2958 XSRETURN(argvi);
2959 fail:
2960
2961 SWIG_croak_null();
2962 }
2963 }
2964
2965
XS(_wrap_gsl_interp_xmin_set)2966 XS(_wrap_gsl_interp_xmin_set) {
2967 {
2968 gsl_interp *arg1 = (gsl_interp *) 0 ;
2969 double arg2 ;
2970 void *argp1 = 0 ;
2971 int res1 = 0 ;
2972 double val2 ;
2973 int ecode2 = 0 ;
2974 int argvi = 0;
2975 dXSARGS;
2976
2977 if ((items < 2) || (items > 2)) {
2978 SWIG_croak("Usage: gsl_interp_xmin_set(self,xmin);");
2979 }
2980 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
2981 if (!SWIG_IsOK(res1)) {
2982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_xmin_set" "', argument " "1"" of type '" "gsl_interp *""'");
2983 }
2984 arg1 = (gsl_interp *)(argp1);
2985 ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2986 if (!SWIG_IsOK(ecode2)) {
2987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_interp_xmin_set" "', argument " "2"" of type '" "double""'");
2988 }
2989 arg2 = (double)(val2);
2990 if (arg1) (arg1)->xmin = arg2;
2991 ST(argvi) = &PL_sv_undef;
2992
2993
2994 XSRETURN(argvi);
2995 fail:
2996
2997
2998 SWIG_croak_null();
2999 }
3000 }
3001
3002
XS(_wrap_gsl_interp_xmin_get)3003 XS(_wrap_gsl_interp_xmin_get) {
3004 {
3005 gsl_interp *arg1 = (gsl_interp *) 0 ;
3006 void *argp1 = 0 ;
3007 int res1 = 0 ;
3008 int argvi = 0;
3009 double result;
3010 dXSARGS;
3011
3012 if ((items < 1) || (items > 1)) {
3013 SWIG_croak("Usage: gsl_interp_xmin_get(self);");
3014 }
3015 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
3016 if (!SWIG_IsOK(res1)) {
3017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_xmin_get" "', argument " "1"" of type '" "gsl_interp *""'");
3018 }
3019 arg1 = (gsl_interp *)(argp1);
3020 result = (double) ((arg1)->xmin);
3021 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3022
3023 XSRETURN(argvi);
3024 fail:
3025
3026 SWIG_croak_null();
3027 }
3028 }
3029
3030
XS(_wrap_gsl_interp_xmax_set)3031 XS(_wrap_gsl_interp_xmax_set) {
3032 {
3033 gsl_interp *arg1 = (gsl_interp *) 0 ;
3034 double arg2 ;
3035 void *argp1 = 0 ;
3036 int res1 = 0 ;
3037 double val2 ;
3038 int ecode2 = 0 ;
3039 int argvi = 0;
3040 dXSARGS;
3041
3042 if ((items < 2) || (items > 2)) {
3043 SWIG_croak("Usage: gsl_interp_xmax_set(self,xmax);");
3044 }
3045 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
3046 if (!SWIG_IsOK(res1)) {
3047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_xmax_set" "', argument " "1"" of type '" "gsl_interp *""'");
3048 }
3049 arg1 = (gsl_interp *)(argp1);
3050 ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
3051 if (!SWIG_IsOK(ecode2)) {
3052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_interp_xmax_set" "', argument " "2"" of type '" "double""'");
3053 }
3054 arg2 = (double)(val2);
3055 if (arg1) (arg1)->xmax = arg2;
3056 ST(argvi) = &PL_sv_undef;
3057
3058
3059 XSRETURN(argvi);
3060 fail:
3061
3062
3063 SWIG_croak_null();
3064 }
3065 }
3066
3067
XS(_wrap_gsl_interp_xmax_get)3068 XS(_wrap_gsl_interp_xmax_get) {
3069 {
3070 gsl_interp *arg1 = (gsl_interp *) 0 ;
3071 void *argp1 = 0 ;
3072 int res1 = 0 ;
3073 int argvi = 0;
3074 double result;
3075 dXSARGS;
3076
3077 if ((items < 1) || (items > 1)) {
3078 SWIG_croak("Usage: gsl_interp_xmax_get(self);");
3079 }
3080 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
3081 if (!SWIG_IsOK(res1)) {
3082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_xmax_get" "', argument " "1"" of type '" "gsl_interp *""'");
3083 }
3084 arg1 = (gsl_interp *)(argp1);
3085 result = (double) ((arg1)->xmax);
3086 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3087
3088 XSRETURN(argvi);
3089 fail:
3090
3091 SWIG_croak_null();
3092 }
3093 }
3094
3095
XS(_wrap_gsl_interp_size_set)3096 XS(_wrap_gsl_interp_size_set) {
3097 {
3098 gsl_interp *arg1 = (gsl_interp *) 0 ;
3099 size_t arg2 ;
3100 void *argp1 = 0 ;
3101 int res1 = 0 ;
3102 size_t val2 ;
3103 int ecode2 = 0 ;
3104 int argvi = 0;
3105 dXSARGS;
3106
3107 if ((items < 2) || (items > 2)) {
3108 SWIG_croak("Usage: gsl_interp_size_set(self,size);");
3109 }
3110 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
3111 if (!SWIG_IsOK(res1)) {
3112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_size_set" "', argument " "1"" of type '" "gsl_interp *""'");
3113 }
3114 arg1 = (gsl_interp *)(argp1);
3115 ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
3116 if (!SWIG_IsOK(ecode2)) {
3117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_interp_size_set" "', argument " "2"" of type '" "size_t""'");
3118 }
3119 arg2 = (size_t)(val2);
3120 if (arg1) (arg1)->size = arg2;
3121 ST(argvi) = &PL_sv_undef;
3122
3123
3124 XSRETURN(argvi);
3125 fail:
3126
3127
3128 SWIG_croak_null();
3129 }
3130 }
3131
3132
XS(_wrap_gsl_interp_size_get)3133 XS(_wrap_gsl_interp_size_get) {
3134 {
3135 gsl_interp *arg1 = (gsl_interp *) 0 ;
3136 void *argp1 = 0 ;
3137 int res1 = 0 ;
3138 int argvi = 0;
3139 size_t result;
3140 dXSARGS;
3141
3142 if ((items < 1) || (items > 1)) {
3143 SWIG_croak("Usage: gsl_interp_size_get(self);");
3144 }
3145 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
3146 if (!SWIG_IsOK(res1)) {
3147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_size_get" "', argument " "1"" of type '" "gsl_interp *""'");
3148 }
3149 arg1 = (gsl_interp *)(argp1);
3150 result = ((arg1)->size);
3151 ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1((size_t)(result)); argvi++ ;
3152
3153 XSRETURN(argvi);
3154 fail:
3155
3156 SWIG_croak_null();
3157 }
3158 }
3159
3160
XS(_wrap_gsl_interp_state_set)3161 XS(_wrap_gsl_interp_state_set) {
3162 {
3163 gsl_interp *arg1 = (gsl_interp *) 0 ;
3164 void *arg2 = (void *) 0 ;
3165 void *argp1 = 0 ;
3166 int res1 = 0 ;
3167 int res2 ;
3168 int argvi = 0;
3169 dXSARGS;
3170
3171 if ((items < 2) || (items > 2)) {
3172 SWIG_croak("Usage: gsl_interp_state_set(self,state);");
3173 }
3174 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
3175 if (!SWIG_IsOK(res1)) {
3176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_state_set" "', argument " "1"" of type '" "gsl_interp *""'");
3177 }
3178 arg1 = (gsl_interp *)(argp1);
3179 res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
3180 if (!SWIG_IsOK(res2)) {
3181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_interp_state_set" "', argument " "2"" of type '" "void *""'");
3182 }
3183 if (arg1) (arg1)->state = arg2;
3184 ST(argvi) = &PL_sv_undef;
3185
3186
3187 XSRETURN(argvi);
3188 fail:
3189
3190
3191 SWIG_croak_null();
3192 }
3193 }
3194
3195
XS(_wrap_gsl_interp_state_get)3196 XS(_wrap_gsl_interp_state_get) {
3197 {
3198 gsl_interp *arg1 = (gsl_interp *) 0 ;
3199 void *argp1 = 0 ;
3200 int res1 = 0 ;
3201 int argvi = 0;
3202 void *result = 0 ;
3203 dXSARGS;
3204
3205 if ((items < 1) || (items > 1)) {
3206 SWIG_croak("Usage: gsl_interp_state_get(self);");
3207 }
3208 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
3209 if (!SWIG_IsOK(res1)) {
3210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_state_get" "', argument " "1"" of type '" "gsl_interp *""'");
3211 }
3212 arg1 = (gsl_interp *)(argp1);
3213 result = (void *) ((arg1)->state);
3214 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
3215
3216 XSRETURN(argvi);
3217 fail:
3218
3219 SWIG_croak_null();
3220 }
3221 }
3222
3223
XS(_wrap_new_gsl_interp)3224 XS(_wrap_new_gsl_interp) {
3225 {
3226 int argvi = 0;
3227 gsl_interp *result = 0 ;
3228 dXSARGS;
3229
3230 if ((items < 0) || (items > 0)) {
3231 SWIG_croak("Usage: new_gsl_interp();");
3232 }
3233 result = (gsl_interp *)calloc(1, sizeof(gsl_interp));
3234 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gsl_interp, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
3235 XSRETURN(argvi);
3236 fail:
3237 SWIG_croak_null();
3238 }
3239 }
3240
3241
XS(_wrap_delete_gsl_interp)3242 XS(_wrap_delete_gsl_interp) {
3243 {
3244 gsl_interp *arg1 = (gsl_interp *) 0 ;
3245 void *argp1 = 0 ;
3246 int res1 = 0 ;
3247 int argvi = 0;
3248 dXSARGS;
3249
3250 if ((items < 1) || (items > 1)) {
3251 SWIG_croak("Usage: delete_gsl_interp(self);");
3252 }
3253 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, SWIG_POINTER_DISOWN | 0 );
3254 if (!SWIG_IsOK(res1)) {
3255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gsl_interp" "', argument " "1"" of type '" "gsl_interp *""'");
3256 }
3257 arg1 = (gsl_interp *)(argp1);
3258 free((char *) arg1);
3259 ST(argvi) = &PL_sv_undef;
3260
3261 XSRETURN(argvi);
3262 fail:
3263
3264 SWIG_croak_null();
3265 }
3266 }
3267
3268
XS(_wrap_gsl_interp_accel_alloc)3269 XS(_wrap_gsl_interp_accel_alloc) {
3270 {
3271 int argvi = 0;
3272 gsl_interp_accel *result = 0 ;
3273 dXSARGS;
3274
3275 if ((items < 0) || (items > 0)) {
3276 SWIG_croak("Usage: gsl_interp_accel_alloc();");
3277 }
3278 result = (gsl_interp_accel *)gsl_interp_accel_alloc();
3279 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gsl_interp_accel, 0 | SWIG_SHADOW); argvi++ ;
3280 XSRETURN(argvi);
3281 fail:
3282 SWIG_croak_null();
3283 }
3284 }
3285
3286
XS(_wrap_gsl_interp_accel_reset)3287 XS(_wrap_gsl_interp_accel_reset) {
3288 {
3289 gsl_interp_accel *arg1 = (gsl_interp_accel *) 0 ;
3290 void *argp1 = 0 ;
3291 int res1 = 0 ;
3292 int argvi = 0;
3293 int result;
3294 dXSARGS;
3295
3296 if ((items < 1) || (items > 1)) {
3297 SWIG_croak("Usage: gsl_interp_accel_reset(a);");
3298 }
3299 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
3300 if (!SWIG_IsOK(res1)) {
3301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_accel_reset" "', argument " "1"" of type '" "gsl_interp_accel *""'");
3302 }
3303 arg1 = (gsl_interp_accel *)(argp1);
3304 result = (int)gsl_interp_accel_reset(arg1);
3305 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3306
3307 XSRETURN(argvi);
3308 fail:
3309
3310 SWIG_croak_null();
3311 }
3312 }
3313
3314
XS(_wrap_gsl_interp_accel_free)3315 XS(_wrap_gsl_interp_accel_free) {
3316 {
3317 gsl_interp_accel *arg1 = (gsl_interp_accel *) 0 ;
3318 void *argp1 = 0 ;
3319 int res1 = 0 ;
3320 int argvi = 0;
3321 dXSARGS;
3322
3323 if ((items < 1) || (items > 1)) {
3324 SWIG_croak("Usage: gsl_interp_accel_free(a);");
3325 }
3326 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
3327 if (!SWIG_IsOK(res1)) {
3328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_accel_free" "', argument " "1"" of type '" "gsl_interp_accel *""'");
3329 }
3330 arg1 = (gsl_interp_accel *)(argp1);
3331 gsl_interp_accel_free(arg1);
3332 ST(argvi) = &PL_sv_undef;
3333
3334 XSRETURN(argvi);
3335 fail:
3336
3337 SWIG_croak_null();
3338 }
3339 }
3340
3341
XS(_wrap_gsl_interp_alloc)3342 XS(_wrap_gsl_interp_alloc) {
3343 {
3344 gsl_interp_type *arg1 = (gsl_interp_type *) 0 ;
3345 size_t arg2 ;
3346 void *argp1 = 0 ;
3347 int res1 = 0 ;
3348 size_t val2 ;
3349 int ecode2 = 0 ;
3350 int argvi = 0;
3351 gsl_interp *result = 0 ;
3352 dXSARGS;
3353
3354 if ((items < 2) || (items > 2)) {
3355 SWIG_croak("Usage: gsl_interp_alloc(T,n);");
3356 }
3357 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp_type, 0 | 0 );
3358 if (!SWIG_IsOK(res1)) {
3359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_alloc" "', argument " "1"" of type '" "gsl_interp_type const *""'");
3360 }
3361 arg1 = (gsl_interp_type *)(argp1);
3362 ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
3363 if (!SWIG_IsOK(ecode2)) {
3364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_interp_alloc" "', argument " "2"" of type '" "size_t""'");
3365 }
3366 arg2 = (size_t)(val2);
3367 result = (gsl_interp *)gsl_interp_alloc((gsl_interp_type const *)arg1,arg2);
3368 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gsl_interp, 0 | SWIG_SHADOW); argvi++ ;
3369
3370
3371 XSRETURN(argvi);
3372 fail:
3373
3374
3375 SWIG_croak_null();
3376 }
3377 }
3378
3379
XS(_wrap_gsl_interp_init)3380 XS(_wrap_gsl_interp_init) {
3381 {
3382 gsl_interp *arg1 = (gsl_interp *) 0 ;
3383 double *arg2 ;
3384 double *arg3 ;
3385 size_t arg4 ;
3386 void *argp1 = 0 ;
3387 int res1 = 0 ;
3388 size_t val4 ;
3389 int ecode4 = 0 ;
3390 int argvi = 0;
3391 int result;
3392 dXSARGS;
3393
3394 if ((items < 4) || (items > 4)) {
3395 SWIG_croak("Usage: gsl_interp_init(obj,xa,ya,size);");
3396 }
3397 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
3398 if (!SWIG_IsOK(res1)) {
3399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_init" "', argument " "1"" of type '" "gsl_interp *""'");
3400 }
3401 arg1 = (gsl_interp *)(argp1);
3402 {
3403 AV *tempav;
3404 I32 len;
3405 int i;
3406 SV **tv;
3407 if (!SvROK(ST(1)))
3408 croak("Math::GSL : $xa is not a reference!");
3409 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
3410 croak("Math::GSL : $xa is not an array ref!");
3411
3412 tempav = (AV*)SvRV(ST(1));
3413 len = av_len(tempav);
3414 arg2 = (double *) malloc((len+2)*sizeof(double));
3415 for (i = 0; i <= len; i++) {
3416 tv = av_fetch(tempav, i, 0);
3417 arg2[i] = (double) SvNV(*tv);
3418 }
3419 }
3420 {
3421 AV *tempav;
3422 I32 len;
3423 int i;
3424 SV **tv;
3425 if (!SvROK(ST(2)))
3426 croak("Math::GSL : $ya is not a reference!");
3427 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
3428 croak("Math::GSL : $ya is not an array ref!");
3429
3430 tempav = (AV*)SvRV(ST(2));
3431 len = av_len(tempav);
3432 arg3 = (double *) malloc((len+2)*sizeof(double));
3433 for (i = 0; i <= len; i++) {
3434 tv = av_fetch(tempav, i, 0);
3435 arg3[i] = (double) SvNV(*tv);
3436 }
3437 }
3438 ecode4 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
3439 if (!SWIG_IsOK(ecode4)) {
3440 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_interp_init" "', argument " "4"" of type '" "size_t""'");
3441 }
3442 arg4 = (size_t)(val4);
3443 result = (int)gsl_interp_init(arg1,(double const (*))arg2,(double const (*))arg3,arg4);
3444 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3445
3446 {
3447 if (arg2) free(arg2);
3448 }
3449 {
3450 if (arg3) free(arg3);
3451 }
3452
3453 XSRETURN(argvi);
3454 fail:
3455
3456 {
3457 if (arg2) free(arg2);
3458 }
3459 {
3460 if (arg3) free(arg3);
3461 }
3462
3463 SWIG_croak_null();
3464 }
3465 }
3466
3467
XS(_wrap_gsl_interp_name)3468 XS(_wrap_gsl_interp_name) {
3469 {
3470 gsl_interp *arg1 = (gsl_interp *) 0 ;
3471 void *argp1 = 0 ;
3472 int res1 = 0 ;
3473 int argvi = 0;
3474 char *result = 0 ;
3475 dXSARGS;
3476
3477 if ((items < 1) || (items > 1)) {
3478 SWIG_croak("Usage: gsl_interp_name(interp);");
3479 }
3480 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
3481 if (!SWIG_IsOK(res1)) {
3482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_name" "', argument " "1"" of type '" "gsl_interp const *""'");
3483 }
3484 arg1 = (gsl_interp *)(argp1);
3485 result = (char *)gsl_interp_name((gsl_interp const *)arg1);
3486 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3487
3488 XSRETURN(argvi);
3489 fail:
3490
3491 SWIG_croak_null();
3492 }
3493 }
3494
3495
XS(_wrap_gsl_interp_min_size)3496 XS(_wrap_gsl_interp_min_size) {
3497 {
3498 gsl_interp *arg1 = (gsl_interp *) 0 ;
3499 void *argp1 = 0 ;
3500 int res1 = 0 ;
3501 int argvi = 0;
3502 unsigned int result;
3503 dXSARGS;
3504
3505 if ((items < 1) || (items > 1)) {
3506 SWIG_croak("Usage: gsl_interp_min_size(interp);");
3507 }
3508 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
3509 if (!SWIG_IsOK(res1)) {
3510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_min_size" "', argument " "1"" of type '" "gsl_interp const *""'");
3511 }
3512 arg1 = (gsl_interp *)(argp1);
3513 result = (unsigned int)gsl_interp_min_size((gsl_interp const *)arg1);
3514 ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(result)); argvi++ ;
3515
3516 XSRETURN(argvi);
3517 fail:
3518
3519 SWIG_croak_null();
3520 }
3521 }
3522
3523
XS(_wrap_gsl_interp_type_min_size)3524 XS(_wrap_gsl_interp_type_min_size) {
3525 {
3526 gsl_interp_type *arg1 = (gsl_interp_type *) 0 ;
3527 void *argp1 = 0 ;
3528 int res1 = 0 ;
3529 int argvi = 0;
3530 unsigned int result;
3531 dXSARGS;
3532
3533 if ((items < 1) || (items > 1)) {
3534 SWIG_croak("Usage: gsl_interp_type_min_size(T);");
3535 }
3536 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp_type, 0 | 0 );
3537 if (!SWIG_IsOK(res1)) {
3538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_type_min_size" "', argument " "1"" of type '" "gsl_interp_type const *""'");
3539 }
3540 arg1 = (gsl_interp_type *)(argp1);
3541 result = (unsigned int)gsl_interp_type_min_size((gsl_interp_type const *)arg1);
3542 ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1((unsigned int)(result)); argvi++ ;
3543
3544 XSRETURN(argvi);
3545 fail:
3546
3547 SWIG_croak_null();
3548 }
3549 }
3550
3551
XS(_wrap_gsl_interp_eval_e)3552 XS(_wrap_gsl_interp_eval_e) {
3553 {
3554 gsl_interp *arg1 = (gsl_interp *) 0 ;
3555 double *arg2 ;
3556 double *arg3 ;
3557 double arg4 ;
3558 gsl_interp_accel *arg5 = (gsl_interp_accel *) 0 ;
3559 double *arg6 = (double *) 0 ;
3560 void *argp1 = 0 ;
3561 int res1 = 0 ;
3562 double val4 ;
3563 int ecode4 = 0 ;
3564 void *argp5 = 0 ;
3565 int res5 = 0 ;
3566 double temp6 ;
3567 int res6 = SWIG_TMPOBJ ;
3568 int argvi = 0;
3569 int result;
3570 dXSARGS;
3571
3572 arg6 = &temp6;
3573 if ((items < 5) || (items > 5)) {
3574 SWIG_croak("Usage: gsl_interp_eval_e(obj,xa,ya,x,a);");
3575 }
3576 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
3577 if (!SWIG_IsOK(res1)) {
3578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_eval_e" "', argument " "1"" of type '" "gsl_interp const *""'");
3579 }
3580 arg1 = (gsl_interp *)(argp1);
3581 {
3582 AV *tempav;
3583 I32 len;
3584 int i;
3585 SV **tv;
3586 if (!SvROK(ST(1)))
3587 croak("Math::GSL : $xa is not a reference!");
3588 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
3589 croak("Math::GSL : $xa is not an array ref!");
3590
3591 tempav = (AV*)SvRV(ST(1));
3592 len = av_len(tempav);
3593 arg2 = (double *) malloc((len+2)*sizeof(double));
3594 for (i = 0; i <= len; i++) {
3595 tv = av_fetch(tempav, i, 0);
3596 arg2[i] = (double) SvNV(*tv);
3597 }
3598 }
3599 {
3600 AV *tempav;
3601 I32 len;
3602 int i;
3603 SV **tv;
3604 if (!SvROK(ST(2)))
3605 croak("Math::GSL : $ya is not a reference!");
3606 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
3607 croak("Math::GSL : $ya is not an array ref!");
3608
3609 tempav = (AV*)SvRV(ST(2));
3610 len = av_len(tempav);
3611 arg3 = (double *) malloc((len+2)*sizeof(double));
3612 for (i = 0; i <= len; i++) {
3613 tv = av_fetch(tempav, i, 0);
3614 arg3[i] = (double) SvNV(*tv);
3615 }
3616 }
3617 ecode4 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
3618 if (!SWIG_IsOK(ecode4)) {
3619 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_interp_eval_e" "', argument " "4"" of type '" "double""'");
3620 }
3621 arg4 = (double)(val4);
3622 res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
3623 if (!SWIG_IsOK(res5)) {
3624 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gsl_interp_eval_e" "', argument " "5"" of type '" "gsl_interp_accel *""'");
3625 }
3626 arg5 = (gsl_interp_accel *)(argp5);
3627 result = (int)gsl_interp_eval_e((gsl_interp const *)arg1,(double const (*))arg2,(double const (*))arg3,arg4,arg5,arg6);
3628 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3629 if (SWIG_IsTmpObj(res6)) {
3630 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg6)); argvi++ ;
3631 } else {
3632 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0) : 0;
3633 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags); argvi++ ;
3634 }
3635
3636 {
3637 if (arg2) free(arg2);
3638 }
3639 {
3640 if (arg3) free(arg3);
3641 }
3642
3643
3644
3645 XSRETURN(argvi);
3646 fail:
3647
3648 {
3649 if (arg2) free(arg2);
3650 }
3651 {
3652 if (arg3) free(arg3);
3653 }
3654
3655
3656
3657 SWIG_croak_null();
3658 }
3659 }
3660
3661
XS(_wrap_gsl_interp_eval)3662 XS(_wrap_gsl_interp_eval) {
3663 {
3664 gsl_interp *arg1 = (gsl_interp *) 0 ;
3665 double *arg2 ;
3666 double *arg3 ;
3667 double arg4 ;
3668 gsl_interp_accel *arg5 = (gsl_interp_accel *) 0 ;
3669 void *argp1 = 0 ;
3670 int res1 = 0 ;
3671 double val4 ;
3672 int ecode4 = 0 ;
3673 void *argp5 = 0 ;
3674 int res5 = 0 ;
3675 int argvi = 0;
3676 double result;
3677 dXSARGS;
3678
3679 if ((items < 5) || (items > 5)) {
3680 SWIG_croak("Usage: gsl_interp_eval(obj,xa,ya,x,a);");
3681 }
3682 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
3683 if (!SWIG_IsOK(res1)) {
3684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_eval" "', argument " "1"" of type '" "gsl_interp const *""'");
3685 }
3686 arg1 = (gsl_interp *)(argp1);
3687 {
3688 AV *tempav;
3689 I32 len;
3690 int i;
3691 SV **tv;
3692 if (!SvROK(ST(1)))
3693 croak("Math::GSL : $xa is not a reference!");
3694 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
3695 croak("Math::GSL : $xa is not an array ref!");
3696
3697 tempav = (AV*)SvRV(ST(1));
3698 len = av_len(tempav);
3699 arg2 = (double *) malloc((len+2)*sizeof(double));
3700 for (i = 0; i <= len; i++) {
3701 tv = av_fetch(tempav, i, 0);
3702 arg2[i] = (double) SvNV(*tv);
3703 }
3704 }
3705 {
3706 AV *tempav;
3707 I32 len;
3708 int i;
3709 SV **tv;
3710 if (!SvROK(ST(2)))
3711 croak("Math::GSL : $ya is not a reference!");
3712 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
3713 croak("Math::GSL : $ya is not an array ref!");
3714
3715 tempav = (AV*)SvRV(ST(2));
3716 len = av_len(tempav);
3717 arg3 = (double *) malloc((len+2)*sizeof(double));
3718 for (i = 0; i <= len; i++) {
3719 tv = av_fetch(tempav, i, 0);
3720 arg3[i] = (double) SvNV(*tv);
3721 }
3722 }
3723 ecode4 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
3724 if (!SWIG_IsOK(ecode4)) {
3725 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_interp_eval" "', argument " "4"" of type '" "double""'");
3726 }
3727 arg4 = (double)(val4);
3728 res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
3729 if (!SWIG_IsOK(res5)) {
3730 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gsl_interp_eval" "', argument " "5"" of type '" "gsl_interp_accel *""'");
3731 }
3732 arg5 = (gsl_interp_accel *)(argp5);
3733 result = (double)gsl_interp_eval((gsl_interp const *)arg1,(double const (*))arg2,(double const (*))arg3,arg4,arg5);
3734 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3735
3736 {
3737 if (arg2) free(arg2);
3738 }
3739 {
3740 if (arg3) free(arg3);
3741 }
3742
3743
3744 XSRETURN(argvi);
3745 fail:
3746
3747 {
3748 if (arg2) free(arg2);
3749 }
3750 {
3751 if (arg3) free(arg3);
3752 }
3753
3754
3755 SWIG_croak_null();
3756 }
3757 }
3758
3759
XS(_wrap_gsl_interp_eval_deriv_e)3760 XS(_wrap_gsl_interp_eval_deriv_e) {
3761 {
3762 gsl_interp *arg1 = (gsl_interp *) 0 ;
3763 double *arg2 ;
3764 double *arg3 ;
3765 double arg4 ;
3766 gsl_interp_accel *arg5 = (gsl_interp_accel *) 0 ;
3767 double *arg6 = (double *) 0 ;
3768 void *argp1 = 0 ;
3769 int res1 = 0 ;
3770 double val4 ;
3771 int ecode4 = 0 ;
3772 void *argp5 = 0 ;
3773 int res5 = 0 ;
3774 double temp6 ;
3775 int res6 = SWIG_TMPOBJ ;
3776 int argvi = 0;
3777 int result;
3778 dXSARGS;
3779
3780 arg6 = &temp6;
3781 if ((items < 5) || (items > 5)) {
3782 SWIG_croak("Usage: gsl_interp_eval_deriv_e(obj,xa,ya,x,a);");
3783 }
3784 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
3785 if (!SWIG_IsOK(res1)) {
3786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_eval_deriv_e" "', argument " "1"" of type '" "gsl_interp const *""'");
3787 }
3788 arg1 = (gsl_interp *)(argp1);
3789 {
3790 AV *tempav;
3791 I32 len;
3792 int i;
3793 SV **tv;
3794 if (!SvROK(ST(1)))
3795 croak("Math::GSL : $xa is not a reference!");
3796 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
3797 croak("Math::GSL : $xa is not an array ref!");
3798
3799 tempav = (AV*)SvRV(ST(1));
3800 len = av_len(tempav);
3801 arg2 = (double *) malloc((len+2)*sizeof(double));
3802 for (i = 0; i <= len; i++) {
3803 tv = av_fetch(tempav, i, 0);
3804 arg2[i] = (double) SvNV(*tv);
3805 }
3806 }
3807 {
3808 AV *tempav;
3809 I32 len;
3810 int i;
3811 SV **tv;
3812 if (!SvROK(ST(2)))
3813 croak("Math::GSL : $ya is not a reference!");
3814 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
3815 croak("Math::GSL : $ya is not an array ref!");
3816
3817 tempav = (AV*)SvRV(ST(2));
3818 len = av_len(tempav);
3819 arg3 = (double *) malloc((len+2)*sizeof(double));
3820 for (i = 0; i <= len; i++) {
3821 tv = av_fetch(tempav, i, 0);
3822 arg3[i] = (double) SvNV(*tv);
3823 }
3824 }
3825 ecode4 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
3826 if (!SWIG_IsOK(ecode4)) {
3827 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_interp_eval_deriv_e" "', argument " "4"" of type '" "double""'");
3828 }
3829 arg4 = (double)(val4);
3830 res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
3831 if (!SWIG_IsOK(res5)) {
3832 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gsl_interp_eval_deriv_e" "', argument " "5"" of type '" "gsl_interp_accel *""'");
3833 }
3834 arg5 = (gsl_interp_accel *)(argp5);
3835 result = (int)gsl_interp_eval_deriv_e((gsl_interp const *)arg1,(double const (*))arg2,(double const (*))arg3,arg4,arg5,arg6);
3836 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3837 if (SWIG_IsTmpObj(res6)) {
3838 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg6)); argvi++ ;
3839 } else {
3840 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0) : 0;
3841 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags); argvi++ ;
3842 }
3843
3844 {
3845 if (arg2) free(arg2);
3846 }
3847 {
3848 if (arg3) free(arg3);
3849 }
3850
3851
3852
3853 XSRETURN(argvi);
3854 fail:
3855
3856 {
3857 if (arg2) free(arg2);
3858 }
3859 {
3860 if (arg3) free(arg3);
3861 }
3862
3863
3864
3865 SWIG_croak_null();
3866 }
3867 }
3868
3869
XS(_wrap_gsl_interp_eval_deriv)3870 XS(_wrap_gsl_interp_eval_deriv) {
3871 {
3872 gsl_interp *arg1 = (gsl_interp *) 0 ;
3873 double *arg2 ;
3874 double *arg3 ;
3875 double arg4 ;
3876 gsl_interp_accel *arg5 = (gsl_interp_accel *) 0 ;
3877 void *argp1 = 0 ;
3878 int res1 = 0 ;
3879 double val4 ;
3880 int ecode4 = 0 ;
3881 void *argp5 = 0 ;
3882 int res5 = 0 ;
3883 int argvi = 0;
3884 double result;
3885 dXSARGS;
3886
3887 if ((items < 5) || (items > 5)) {
3888 SWIG_croak("Usage: gsl_interp_eval_deriv(obj,xa,ya,x,a);");
3889 }
3890 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
3891 if (!SWIG_IsOK(res1)) {
3892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_eval_deriv" "', argument " "1"" of type '" "gsl_interp const *""'");
3893 }
3894 arg1 = (gsl_interp *)(argp1);
3895 {
3896 AV *tempav;
3897 I32 len;
3898 int i;
3899 SV **tv;
3900 if (!SvROK(ST(1)))
3901 croak("Math::GSL : $xa is not a reference!");
3902 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
3903 croak("Math::GSL : $xa is not an array ref!");
3904
3905 tempav = (AV*)SvRV(ST(1));
3906 len = av_len(tempav);
3907 arg2 = (double *) malloc((len+2)*sizeof(double));
3908 for (i = 0; i <= len; i++) {
3909 tv = av_fetch(tempav, i, 0);
3910 arg2[i] = (double) SvNV(*tv);
3911 }
3912 }
3913 {
3914 AV *tempav;
3915 I32 len;
3916 int i;
3917 SV **tv;
3918 if (!SvROK(ST(2)))
3919 croak("Math::GSL : $ya is not a reference!");
3920 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
3921 croak("Math::GSL : $ya is not an array ref!");
3922
3923 tempav = (AV*)SvRV(ST(2));
3924 len = av_len(tempav);
3925 arg3 = (double *) malloc((len+2)*sizeof(double));
3926 for (i = 0; i <= len; i++) {
3927 tv = av_fetch(tempav, i, 0);
3928 arg3[i] = (double) SvNV(*tv);
3929 }
3930 }
3931 ecode4 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
3932 if (!SWIG_IsOK(ecode4)) {
3933 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_interp_eval_deriv" "', argument " "4"" of type '" "double""'");
3934 }
3935 arg4 = (double)(val4);
3936 res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
3937 if (!SWIG_IsOK(res5)) {
3938 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gsl_interp_eval_deriv" "', argument " "5"" of type '" "gsl_interp_accel *""'");
3939 }
3940 arg5 = (gsl_interp_accel *)(argp5);
3941 result = (double)gsl_interp_eval_deriv((gsl_interp const *)arg1,(double const (*))arg2,(double const (*))arg3,arg4,arg5);
3942 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3943
3944 {
3945 if (arg2) free(arg2);
3946 }
3947 {
3948 if (arg3) free(arg3);
3949 }
3950
3951
3952 XSRETURN(argvi);
3953 fail:
3954
3955 {
3956 if (arg2) free(arg2);
3957 }
3958 {
3959 if (arg3) free(arg3);
3960 }
3961
3962
3963 SWIG_croak_null();
3964 }
3965 }
3966
3967
XS(_wrap_gsl_interp_eval_deriv2_e)3968 XS(_wrap_gsl_interp_eval_deriv2_e) {
3969 {
3970 gsl_interp *arg1 = (gsl_interp *) 0 ;
3971 double *arg2 ;
3972 double *arg3 ;
3973 double arg4 ;
3974 gsl_interp_accel *arg5 = (gsl_interp_accel *) 0 ;
3975 double *arg6 = (double *) 0 ;
3976 void *argp1 = 0 ;
3977 int res1 = 0 ;
3978 double val4 ;
3979 int ecode4 = 0 ;
3980 void *argp5 = 0 ;
3981 int res5 = 0 ;
3982 double temp6 ;
3983 int res6 = SWIG_TMPOBJ ;
3984 int argvi = 0;
3985 int result;
3986 dXSARGS;
3987
3988 arg6 = &temp6;
3989 if ((items < 5) || (items > 5)) {
3990 SWIG_croak("Usage: gsl_interp_eval_deriv2_e(obj,xa,ya,x,a);");
3991 }
3992 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
3993 if (!SWIG_IsOK(res1)) {
3994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_eval_deriv2_e" "', argument " "1"" of type '" "gsl_interp const *""'");
3995 }
3996 arg1 = (gsl_interp *)(argp1);
3997 {
3998 AV *tempav;
3999 I32 len;
4000 int i;
4001 SV **tv;
4002 if (!SvROK(ST(1)))
4003 croak("Math::GSL : $xa is not a reference!");
4004 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
4005 croak("Math::GSL : $xa is not an array ref!");
4006
4007 tempav = (AV*)SvRV(ST(1));
4008 len = av_len(tempav);
4009 arg2 = (double *) malloc((len+2)*sizeof(double));
4010 for (i = 0; i <= len; i++) {
4011 tv = av_fetch(tempav, i, 0);
4012 arg2[i] = (double) SvNV(*tv);
4013 }
4014 }
4015 {
4016 AV *tempav;
4017 I32 len;
4018 int i;
4019 SV **tv;
4020 if (!SvROK(ST(2)))
4021 croak("Math::GSL : $ya is not a reference!");
4022 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
4023 croak("Math::GSL : $ya is not an array ref!");
4024
4025 tempav = (AV*)SvRV(ST(2));
4026 len = av_len(tempav);
4027 arg3 = (double *) malloc((len+2)*sizeof(double));
4028 for (i = 0; i <= len; i++) {
4029 tv = av_fetch(tempav, i, 0);
4030 arg3[i] = (double) SvNV(*tv);
4031 }
4032 }
4033 ecode4 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
4034 if (!SWIG_IsOK(ecode4)) {
4035 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_interp_eval_deriv2_e" "', argument " "4"" of type '" "double""'");
4036 }
4037 arg4 = (double)(val4);
4038 res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
4039 if (!SWIG_IsOK(res5)) {
4040 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gsl_interp_eval_deriv2_e" "', argument " "5"" of type '" "gsl_interp_accel *""'");
4041 }
4042 arg5 = (gsl_interp_accel *)(argp5);
4043 result = (int)gsl_interp_eval_deriv2_e((gsl_interp const *)arg1,(double const (*))arg2,(double const (*))arg3,arg4,arg5,arg6);
4044 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
4045 if (SWIG_IsTmpObj(res6)) {
4046 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg6)); argvi++ ;
4047 } else {
4048 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0) : 0;
4049 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags); argvi++ ;
4050 }
4051
4052 {
4053 if (arg2) free(arg2);
4054 }
4055 {
4056 if (arg3) free(arg3);
4057 }
4058
4059
4060
4061 XSRETURN(argvi);
4062 fail:
4063
4064 {
4065 if (arg2) free(arg2);
4066 }
4067 {
4068 if (arg3) free(arg3);
4069 }
4070
4071
4072
4073 SWIG_croak_null();
4074 }
4075 }
4076
4077
XS(_wrap_gsl_interp_eval_deriv2)4078 XS(_wrap_gsl_interp_eval_deriv2) {
4079 {
4080 gsl_interp *arg1 = (gsl_interp *) 0 ;
4081 double *arg2 ;
4082 double *arg3 ;
4083 double arg4 ;
4084 gsl_interp_accel *arg5 = (gsl_interp_accel *) 0 ;
4085 void *argp1 = 0 ;
4086 int res1 = 0 ;
4087 double val4 ;
4088 int ecode4 = 0 ;
4089 void *argp5 = 0 ;
4090 int res5 = 0 ;
4091 int argvi = 0;
4092 double result;
4093 dXSARGS;
4094
4095 if ((items < 5) || (items > 5)) {
4096 SWIG_croak("Usage: gsl_interp_eval_deriv2(obj,xa,ya,x,a);");
4097 }
4098 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
4099 if (!SWIG_IsOK(res1)) {
4100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_eval_deriv2" "', argument " "1"" of type '" "gsl_interp const *""'");
4101 }
4102 arg1 = (gsl_interp *)(argp1);
4103 {
4104 AV *tempav;
4105 I32 len;
4106 int i;
4107 SV **tv;
4108 if (!SvROK(ST(1)))
4109 croak("Math::GSL : $xa is not a reference!");
4110 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
4111 croak("Math::GSL : $xa is not an array ref!");
4112
4113 tempav = (AV*)SvRV(ST(1));
4114 len = av_len(tempav);
4115 arg2 = (double *) malloc((len+2)*sizeof(double));
4116 for (i = 0; i <= len; i++) {
4117 tv = av_fetch(tempav, i, 0);
4118 arg2[i] = (double) SvNV(*tv);
4119 }
4120 }
4121 {
4122 AV *tempav;
4123 I32 len;
4124 int i;
4125 SV **tv;
4126 if (!SvROK(ST(2)))
4127 croak("Math::GSL : $ya is not a reference!");
4128 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
4129 croak("Math::GSL : $ya is not an array ref!");
4130
4131 tempav = (AV*)SvRV(ST(2));
4132 len = av_len(tempav);
4133 arg3 = (double *) malloc((len+2)*sizeof(double));
4134 for (i = 0; i <= len; i++) {
4135 tv = av_fetch(tempav, i, 0);
4136 arg3[i] = (double) SvNV(*tv);
4137 }
4138 }
4139 ecode4 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
4140 if (!SWIG_IsOK(ecode4)) {
4141 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_interp_eval_deriv2" "', argument " "4"" of type '" "double""'");
4142 }
4143 arg4 = (double)(val4);
4144 res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
4145 if (!SWIG_IsOK(res5)) {
4146 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gsl_interp_eval_deriv2" "', argument " "5"" of type '" "gsl_interp_accel *""'");
4147 }
4148 arg5 = (gsl_interp_accel *)(argp5);
4149 result = (double)gsl_interp_eval_deriv2((gsl_interp const *)arg1,(double const (*))arg2,(double const (*))arg3,arg4,arg5);
4150 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
4151
4152 {
4153 if (arg2) free(arg2);
4154 }
4155 {
4156 if (arg3) free(arg3);
4157 }
4158
4159
4160 XSRETURN(argvi);
4161 fail:
4162
4163 {
4164 if (arg2) free(arg2);
4165 }
4166 {
4167 if (arg3) free(arg3);
4168 }
4169
4170
4171 SWIG_croak_null();
4172 }
4173 }
4174
4175
XS(_wrap_gsl_interp_eval_integ_e)4176 XS(_wrap_gsl_interp_eval_integ_e) {
4177 {
4178 gsl_interp *arg1 = (gsl_interp *) 0 ;
4179 double *arg2 ;
4180 double *arg3 ;
4181 double arg4 ;
4182 double arg5 ;
4183 gsl_interp_accel *arg6 = (gsl_interp_accel *) 0 ;
4184 double *arg7 = (double *) 0 ;
4185 void *argp1 = 0 ;
4186 int res1 = 0 ;
4187 double val4 ;
4188 int ecode4 = 0 ;
4189 double val5 ;
4190 int ecode5 = 0 ;
4191 void *argp6 = 0 ;
4192 int res6 = 0 ;
4193 double temp7 ;
4194 int res7 = SWIG_TMPOBJ ;
4195 int argvi = 0;
4196 int result;
4197 dXSARGS;
4198
4199 arg7 = &temp7;
4200 if ((items < 6) || (items > 6)) {
4201 SWIG_croak("Usage: gsl_interp_eval_integ_e(obj,xa,ya,a,b,acc);");
4202 }
4203 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
4204 if (!SWIG_IsOK(res1)) {
4205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_eval_integ_e" "', argument " "1"" of type '" "gsl_interp const *""'");
4206 }
4207 arg1 = (gsl_interp *)(argp1);
4208 {
4209 AV *tempav;
4210 I32 len;
4211 int i;
4212 SV **tv;
4213 if (!SvROK(ST(1)))
4214 croak("Math::GSL : $xa is not a reference!");
4215 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
4216 croak("Math::GSL : $xa is not an array ref!");
4217
4218 tempav = (AV*)SvRV(ST(1));
4219 len = av_len(tempav);
4220 arg2 = (double *) malloc((len+2)*sizeof(double));
4221 for (i = 0; i <= len; i++) {
4222 tv = av_fetch(tempav, i, 0);
4223 arg2[i] = (double) SvNV(*tv);
4224 }
4225 }
4226 {
4227 AV *tempav;
4228 I32 len;
4229 int i;
4230 SV **tv;
4231 if (!SvROK(ST(2)))
4232 croak("Math::GSL : $ya is not a reference!");
4233 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
4234 croak("Math::GSL : $ya is not an array ref!");
4235
4236 tempav = (AV*)SvRV(ST(2));
4237 len = av_len(tempav);
4238 arg3 = (double *) malloc((len+2)*sizeof(double));
4239 for (i = 0; i <= len; i++) {
4240 tv = av_fetch(tempav, i, 0);
4241 arg3[i] = (double) SvNV(*tv);
4242 }
4243 }
4244 ecode4 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
4245 if (!SWIG_IsOK(ecode4)) {
4246 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_interp_eval_integ_e" "', argument " "4"" of type '" "double""'");
4247 }
4248 arg4 = (double)(val4);
4249 ecode5 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
4250 if (!SWIG_IsOK(ecode5)) {
4251 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gsl_interp_eval_integ_e" "', argument " "5"" of type '" "double""'");
4252 }
4253 arg5 = (double)(val5);
4254 res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
4255 if (!SWIG_IsOK(res6)) {
4256 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gsl_interp_eval_integ_e" "', argument " "6"" of type '" "gsl_interp_accel *""'");
4257 }
4258 arg6 = (gsl_interp_accel *)(argp6);
4259 result = (int)gsl_interp_eval_integ_e((gsl_interp const *)arg1,(double const (*))arg2,(double const (*))arg3,arg4,arg5,arg6,arg7);
4260 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
4261 if (SWIG_IsTmpObj(res7)) {
4262 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((*arg7)); argvi++ ;
4263 } else {
4264 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0) : 0;
4265 if (argvi >= items) EXTEND(sp, argvi+1); ST(argvi) = SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags); argvi++ ;
4266 }
4267
4268 {
4269 if (arg2) free(arg2);
4270 }
4271 {
4272 if (arg3) free(arg3);
4273 }
4274
4275
4276
4277
4278 XSRETURN(argvi);
4279 fail:
4280
4281 {
4282 if (arg2) free(arg2);
4283 }
4284 {
4285 if (arg3) free(arg3);
4286 }
4287
4288
4289
4290
4291 SWIG_croak_null();
4292 }
4293 }
4294
4295
XS(_wrap_gsl_interp_eval_integ)4296 XS(_wrap_gsl_interp_eval_integ) {
4297 {
4298 gsl_interp *arg1 = (gsl_interp *) 0 ;
4299 double *arg2 ;
4300 double *arg3 ;
4301 double arg4 ;
4302 double arg5 ;
4303 gsl_interp_accel *arg6 = (gsl_interp_accel *) 0 ;
4304 void *argp1 = 0 ;
4305 int res1 = 0 ;
4306 double val4 ;
4307 int ecode4 = 0 ;
4308 double val5 ;
4309 int ecode5 = 0 ;
4310 void *argp6 = 0 ;
4311 int res6 = 0 ;
4312 int argvi = 0;
4313 double result;
4314 dXSARGS;
4315
4316 if ((items < 6) || (items > 6)) {
4317 SWIG_croak("Usage: gsl_interp_eval_integ(obj,xa,ya,a,b,acc);");
4318 }
4319 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
4320 if (!SWIG_IsOK(res1)) {
4321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_eval_integ" "', argument " "1"" of type '" "gsl_interp const *""'");
4322 }
4323 arg1 = (gsl_interp *)(argp1);
4324 {
4325 AV *tempav;
4326 I32 len;
4327 int i;
4328 SV **tv;
4329 if (!SvROK(ST(1)))
4330 croak("Math::GSL : $xa is not a reference!");
4331 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
4332 croak("Math::GSL : $xa is not an array ref!");
4333
4334 tempav = (AV*)SvRV(ST(1));
4335 len = av_len(tempav);
4336 arg2 = (double *) malloc((len+2)*sizeof(double));
4337 for (i = 0; i <= len; i++) {
4338 tv = av_fetch(tempav, i, 0);
4339 arg2[i] = (double) SvNV(*tv);
4340 }
4341 }
4342 {
4343 AV *tempav;
4344 I32 len;
4345 int i;
4346 SV **tv;
4347 if (!SvROK(ST(2)))
4348 croak("Math::GSL : $ya is not a reference!");
4349 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
4350 croak("Math::GSL : $ya is not an array ref!");
4351
4352 tempav = (AV*)SvRV(ST(2));
4353 len = av_len(tempav);
4354 arg3 = (double *) malloc((len+2)*sizeof(double));
4355 for (i = 0; i <= len; i++) {
4356 tv = av_fetch(tempav, i, 0);
4357 arg3[i] = (double) SvNV(*tv);
4358 }
4359 }
4360 ecode4 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
4361 if (!SWIG_IsOK(ecode4)) {
4362 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_interp_eval_integ" "', argument " "4"" of type '" "double""'");
4363 }
4364 arg4 = (double)(val4);
4365 ecode5 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
4366 if (!SWIG_IsOK(ecode5)) {
4367 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gsl_interp_eval_integ" "', argument " "5"" of type '" "double""'");
4368 }
4369 arg5 = (double)(val5);
4370 res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
4371 if (!SWIG_IsOK(res6)) {
4372 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gsl_interp_eval_integ" "', argument " "6"" of type '" "gsl_interp_accel *""'");
4373 }
4374 arg6 = (gsl_interp_accel *)(argp6);
4375 result = (double)gsl_interp_eval_integ((gsl_interp const *)arg1,(double const (*))arg2,(double const (*))arg3,arg4,arg5,arg6);
4376 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
4377
4378 {
4379 if (arg2) free(arg2);
4380 }
4381 {
4382 if (arg3) free(arg3);
4383 }
4384
4385
4386
4387 XSRETURN(argvi);
4388 fail:
4389
4390 {
4391 if (arg2) free(arg2);
4392 }
4393 {
4394 if (arg3) free(arg3);
4395 }
4396
4397
4398
4399 SWIG_croak_null();
4400 }
4401 }
4402
4403
XS(_wrap_gsl_interp_free)4404 XS(_wrap_gsl_interp_free) {
4405 {
4406 gsl_interp *arg1 = (gsl_interp *) 0 ;
4407 void *argp1 = 0 ;
4408 int res1 = 0 ;
4409 int argvi = 0;
4410 dXSARGS;
4411
4412 if ((items < 1) || (items > 1)) {
4413 SWIG_croak("Usage: gsl_interp_free(interp);");
4414 }
4415 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp, 0 | 0 );
4416 if (!SWIG_IsOK(res1)) {
4417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_free" "', argument " "1"" of type '" "gsl_interp *""'");
4418 }
4419 arg1 = (gsl_interp *)(argp1);
4420 gsl_interp_free(arg1);
4421 ST(argvi) = &PL_sv_undef;
4422
4423 XSRETURN(argvi);
4424 fail:
4425
4426 SWIG_croak_null();
4427 }
4428 }
4429
4430
XS(_wrap_gsl_interp_bsearch)4431 XS(_wrap_gsl_interp_bsearch) {
4432 {
4433 double *arg1 ;
4434 double arg2 ;
4435 size_t arg3 ;
4436 size_t arg4 ;
4437 double val2 ;
4438 int ecode2 = 0 ;
4439 size_t val3 ;
4440 int ecode3 = 0 ;
4441 size_t val4 ;
4442 int ecode4 = 0 ;
4443 int argvi = 0;
4444 size_t result;
4445 dXSARGS;
4446
4447 if ((items < 4) || (items > 4)) {
4448 SWIG_croak("Usage: gsl_interp_bsearch(x_array,x,index_lo,index_hi);");
4449 }
4450 {
4451 AV *tempav;
4452 I32 len;
4453 int i;
4454 SV **tv;
4455 if (!SvROK(ST(0)))
4456 croak("Math::GSL : $x_array is not a reference!");
4457 if (SvTYPE(SvRV(ST(0))) != SVt_PVAV)
4458 croak("Math::GSL : $x_array is not an array ref!");
4459
4460 tempav = (AV*)SvRV(ST(0));
4461 len = av_len(tempav);
4462 arg1 = (double *) malloc((len+2)*sizeof(double));
4463 for (i = 0; i <= len; i++) {
4464 tv = av_fetch(tempav, i, 0);
4465 arg1[i] = (double) SvNV(*tv);
4466 }
4467 }
4468 ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
4469 if (!SWIG_IsOK(ecode2)) {
4470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_interp_bsearch" "', argument " "2"" of type '" "double""'");
4471 }
4472 arg2 = (double)(val2);
4473 ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
4474 if (!SWIG_IsOK(ecode3)) {
4475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_interp_bsearch" "', argument " "3"" of type '" "size_t""'");
4476 }
4477 arg3 = (size_t)(val3);
4478 ecode4 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
4479 if (!SWIG_IsOK(ecode4)) {
4480 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_interp_bsearch" "', argument " "4"" of type '" "size_t""'");
4481 }
4482 arg4 = (size_t)(val4);
4483 result = gsl_interp_bsearch((double const (*))arg1,arg2,arg3,arg4);
4484 ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1((size_t)(result)); argvi++ ;
4485 {
4486 if (arg1) free(arg1);
4487 }
4488
4489
4490
4491 XSRETURN(argvi);
4492 fail:
4493 {
4494 if (arg1) free(arg1);
4495 }
4496
4497
4498
4499 SWIG_croak_null();
4500 }
4501 }
4502
4503
XS(_wrap_gsl_interp_accel_find)4504 XS(_wrap_gsl_interp_accel_find) {
4505 {
4506 gsl_interp_accel *arg1 = (gsl_interp_accel *) 0 ;
4507 double *arg2 ;
4508 size_t arg3 ;
4509 double arg4 ;
4510 void *argp1 = 0 ;
4511 int res1 = 0 ;
4512 size_t val3 ;
4513 int ecode3 = 0 ;
4514 double val4 ;
4515 int ecode4 = 0 ;
4516 int argvi = 0;
4517 size_t result;
4518 dXSARGS;
4519
4520 if ((items < 4) || (items > 4)) {
4521 SWIG_croak("Usage: gsl_interp_accel_find(a,x_array,size,x);");
4522 }
4523 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_interp_accel, 0 | 0 );
4524 if (!SWIG_IsOK(res1)) {
4525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_interp_accel_find" "', argument " "1"" of type '" "gsl_interp_accel *""'");
4526 }
4527 arg1 = (gsl_interp_accel *)(argp1);
4528 {
4529 AV *tempav;
4530 I32 len;
4531 int i;
4532 SV **tv;
4533 if (!SvROK(ST(1)))
4534 croak("Math::GSL : $x_array is not a reference!");
4535 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
4536 croak("Math::GSL : $x_array is not an array ref!");
4537
4538 tempav = (AV*)SvRV(ST(1));
4539 len = av_len(tempav);
4540 arg2 = (double *) malloc((len+2)*sizeof(double));
4541 for (i = 0; i <= len; i++) {
4542 tv = av_fetch(tempav, i, 0);
4543 arg2[i] = (double) SvNV(*tv);
4544 }
4545 }
4546 ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
4547 if (!SWIG_IsOK(ecode3)) {
4548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_interp_accel_find" "', argument " "3"" of type '" "size_t""'");
4549 }
4550 arg3 = (size_t)(val3);
4551 ecode4 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
4552 if (!SWIG_IsOK(ecode4)) {
4553 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_interp_accel_find" "', argument " "4"" of type '" "double""'");
4554 }
4555 arg4 = (double)(val4);
4556 result = gsl_interp_accel_find(arg1,(double const (*))arg2,arg3,arg4);
4557 ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1((size_t)(result)); argvi++ ;
4558
4559 {
4560 if (arg2) free(arg2);
4561 }
4562
4563
4564 XSRETURN(argvi);
4565 fail:
4566
4567 {
4568 if (arg2) free(arg2);
4569 }
4570
4571
4572 SWIG_croak_null();
4573 }
4574 }
4575
4576
4577
4578 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
4579
4580 static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
4581 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
4582 static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
4583 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};
4584 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};
4585 static swig_type_info _swigt__p_gsl_interp = {"_p_gsl_interp", "gsl_interp *", 0, 0, (void*)"Math::GSL::Interp::gsl_interp", 0};
4586 static swig_type_info _swigt__p_gsl_interp_accel = {"_p_gsl_interp_accel", "gsl_interp_accel *", 0, 0, (void*)"Math::GSL::Interp::gsl_interp_accel", 0};
4587 static swig_type_info _swigt__p_gsl_interp_type = {"_p_gsl_interp_type", "gsl_interp_type *", 0, 0, (void*)0, 0};
4588 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
4589
4590 static swig_type_info *swig_type_initial[] = {
4591 &_swigt__p_FILE,
4592 &_swigt__p_char,
4593 &_swigt__p_double,
4594 &_swigt__p_f_p_q_const__char_p_q_const__char_int_int__void,
4595 &_swigt__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void,
4596 &_swigt__p_gsl_interp,
4597 &_swigt__p_gsl_interp_accel,
4598 &_swigt__p_gsl_interp_type,
4599 &_swigt__p_void,
4600 };
4601
4602 static swig_cast_info _swigc__p_FILE[] = { {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
4603 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
4604 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
4605 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}};
4606 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}};
4607 static swig_cast_info _swigc__p_gsl_interp[] = { {&_swigt__p_gsl_interp, 0, 0, 0},{0, 0, 0, 0}};
4608 static swig_cast_info _swigc__p_gsl_interp_accel[] = { {&_swigt__p_gsl_interp_accel, 0, 0, 0},{0, 0, 0, 0}};
4609 static swig_cast_info _swigc__p_gsl_interp_type[] = { {&_swigt__p_gsl_interp_type, 0, 0, 0},{0, 0, 0, 0}};
4610 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
4611
4612 static swig_cast_info *swig_cast_initial[] = {
4613 _swigc__p_FILE,
4614 _swigc__p_char,
4615 _swigc__p_double,
4616 _swigc__p_f_p_q_const__char_p_q_const__char_int_int__void,
4617 _swigc__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void,
4618 _swigc__p_gsl_interp,
4619 _swigc__p_gsl_interp_accel,
4620 _swigc__p_gsl_interp_type,
4621 _swigc__p_void,
4622 };
4623
4624
4625 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
4626
4627 static swig_constant_info swig_constants[] = {
4628 {0,0,0,0,0,0}
4629 };
4630 #ifdef __cplusplus
4631 }
4632 #endif
4633 static swig_variable_info swig_variables[] = {
4634 { "Math::GSL::Interpc::gsl_interp_linear", MAGIC_CLASS _wrap_gsl_interp_linear_set, MAGIC_CLASS _wrap_gsl_interp_linear_get,&SWIGTYPE_p_gsl_interp_type },
4635 { "Math::GSL::Interpc::gsl_interp_polynomial", MAGIC_CLASS _wrap_gsl_interp_polynomial_set, MAGIC_CLASS _wrap_gsl_interp_polynomial_get,&SWIGTYPE_p_gsl_interp_type },
4636 { "Math::GSL::Interpc::gsl_interp_cspline", MAGIC_CLASS _wrap_gsl_interp_cspline_set, MAGIC_CLASS _wrap_gsl_interp_cspline_get,&SWIGTYPE_p_gsl_interp_type },
4637 { "Math::GSL::Interpc::gsl_interp_cspline_periodic", MAGIC_CLASS _wrap_gsl_interp_cspline_periodic_set, MAGIC_CLASS _wrap_gsl_interp_cspline_periodic_get,&SWIGTYPE_p_gsl_interp_type },
4638 { "Math::GSL::Interpc::gsl_interp_akima", MAGIC_CLASS _wrap_gsl_interp_akima_set, MAGIC_CLASS _wrap_gsl_interp_akima_get,&SWIGTYPE_p_gsl_interp_type },
4639 { "Math::GSL::Interpc::gsl_interp_akima_periodic", MAGIC_CLASS _wrap_gsl_interp_akima_periodic_set, MAGIC_CLASS _wrap_gsl_interp_akima_periodic_get,&SWIGTYPE_p_gsl_interp_type },
4640 {0,0,0,0}
4641 };
4642 static swig_command_info swig_commands[] = {
4643 {"Math::GSL::Interpc::gsl_error", _wrap_gsl_error},
4644 {"Math::GSL::Interpc::gsl_stream_printf", _wrap_gsl_stream_printf},
4645 {"Math::GSL::Interpc::gsl_strerror", _wrap_gsl_strerror},
4646 {"Math::GSL::Interpc::gsl_set_error_handler", _wrap_gsl_set_error_handler},
4647 {"Math::GSL::Interpc::gsl_set_error_handler_off", _wrap_gsl_set_error_handler_off},
4648 {"Math::GSL::Interpc::gsl_set_stream_handler", _wrap_gsl_set_stream_handler},
4649 {"Math::GSL::Interpc::gsl_set_stream", _wrap_gsl_set_stream},
4650 {"Math::GSL::Interpc::gsl_interp_accel_cache_set", _wrap_gsl_interp_accel_cache_set},
4651 {"Math::GSL::Interpc::gsl_interp_accel_cache_get", _wrap_gsl_interp_accel_cache_get},
4652 {"Math::GSL::Interpc::gsl_interp_accel_miss_count_set", _wrap_gsl_interp_accel_miss_count_set},
4653 {"Math::GSL::Interpc::gsl_interp_accel_miss_count_get", _wrap_gsl_interp_accel_miss_count_get},
4654 {"Math::GSL::Interpc::gsl_interp_accel_hit_count_set", _wrap_gsl_interp_accel_hit_count_set},
4655 {"Math::GSL::Interpc::gsl_interp_accel_hit_count_get", _wrap_gsl_interp_accel_hit_count_get},
4656 {"Math::GSL::Interpc::new_gsl_interp_accel", _wrap_new_gsl_interp_accel},
4657 {"Math::GSL::Interpc::delete_gsl_interp_accel", _wrap_delete_gsl_interp_accel},
4658 {"Math::GSL::Interpc::gsl_interp_type_set", _wrap_gsl_interp_type_set},
4659 {"Math::GSL::Interpc::gsl_interp_type_get", _wrap_gsl_interp_type_get},
4660 {"Math::GSL::Interpc::gsl_interp_xmin_set", _wrap_gsl_interp_xmin_set},
4661 {"Math::GSL::Interpc::gsl_interp_xmin_get", _wrap_gsl_interp_xmin_get},
4662 {"Math::GSL::Interpc::gsl_interp_xmax_set", _wrap_gsl_interp_xmax_set},
4663 {"Math::GSL::Interpc::gsl_interp_xmax_get", _wrap_gsl_interp_xmax_get},
4664 {"Math::GSL::Interpc::gsl_interp_size_set", _wrap_gsl_interp_size_set},
4665 {"Math::GSL::Interpc::gsl_interp_size_get", _wrap_gsl_interp_size_get},
4666 {"Math::GSL::Interpc::gsl_interp_state_set", _wrap_gsl_interp_state_set},
4667 {"Math::GSL::Interpc::gsl_interp_state_get", _wrap_gsl_interp_state_get},
4668 {"Math::GSL::Interpc::new_gsl_interp", _wrap_new_gsl_interp},
4669 {"Math::GSL::Interpc::delete_gsl_interp", _wrap_delete_gsl_interp},
4670 {"Math::GSL::Interpc::gsl_interp_accel_alloc", _wrap_gsl_interp_accel_alloc},
4671 {"Math::GSL::Interpc::gsl_interp_accel_reset", _wrap_gsl_interp_accel_reset},
4672 {"Math::GSL::Interpc::gsl_interp_accel_free", _wrap_gsl_interp_accel_free},
4673 {"Math::GSL::Interpc::gsl_interp_alloc", _wrap_gsl_interp_alloc},
4674 {"Math::GSL::Interpc::gsl_interp_init", _wrap_gsl_interp_init},
4675 {"Math::GSL::Interpc::gsl_interp_name", _wrap_gsl_interp_name},
4676 {"Math::GSL::Interpc::gsl_interp_min_size", _wrap_gsl_interp_min_size},
4677 {"Math::GSL::Interpc::gsl_interp_type_min_size", _wrap_gsl_interp_type_min_size},
4678 {"Math::GSL::Interpc::gsl_interp_eval_e", _wrap_gsl_interp_eval_e},
4679 {"Math::GSL::Interpc::gsl_interp_eval", _wrap_gsl_interp_eval},
4680 {"Math::GSL::Interpc::gsl_interp_eval_deriv_e", _wrap_gsl_interp_eval_deriv_e},
4681 {"Math::GSL::Interpc::gsl_interp_eval_deriv", _wrap_gsl_interp_eval_deriv},
4682 {"Math::GSL::Interpc::gsl_interp_eval_deriv2_e", _wrap_gsl_interp_eval_deriv2_e},
4683 {"Math::GSL::Interpc::gsl_interp_eval_deriv2", _wrap_gsl_interp_eval_deriv2},
4684 {"Math::GSL::Interpc::gsl_interp_eval_integ_e", _wrap_gsl_interp_eval_integ_e},
4685 {"Math::GSL::Interpc::gsl_interp_eval_integ", _wrap_gsl_interp_eval_integ},
4686 {"Math::GSL::Interpc::gsl_interp_free", _wrap_gsl_interp_free},
4687 {"Math::GSL::Interpc::gsl_interp_bsearch", _wrap_gsl_interp_bsearch},
4688 {"Math::GSL::Interpc::gsl_interp_accel_find", _wrap_gsl_interp_accel_find},
4689 {0,0}
4690 };
4691 /* -----------------------------------------------------------------------------
4692 * Type initialization:
4693 * This problem is tough by the requirement that no dynamic
4694 * memory is used. Also, since swig_type_info structures store pointers to
4695 * swig_cast_info structures and swig_cast_info structures store pointers back
4696 * to swig_type_info structures, we need some lookup code at initialization.
4697 * The idea is that swig generates all the structures that are needed.
4698 * The runtime then collects these partially filled structures.
4699 * The SWIG_InitializeModule function takes these initial arrays out of
4700 * swig_module, and does all the lookup, filling in the swig_module.types
4701 * array with the correct data and linking the correct swig_cast_info
4702 * structures together.
4703 *
4704 * The generated swig_type_info structures are assigned statically to an initial
4705 * array. We just loop through that array, and handle each type individually.
4706 * First we lookup if this type has been already loaded, and if so, use the
4707 * loaded structure instead of the generated one. Then we have to fill in the
4708 * cast linked list. The cast data is initially stored in something like a
4709 * two-dimensional array. Each row corresponds to a type (there are the same
4710 * number of rows as there are in the swig_type_initial array). Each entry in
4711 * a column is one of the swig_cast_info structures for that type.
4712 * The cast_initial array is actually an array of arrays, because each row has
4713 * a variable number of columns. So to actually build the cast linked list,
4714 * we find the array of casts associated with the type, and loop through it
4715 * adding the casts to the list. The one last trick we need to do is making
4716 * sure the type pointer in the swig_cast_info struct is correct.
4717 *
4718 * First off, we lookup the cast->type name to see if it is already loaded.
4719 * There are three cases to handle:
4720 * 1) If the cast->type has already been loaded AND the type we are adding
4721 * casting info to has not been loaded (it is in this module), THEN we
4722 * replace the cast->type pointer with the type pointer that has already
4723 * been loaded.
4724 * 2) If BOTH types (the one we are adding casting info to, and the
4725 * cast->type) are loaded, THEN the cast info has already been loaded by
4726 * the previous module so we just ignore it.
4727 * 3) Finally, if cast->type has not already been loaded, then we add that
4728 * swig_cast_info to the linked list (because the cast->type) pointer will
4729 * be correct.
4730 * ----------------------------------------------------------------------------- */
4731
4732 #ifdef __cplusplus
4733 extern "C" {
4734 #if 0
4735 } /* c-mode */
4736 #endif
4737 #endif
4738
4739 #if 0
4740 #define SWIGRUNTIME_DEBUG
4741 #endif
4742
4743
4744 SWIGRUNTIME void
SWIG_InitializeModule(void * clientdata)4745 SWIG_InitializeModule(void *clientdata) {
4746 size_t i;
4747 swig_module_info *module_head, *iter;
4748 int init;
4749
4750 /* check to see if the circular list has been setup, if not, set it up */
4751 if (swig_module.next==0) {
4752 /* Initialize the swig_module */
4753 swig_module.type_initial = swig_type_initial;
4754 swig_module.cast_initial = swig_cast_initial;
4755 swig_module.next = &swig_module;
4756 init = 1;
4757 } else {
4758 init = 0;
4759 }
4760
4761 /* Try and load any already created modules */
4762 module_head = SWIG_GetModule(clientdata);
4763 if (!module_head) {
4764 /* This is the first module loaded for this interpreter */
4765 /* so set the swig module into the interpreter */
4766 SWIG_SetModule(clientdata, &swig_module);
4767 } else {
4768 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
4769 iter=module_head;
4770 do {
4771 if (iter==&swig_module) {
4772 /* Our module is already in the list, so there's nothing more to do. */
4773 return;
4774 }
4775 iter=iter->next;
4776 } while (iter!= module_head);
4777
4778 /* otherwise we must add our module into the list */
4779 swig_module.next = module_head->next;
4780 module_head->next = &swig_module;
4781 }
4782
4783 /* When multiple interpreters are used, a module could have already been initialized in
4784 a different interpreter, but not yet have a pointer in this interpreter.
4785 In this case, we do not want to continue adding types... everything should be
4786 set up already */
4787 if (init == 0) return;
4788
4789 /* Now work on filling in swig_module.types */
4790 #ifdef SWIGRUNTIME_DEBUG
4791 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
4792 #endif
4793 for (i = 0; i < swig_module.size; ++i) {
4794 swig_type_info *type = 0;
4795 swig_type_info *ret;
4796 swig_cast_info *cast;
4797
4798 #ifdef SWIGRUNTIME_DEBUG
4799 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
4800 #endif
4801
4802 /* if there is another module already loaded */
4803 if (swig_module.next != &swig_module) {
4804 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
4805 }
4806 if (type) {
4807 /* Overwrite clientdata field */
4808 #ifdef SWIGRUNTIME_DEBUG
4809 printf("SWIG_InitializeModule: found type %s\n", type->name);
4810 #endif
4811 if (swig_module.type_initial[i]->clientdata) {
4812 type->clientdata = swig_module.type_initial[i]->clientdata;
4813 #ifdef SWIGRUNTIME_DEBUG
4814 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
4815 #endif
4816 }
4817 } else {
4818 type = swig_module.type_initial[i];
4819 }
4820
4821 /* Insert casting types */
4822 cast = swig_module.cast_initial[i];
4823 while (cast->type) {
4824 /* Don't need to add information already in the list */
4825 ret = 0;
4826 #ifdef SWIGRUNTIME_DEBUG
4827 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
4828 #endif
4829 if (swig_module.next != &swig_module) {
4830 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
4831 #ifdef SWIGRUNTIME_DEBUG
4832 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
4833 #endif
4834 }
4835 if (ret) {
4836 if (type == swig_module.type_initial[i]) {
4837 #ifdef SWIGRUNTIME_DEBUG
4838 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
4839 #endif
4840 cast->type = ret;
4841 ret = 0;
4842 } else {
4843 /* Check for casting already in the list */
4844 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
4845 #ifdef SWIGRUNTIME_DEBUG
4846 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
4847 #endif
4848 if (!ocast) ret = 0;
4849 }
4850 }
4851
4852 if (!ret) {
4853 #ifdef SWIGRUNTIME_DEBUG
4854 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
4855 #endif
4856 if (type->cast) {
4857 type->cast->prev = cast;
4858 cast->next = type->cast;
4859 }
4860 type->cast = cast;
4861 }
4862 cast++;
4863 }
4864 /* Set entry in modules->types array equal to the type */
4865 swig_module.types[i] = type;
4866 }
4867 swig_module.types[i] = 0;
4868
4869 #ifdef SWIGRUNTIME_DEBUG
4870 printf("**** SWIG_InitializeModule: Cast List ******\n");
4871 for (i = 0; i < swig_module.size; ++i) {
4872 int j = 0;
4873 swig_cast_info *cast = swig_module.cast_initial[i];
4874 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
4875 while (cast->type) {
4876 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
4877 cast++;
4878 ++j;
4879 }
4880 printf("---- Total casts: %d\n",j);
4881 }
4882 printf("**** SWIG_InitializeModule: Cast List ******\n");
4883 #endif
4884 }
4885
4886 /* This function will propagate the clientdata field of type to
4887 * any new swig_type_info structures that have been added into the list
4888 * of equivalent types. It is like calling
4889 * SWIG_TypeClientData(type, clientdata) a second time.
4890 */
4891 SWIGRUNTIME void
SWIG_PropagateClientData(void)4892 SWIG_PropagateClientData(void) {
4893 size_t i;
4894 swig_cast_info *equiv;
4895 static int init_run = 0;
4896
4897 if (init_run) return;
4898 init_run = 1;
4899
4900 for (i = 0; i < swig_module.size; i++) {
4901 if (swig_module.types[i]->clientdata) {
4902 equiv = swig_module.types[i]->cast;
4903 while (equiv) {
4904 if (!equiv->converter) {
4905 if (equiv->type && !equiv->type->clientdata)
4906 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
4907 }
4908 equiv = equiv->next;
4909 }
4910 }
4911 }
4912 }
4913
4914 #ifdef __cplusplus
4915 #if 0
4916 {
4917 /* c-mode */
4918 #endif
4919 }
4920 #endif
4921
4922
4923
4924 #if defined(__cplusplus) && ! defined(XSPROTO)
4925 extern "C"
4926 #endif
4927
XS(SWIG_init)4928 XS(SWIG_init) {
4929 dXSARGS;
4930 int i;
4931 (void)items;
4932
4933 SWIG_InitializeModule(0);
4934
4935 /* Install commands */
4936 for (i = 0; swig_commands[i].name; i++) {
4937 /* Casts only needed for Perl < 5.10. */
4938 #ifdef __cplusplus
4939 newXS(const_cast<char*>(swig_commands[i].name), swig_commands[i].wrapper, const_cast<char*>(__FILE__));
4940 #else
4941 newXS((char*)swig_commands[i].name, swig_commands[i].wrapper, (char*)__FILE__);
4942 #endif
4943 }
4944
4945 /* Install variables */
4946 for (i = 0; swig_variables[i].name; i++) {
4947 SV *sv;
4948 sv = get_sv(swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
4949 if (swig_variables[i].type) {
4950 SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
4951 } else {
4952 sv_setiv(sv,(IV) 0);
4953 }
4954 swig_create_magic(sv, swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
4955 }
4956
4957 /* Install constant */
4958 for (i = 0; swig_constants[i].type; i++) {
4959 SV *sv;
4960 sv = get_sv(swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
4961 switch(swig_constants[i].type) {
4962 case SWIG_INT:
4963 sv_setiv(sv, (IV) swig_constants[i].lvalue);
4964 break;
4965 case SWIG_FLOAT:
4966 sv_setnv(sv, (double) swig_constants[i].dvalue);
4967 break;
4968 case SWIG_STRING:
4969 sv_setpv(sv, (const char *) swig_constants[i].pvalue);
4970 break;
4971 case SWIG_POINTER:
4972 SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
4973 break;
4974 case SWIG_BINARY:
4975 SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
4976 break;
4977 default:
4978 break;
4979 }
4980 SvREADONLY_on(sv);
4981 }
4982
4983 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4984 SV *sv = get_sv((char*) SWIG_prefix "GSL_VERSION", TRUE | 0x2 | GV_ADDMULTI);
4985 sv_setsv(sv, SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(2.7)));
4986 SvREADONLY_on(sv);
4987 } while(0) /*@SWIG@*/;
4988 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4989 SV *sv = get_sv((char*) SWIG_prefix "GSL_MAJOR_VERSION", TRUE | 0x2 | GV_ADDMULTI);
4990 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(2)));
4991 SvREADONLY_on(sv);
4992 } while(0) /*@SWIG@*/;
4993 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4994 SV *sv = get_sv((char*) SWIG_prefix "GSL_MINOR_VERSION", TRUE | 0x2 | GV_ADDMULTI);
4995 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(7)));
4996 SvREADONLY_on(sv);
4997 } while(0) /*@SWIG@*/;
4998 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4999 SV *sv = get_sv((char*) SWIG_prefix "GSL_POSZERO", TRUE | 0x2 | GV_ADDMULTI);
5000 sv_setsv(sv, SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)((+0.0))));
5001 SvREADONLY_on(sv);
5002 } while(0) /*@SWIG@*/;
5003 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5004 SV *sv = get_sv((char*) SWIG_prefix "GSL_NEGZERO", TRUE | 0x2 | GV_ADDMULTI);
5005 sv_setsv(sv, SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)((-0.0))));
5006 SvREADONLY_on(sv);
5007 } while(0) /*@SWIG@*/;
5008 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5009 SV *sv = get_sv((char*) SWIG_prefix "GSL_SUCCESS", TRUE | 0x2 | GV_ADDMULTI);
5010 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_SUCCESS)));
5011 SvREADONLY_on(sv);
5012 } while(0) /*@SWIG@*/;
5013 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5014 SV *sv = get_sv((char*) SWIG_prefix "GSL_FAILURE", TRUE | 0x2 | GV_ADDMULTI);
5015 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_FAILURE)));
5016 SvREADONLY_on(sv);
5017 } while(0) /*@SWIG@*/;
5018 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5019 SV *sv = get_sv((char*) SWIG_prefix "GSL_CONTINUE", TRUE | 0x2 | GV_ADDMULTI);
5020 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_CONTINUE)));
5021 SvREADONLY_on(sv);
5022 } while(0) /*@SWIG@*/;
5023 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5024 SV *sv = get_sv((char*) SWIG_prefix "GSL_EDOM", TRUE | 0x2 | GV_ADDMULTI);
5025 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EDOM)));
5026 SvREADONLY_on(sv);
5027 } while(0) /*@SWIG@*/;
5028 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5029 SV *sv = get_sv((char*) SWIG_prefix "GSL_ERANGE", TRUE | 0x2 | GV_ADDMULTI);
5030 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ERANGE)));
5031 SvREADONLY_on(sv);
5032 } while(0) /*@SWIG@*/;
5033 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5034 SV *sv = get_sv((char*) SWIG_prefix "GSL_EFAULT", TRUE | 0x2 | GV_ADDMULTI);
5035 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EFAULT)));
5036 SvREADONLY_on(sv);
5037 } while(0) /*@SWIG@*/;
5038 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5039 SV *sv = get_sv((char*) SWIG_prefix "GSL_EINVAL", TRUE | 0x2 | GV_ADDMULTI);
5040 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EINVAL)));
5041 SvREADONLY_on(sv);
5042 } while(0) /*@SWIG@*/;
5043 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5044 SV *sv = get_sv((char*) SWIG_prefix "GSL_EFAILED", TRUE | 0x2 | GV_ADDMULTI);
5045 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EFAILED)));
5046 SvREADONLY_on(sv);
5047 } while(0) /*@SWIG@*/;
5048 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5049 SV *sv = get_sv((char*) SWIG_prefix "GSL_EFACTOR", TRUE | 0x2 | GV_ADDMULTI);
5050 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EFACTOR)));
5051 SvREADONLY_on(sv);
5052 } while(0) /*@SWIG@*/;
5053 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5054 SV *sv = get_sv((char*) SWIG_prefix "GSL_ESANITY", TRUE | 0x2 | GV_ADDMULTI);
5055 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ESANITY)));
5056 SvREADONLY_on(sv);
5057 } while(0) /*@SWIG@*/;
5058 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5059 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOMEM", TRUE | 0x2 | GV_ADDMULTI);
5060 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOMEM)));
5061 SvREADONLY_on(sv);
5062 } while(0) /*@SWIG@*/;
5063 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5064 SV *sv = get_sv((char*) SWIG_prefix "GSL_EBADFUNC", TRUE | 0x2 | GV_ADDMULTI);
5065 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EBADFUNC)));
5066 SvREADONLY_on(sv);
5067 } while(0) /*@SWIG@*/;
5068 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5069 SV *sv = get_sv((char*) SWIG_prefix "GSL_ERUNAWAY", TRUE | 0x2 | GV_ADDMULTI);
5070 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ERUNAWAY)));
5071 SvREADONLY_on(sv);
5072 } while(0) /*@SWIG@*/;
5073 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5074 SV *sv = get_sv((char*) SWIG_prefix "GSL_EMAXITER", TRUE | 0x2 | GV_ADDMULTI);
5075 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EMAXITER)));
5076 SvREADONLY_on(sv);
5077 } while(0) /*@SWIG@*/;
5078 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5079 SV *sv = get_sv((char*) SWIG_prefix "GSL_EZERODIV", TRUE | 0x2 | GV_ADDMULTI);
5080 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EZERODIV)));
5081 SvREADONLY_on(sv);
5082 } while(0) /*@SWIG@*/;
5083 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5084 SV *sv = get_sv((char*) SWIG_prefix "GSL_EBADTOL", TRUE | 0x2 | GV_ADDMULTI);
5085 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EBADTOL)));
5086 SvREADONLY_on(sv);
5087 } while(0) /*@SWIG@*/;
5088 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5089 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOL", TRUE | 0x2 | GV_ADDMULTI);
5090 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOL)));
5091 SvREADONLY_on(sv);
5092 } while(0) /*@SWIG@*/;
5093 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5094 SV *sv = get_sv((char*) SWIG_prefix "GSL_EUNDRFLW", TRUE | 0x2 | GV_ADDMULTI);
5095 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EUNDRFLW)));
5096 SvREADONLY_on(sv);
5097 } while(0) /*@SWIG@*/;
5098 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5099 SV *sv = get_sv((char*) SWIG_prefix "GSL_EOVRFLW", TRUE | 0x2 | GV_ADDMULTI);
5100 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EOVRFLW)));
5101 SvREADONLY_on(sv);
5102 } while(0) /*@SWIG@*/;
5103 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5104 SV *sv = get_sv((char*) SWIG_prefix "GSL_ELOSS", TRUE | 0x2 | GV_ADDMULTI);
5105 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ELOSS)));
5106 SvREADONLY_on(sv);
5107 } while(0) /*@SWIG@*/;
5108 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5109 SV *sv = get_sv((char*) SWIG_prefix "GSL_EROUND", TRUE | 0x2 | GV_ADDMULTI);
5110 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EROUND)));
5111 SvREADONLY_on(sv);
5112 } while(0) /*@SWIG@*/;
5113 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5114 SV *sv = get_sv((char*) SWIG_prefix "GSL_EBADLEN", TRUE | 0x2 | GV_ADDMULTI);
5115 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EBADLEN)));
5116 SvREADONLY_on(sv);
5117 } while(0) /*@SWIG@*/;
5118 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5119 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOTSQR", TRUE | 0x2 | GV_ADDMULTI);
5120 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOTSQR)));
5121 SvREADONLY_on(sv);
5122 } while(0) /*@SWIG@*/;
5123 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5124 SV *sv = get_sv((char*) SWIG_prefix "GSL_ESING", TRUE | 0x2 | GV_ADDMULTI);
5125 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ESING)));
5126 SvREADONLY_on(sv);
5127 } while(0) /*@SWIG@*/;
5128 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5129 SV *sv = get_sv((char*) SWIG_prefix "GSL_EDIVERGE", TRUE | 0x2 | GV_ADDMULTI);
5130 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EDIVERGE)));
5131 SvREADONLY_on(sv);
5132 } while(0) /*@SWIG@*/;
5133 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5134 SV *sv = get_sv((char*) SWIG_prefix "GSL_EUNSUP", TRUE | 0x2 | GV_ADDMULTI);
5135 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EUNSUP)));
5136 SvREADONLY_on(sv);
5137 } while(0) /*@SWIG@*/;
5138 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5139 SV *sv = get_sv((char*) SWIG_prefix "GSL_EUNIMPL", TRUE | 0x2 | GV_ADDMULTI);
5140 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EUNIMPL)));
5141 SvREADONLY_on(sv);
5142 } while(0) /*@SWIG@*/;
5143 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5144 SV *sv = get_sv((char*) SWIG_prefix "GSL_ECACHE", TRUE | 0x2 | GV_ADDMULTI);
5145 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ECACHE)));
5146 SvREADONLY_on(sv);
5147 } while(0) /*@SWIG@*/;
5148 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5149 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETABLE", TRUE | 0x2 | GV_ADDMULTI);
5150 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETABLE)));
5151 SvREADONLY_on(sv);
5152 } while(0) /*@SWIG@*/;
5153 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5154 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOPROG", TRUE | 0x2 | GV_ADDMULTI);
5155 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOPROG)));
5156 SvREADONLY_on(sv);
5157 } while(0) /*@SWIG@*/;
5158 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5159 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOPROGJ", TRUE | 0x2 | GV_ADDMULTI);
5160 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOPROGJ)));
5161 SvREADONLY_on(sv);
5162 } while(0) /*@SWIG@*/;
5163 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5164 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOLF", TRUE | 0x2 | GV_ADDMULTI);
5165 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOLF)));
5166 SvREADONLY_on(sv);
5167 } while(0) /*@SWIG@*/;
5168 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5169 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOLX", TRUE | 0x2 | GV_ADDMULTI);
5170 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOLX)));
5171 SvREADONLY_on(sv);
5172 } while(0) /*@SWIG@*/;
5173 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5174 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOLG", TRUE | 0x2 | GV_ADDMULTI);
5175 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOLG)));
5176 SvREADONLY_on(sv);
5177 } while(0) /*@SWIG@*/;
5178 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5179 SV *sv = get_sv((char*) SWIG_prefix "GSL_EOF", TRUE | 0x2 | GV_ADDMULTI);
5180 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EOF)));
5181 SvREADONLY_on(sv);
5182 } while(0) /*@SWIG@*/;
5183 SWIG_TypeClientData(SWIGTYPE_p_gsl_interp_accel, (void*) "Math::GSL::Interp::gsl_interp_accel");
5184 SWIG_TypeClientData(SWIGTYPE_p_gsl_interp, (void*) "Math::GSL::Interp::gsl_interp");
5185 ST(0) = &PL_sv_yes;
5186 XSRETURN(1);
5187 }
5188
5189