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_rstat_quantile_workspace swig_types[5]
1525 #define SWIGTYPE_p_gsl_rstat_workspace swig_types[6]
1526 #define SWIGTYPE_p_int swig_types[7]
1527 static swig_type_info *swig_types[9];
1528 static swig_module_info swig_module = {swig_types, 8, 0, 0, 0, 0};
1529 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1530 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1531
1532 /* -------- TYPES TABLE (END) -------- */
1533
1534 #define SWIG_init boot_Math__GSL__Rstat
1535
1536 #define SWIG_name "Math::GSL::Rstatc::boot_Math__GSL__Rstat"
1537 #define SWIG_prefix "Math::GSL::Rstatc::"
1538
1539 #define SWIGVERSION 0x040001
1540 #define SWIG_VERSION SWIGVERSION
1541
1542
1543 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1544 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1545
1546
1547 #ifdef __cplusplus
1548 extern "C"
1549 #endif
1550 #ifndef PERL_OBJECT
1551 #ifndef MULTIPLICITY
1552 SWIGEXPORT void SWIG_init (CV* cv);
1553 #else
1554 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1555 #endif
1556 #else
1557 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1558 #endif
1559
1560
1561 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(double value)1562 SWIG_From_double SWIG_PERL_DECL_ARGS_1(double value)
1563 {
1564 return sv_2mortal(newSVnv(value));
1565 }
1566
1567
1568 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(long value)1569 SWIG_From_long SWIG_PERL_DECL_ARGS_1(long value)
1570 {
1571 SV *sv;
1572 if (IVSIZE >= sizeof(value) || (value >= IV_MIN && value <= IV_MAX))
1573 sv = newSViv(value);
1574 else
1575 sv = newSVpvf("%ld", value);
1576 return sv_2mortal(sv);
1577 }
1578
1579
1580 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(int value)1581 SWIG_From_int SWIG_PERL_DECL_ARGS_1(int value)
1582 {
1583 return SWIG_From_long SWIG_PERL_CALL_ARGS_1(value);
1584 }
1585
1586
1587 SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)1588 SWIG_pchar_descriptor(void)
1589 {
1590 static int init = 0;
1591 static swig_type_info* info = 0;
1592 if (!init) {
1593 info = SWIG_TypeQuery("_p_char");
1594 init = 1;
1595 }
1596 return info;
1597 }
1598
1599
1600 SWIGINTERN int
SWIG_AsCharPtrAndSize(SV * obj,char ** cptr,size_t * psize,int * alloc)1601 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1602 {
1603 if (SvMAGICAL(obj)) {
1604 SV *tmp = sv_newmortal();
1605 SvSetSV(tmp, obj);
1606 obj = tmp;
1607 }
1608 if (SvPOK(obj)) {
1609 STRLEN len = 0;
1610 char *cstr = SvPV(obj, len);
1611 size_t size = len + 1;
1612 if (cptr) {
1613 if (alloc) {
1614 if (*alloc == SWIG_NEWOBJ) {
1615 *cptr = (char *)memcpy(malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1616 } else {
1617 *cptr = cstr;
1618 *alloc = SWIG_OLDOBJ;
1619 }
1620 }
1621 }
1622 if (psize) *psize = size;
1623 return SWIG_OK;
1624 } else {
1625 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1626 if (pchar_descriptor) {
1627 char* vptr = 0;
1628 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1629 if (cptr) *cptr = vptr;
1630 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1631 if (alloc) *alloc = SWIG_OLDOBJ;
1632 return SWIG_OK;
1633 }
1634 }
1635 }
1636 return SWIG_TypeError;
1637 }
1638
1639
1640
1641
1642
1643 #include <limits.h>
1644 #if !defined(SWIG_NO_LLONG_MAX)
1645 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1646 # define LLONG_MAX __LONG_LONG_MAX__
1647 # define LLONG_MIN (-LLONG_MAX - 1LL)
1648 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1649 # endif
1650 #endif
1651
1652
1653 #include <stdlib.h>
1654 #ifdef _MSC_VER
1655 # ifndef strtoull
1656 # define strtoull _strtoui64
1657 # endif
1658 # ifndef strtoll
1659 # define strtoll _strtoi64
1660 # endif
1661 #endif
1662
1663
1664 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,double * val)1665 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1666 {
1667 if (SvNIOK(obj)) {
1668 if (val) *val = SvNV(obj);
1669 return SWIG_OK;
1670 } else if (SvIOK(obj)) {
1671 if (val) *val = (double) SvIV(obj);
1672 return SWIG_AddCast(SWIG_OK);
1673 } else {
1674 const char *nptr = SvPV_nolen(obj);
1675 if (nptr) {
1676 char *endptr;
1677 double v;
1678 errno = 0;
1679 v = strtod(nptr, &endptr);
1680 if (errno == ERANGE) {
1681 errno = 0;
1682 return SWIG_OverflowError;
1683 } else {
1684 if (*endptr == '\0') {
1685 if (val) *val = v;
1686 return SWIG_Str2NumCast(SWIG_OK);
1687 }
1688 }
1689 }
1690 }
1691 return SWIG_TypeError;
1692 }
1693
1694
1695 #include <float.h>
1696
1697
1698 #include <math.h>
1699
1700
1701 SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double * d,double min,double max)1702 SWIG_CanCastAsInteger(double *d, double min, double max) {
1703 double x = *d;
1704 if ((min <= x && x <= max)) {
1705 double fx = floor(x);
1706 double cx = ceil(x);
1707 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1708 if ((errno == EDOM) || (errno == ERANGE)) {
1709 errno = 0;
1710 } else {
1711 double summ, reps, diff;
1712 if (rd < x) {
1713 diff = x - rd;
1714 } else if (rd > x) {
1715 diff = rd - x;
1716 } else {
1717 return 1;
1718 }
1719 summ = rd + x;
1720 reps = diff/summ;
1721 if (reps < 8*DBL_EPSILON) {
1722 *d = rd;
1723 return 1;
1724 }
1725 }
1726 }
1727 return 0;
1728 }
1729
1730
1731 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,long * val)1732 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1733 {
1734 if (SvUOK(obj)) {
1735 UV v = SvUV(obj);
1736 if (UVSIZE < sizeof(*val) || v <= LONG_MAX) {
1737 if (val) *val = v;
1738 return SWIG_OK;
1739 }
1740 return SWIG_OverflowError;
1741 } else if (SvIOK(obj)) {
1742 IV v = SvIV(obj);
1743 if (IVSIZE <= sizeof(*val) || (v >= LONG_MIN && v <= LONG_MAX)) {
1744 if(val) *val = v;
1745 return SWIG_OK;
1746 }
1747 return SWIG_OverflowError;
1748 } else {
1749 int dispatch = 0;
1750 const char *nptr = SvPV_nolen(obj);
1751 if (nptr) {
1752 char *endptr;
1753 long v;
1754 errno = 0;
1755 v = strtol(nptr, &endptr,0);
1756 if (errno == ERANGE) {
1757 errno = 0;
1758 return SWIG_OverflowError;
1759 } else {
1760 if (*endptr == '\0') {
1761 if (val) *val = v;
1762 return SWIG_Str2NumCast(SWIG_OK);
1763 }
1764 }
1765 }
1766 if (!dispatch) {
1767 double d;
1768 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1769 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1770 if (val) *val = (long)(d);
1771 return res;
1772 }
1773 }
1774 }
1775 return SWIG_TypeError;
1776 }
1777
1778
1779 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,int * val)1780 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1781 {
1782 long v;
1783 int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1784 if (SWIG_IsOK(res)) {
1785 if ((v < INT_MIN || v > INT_MAX)) {
1786 return SWIG_OverflowError;
1787 } else {
1788 if (val) *val = (int)(v);
1789 }
1790 }
1791 return res;
1792 }
1793
1794
1795 SWIGINTERNINLINE SV *
SWIG_FromCharPtrAndSize(const char * carray,size_t size)1796 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1797 {
1798 SV *obj = sv_newmortal();
1799 if (carray) {
1800 sv_setpvn(obj, carray, size);
1801 } else {
1802 sv_setsv(obj, &PL_sv_undef);
1803 }
1804 return obj;
1805 }
1806
1807
1808 SWIGINTERNINLINE SV *
SWIG_FromCharPtr(const char * cptr)1809 SWIG_FromCharPtr(const char *cptr)
1810 {
1811 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1812 }
1813
1814
1815 #include "gsl/gsl_nan.h"
1816 #include "gsl/gsl_errno.h"
1817 #include "gsl/gsl_math.h"
1818 #include "gsl/gsl_monte.h"
1819
1820
1821 struct perl_array {
1822 I32 len;
1823 AV *array;
1824 };
1825
1826
1827
1828 enum awType { awDouble, awFloat, awInt, awUnsigned };
1829
1830 typedef struct {
1831 I32 size;
1832 enum awType type;
1833 void * data;
1834 } array_wrapper;
1835
array_wrapper_alloc(int numelem,enum awType type)1836 array_wrapper * array_wrapper_alloc(int numelem, enum awType type){
1837 array_wrapper * rv = malloc(sizeof(array_wrapper));
1838
1839 if (rv == NULL)
1840 croak("array_wrapper_alloc: can't malloc wrapper\n");
1841
1842 switch (type){
1843 case awDouble:
1844 rv->data = malloc(sizeof(double) * numelem);
1845 break;
1846 case awFloat:
1847 rv->data = malloc(sizeof(float) * numelem);
1848 break;
1849 case awInt:
1850 rv->data = malloc(sizeof(int) * numelem);
1851 break;
1852 case awUnsigned:
1853 rv->data = malloc(sizeof(unsigned int) * numelem);
1854 break;
1855 default:
1856 croak("array_wrapper_alloc: type should be awDouble, awFloat, awInt, or awUnsigned");
1857 }
1858
1859 if (rv->data == NULL)
1860 croak("array_wrapper_alloc: can't malloc data");
1861
1862 rv->size = numelem;
1863 rv->type = type;
1864 return rv;
1865 }
1866
array_wrapper_free(array_wrapper * daw)1867 void array_wrapper_free(array_wrapper * daw){
1868 free(daw->data);
1869 free(daw);
1870 }
1871
1872
1873 /* structure to hold required information while the gsl function call
1874 for each callback
1875 */
1876 struct gsl_function_perl {
1877 gsl_function C_gsl_function;
1878 SV * function;
1879 SV * params;
1880 };
1881
1882 struct gsl_function_fdf_perl {
1883 gsl_function_fdf C_gsl_function_fdf;
1884 SV * f;
1885 SV * df;
1886 SV * fdf;
1887 SV * params;
1888 };
1889
1890 struct gsl_monte_function_perl {
1891 gsl_monte_function C_gsl_monte_function;
1892 SV * f;
1893 SV * dim;
1894 SV * params;
1895 };
1896
gsl_function_perl_free(struct gsl_function_perl * perl_f)1897 void gsl_function_perl_free(struct gsl_function_perl * perl_f){
1898 if (perl_f != NULL) {
1899 SvREFCNT_dec(perl_f->function);
1900 SvREFCNT_dec(perl_f->params);
1901 Safefree(perl_f);
1902 }
1903 }
1904
gsl_function_fdf_perl_free(struct gsl_function_fdf_perl * perl_fdf)1905 void gsl_function_fdf_perl_free(struct gsl_function_fdf_perl * perl_fdf){
1906 if (perl_fdf != NULL) {
1907 SvREFCNT_dec(perl_fdf->f);
1908 SvREFCNT_dec(perl_fdf->df);
1909 SvREFCNT_dec(perl_fdf->fdf);
1910 SvREFCNT_dec(perl_fdf->params);
1911 Safefree(perl_fdf);
1912 }
1913 }
1914
1915 /* These functions (C callbacks) calls the perl callbacks.
1916 Info for perl callback can be found using the 'void*params' parameter
1917 */
call_gsl_function_x_params(SV * function,double x,SV * params)1918 double call_gsl_function_x_params(SV* function, double x, SV *params){
1919 unsigned int count;
1920 double y;
1921 dSP;
1922
1923 //fprintf(stderr, "LOOKUP CALLBACK\n");
1924 ENTER;
1925 SAVETMPS;
1926
1927 PUSHMARK(SP);
1928 XPUSHs(sv_2mortal(newSVnv((double)x)));
1929 XPUSHs(params);
1930 PUTBACK; /* make local stack pointer global */
1931
1932 count = call_sv(function, G_SCALAR);
1933 SPAGAIN;
1934
1935 if (count != 1)
1936 croak("Expected to call subroutine in scalar context!");
1937
1938 y = POPn;
1939
1940 PUTBACK; /* make local stack pointer global */
1941 FREETMPS;
1942 LEAVE;
1943
1944 return y;
1945 }
1946
call_gsl_function(double x,void * params)1947 double call_gsl_function(double x , void *params){
1948 struct gsl_function_perl *F=(struct gsl_function_perl*)params;
1949 return call_gsl_function_x_params( F->function, x, F->params );
1950 }
1951
call_gsl_function_fdf_f(double x,void * params)1952 double call_gsl_function_fdf_f(double x , void *params){
1953 struct gsl_function_fdf_perl *F=(struct gsl_function_fdf_perl*)params;
1954 return call_gsl_function_x_params( F->f, x, F->params );
1955 }
1956
call_gsl_function_fdf_df(double x,void * params)1957 double call_gsl_function_fdf_df(double x , void *params){
1958 struct gsl_function_fdf_perl *F=(struct gsl_function_fdf_perl*)params;
1959 return call_gsl_function_x_params( F->df, x, F->params );
1960 }
1961
call_gsl_function_fdf_fdf(double x,void * params,double * f,double * df)1962 void call_gsl_function_fdf_fdf(double x , void *params, double *f, double *df ){
1963 struct gsl_function_fdf_perl *F=(struct gsl_function_fdf_perl*)params;
1964
1965 dSP;
1966
1967 ENTER;
1968 SAVETMPS;
1969
1970 PUSHMARK(SP);
1971 EXTEND(SP, 2);
1972 PUSHs(sv_2mortal(newSVnv((double)x)));
1973 PUSHs(F->params);
1974 PUTBACK; /* make local stack pointer global */
1975
1976 {
1977 unsigned int count = call_sv(F->fdf, G_ARRAY);
1978 SPAGAIN;
1979
1980 if (count != 2)
1981 croak( "Expected two return values, got %d", count );
1982 }
1983
1984 *df = POPn;
1985 *f = POPn;
1986
1987 PUTBACK; /* make local stack pointer global */
1988 FREETMPS;
1989 LEAVE;
1990 }
1991
call_gsl_monte_function(double * x_array,size_t dim,void * params)1992 double call_gsl_monte_function(double *x_array , size_t dim, void *params){
1993 struct gsl_monte_function_perl *F=(struct gsl_monte_function_perl*)params;
1994 unsigned int count;
1995 unsigned int i;
1996 AV* perl_array;
1997 double y;
1998 dSP;
1999
2000 //fprintf(stderr, "LOOKUP CALLBACK\n");
2001 ENTER;
2002 SAVETMPS;
2003
2004 PUSHMARK(SP);
2005 perl_array=newAV();
2006 sv_2mortal((SV*)perl_array);
2007 XPUSHs(sv_2mortal(newRV((SV *)perl_array)));
2008 for(i=0; i<dim; i++) {
2009 /* no mortal : it is referenced by the array */
2010 av_push(perl_array, newSVnv(x_array[i]));
2011 }
2012 XPUSHs(sv_2mortal(newSViv(dim)));
2013 XPUSHs(F->params);
2014 PUTBACK; /* make local stack pointer global */
2015
2016 count = call_sv(F->f, G_SCALAR);
2017 SPAGAIN;
2018
2019 if (count != 1)
2020 croak("Expected to call subroutine in scalar context!");
2021
2022 y = POPn;
2023
2024 PUTBACK; /* make local stack pointer global */
2025 FREETMPS;
2026 LEAVE;
2027
2028 return y;
2029 }
2030
2031
gsl_function_fdf_extract(char * param_name,HV * hash,SV * func[])2032 void gsl_function_fdf_extract( char* param_name, HV* hash, SV* func[] ) {
2033 static const char *keys[3] = { "f", "df", "fdf" };
2034
2035 int ikey;
2036
2037 for ( ikey = 0 ; ikey < 3 ; ++ikey ) {
2038 func[ikey] = 0;
2039 const char* key = keys[ikey];
2040 /* it just so happens that strlen(keys[ikey]) == ikey + 1 */
2041 SV** pp_sv = hv_fetch( hash, key, ikey+1, 0 );
2042 SV* function;
2043
2044 if ( !pp_sv )
2045 croak("Math::GSL : %s: missing key %s!", param_name, key);
2046
2047 function = *pp_sv;
2048
2049 if ( SvPOK(function) || ( SvROK( function ) && SvTYPE(SvRV(function)) == SVt_PVCV ) ) {
2050 /* hold on to SV after the enclosing hash goes away */
2051 SvREFCNT_inc( function );
2052 func[ikey] = function;
2053 }
2054 else {
2055 croak( "Math::GSL : %s: key %s is not a reference to code!", param_name, key);
2056 }
2057 }
2058 }
2059
2060
2061
2062 #include "gsl/gsl_rstat.h"
2063
2064
2065 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,unsigned long * val)2066 SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
2067 {
2068 if (SvUOK(obj)) {
2069 UV v = SvUV(obj);
2070 if (UVSIZE <= sizeof(*val) || v <= ULONG_MAX) {
2071 if (val) *val = v;
2072 return SWIG_OK;
2073 }
2074 return SWIG_OverflowError;
2075 } else if (SvIOK(obj)) {
2076 IV v = SvIV(obj);
2077 if (v >= 0 && (IVSIZE <= sizeof(*val) || v <= ULONG_MAX)) {
2078 if (val) *val = v;
2079 return SWIG_OK;
2080 }
2081 return SWIG_OverflowError;
2082 } else {
2083 int dispatch = 0;
2084 const char *nptr = SvPV_nolen(obj);
2085 if (nptr) {
2086 char *endptr;
2087 unsigned long v;
2088 errno = 0;
2089 v = strtoul(nptr, &endptr,0);
2090 if (errno == ERANGE) {
2091 errno = 0;
2092 return SWIG_OverflowError;
2093 } else {
2094 if (*endptr == '\0') {
2095 if (val) *val = v;
2096 return SWIG_Str2NumCast(SWIG_OK);
2097 }
2098 }
2099 }
2100 if (!dispatch) {
2101 double d;
2102 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
2103 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2104 if (val) *val = (unsigned long)(d);
2105 return res;
2106 }
2107 }
2108 }
2109 return SWIG_TypeError;
2110 }
2111
2112
2113 #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
2114 # define SWIG_LONG_LONG_AVAILABLE
2115 #endif
2116
2117
2118 #ifdef SWIG_LONG_LONG_AVAILABLE
2119 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,unsigned long long * val)2120 SWIG_AsVal_unsigned_SS_long_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long long *val)
2121 {
2122 if (SvUOK(obj)) {
2123 /* pretty sure this should be conditional on
2124 * (UVSIZE <= sizeof(*val) || v <= ULLONG_MAX) */
2125 if (val) *val = SvUV(obj);
2126 return SWIG_OK;
2127 } else if (SvIOK(obj)) {
2128 IV v = SvIV(obj);
2129 if (v >= 0 && (IVSIZE <= sizeof(*val) || v <= ULLONG_MAX)) {
2130 if (val) *val = v;
2131 return SWIG_OK;
2132 } else {
2133 return SWIG_OverflowError;
2134 }
2135 } else {
2136 int dispatch = 0;
2137 const char *nptr = SvPV_nolen(obj);
2138 if (nptr) {
2139 char *endptr;
2140 unsigned long long v;
2141 errno = 0;
2142 v = strtoull(nptr, &endptr,0);
2143 if (errno == ERANGE) {
2144 errno = 0;
2145 return SWIG_OverflowError;
2146 } else {
2147 if (*endptr == '\0') {
2148 if (val) *val = v;
2149 return SWIG_Str2NumCast(SWIG_OK);
2150 }
2151 }
2152 }
2153 if (!dispatch) {
2154 const double mant_max = 1LL << DBL_MANT_DIG;
2155 double d;
2156 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
2157 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
2158 if (val) *val = (unsigned long long)(d);
2159 return res;
2160 }
2161 }
2162 }
2163 return SWIG_TypeError;
2164 }
2165 #endif
2166
2167
2168 SWIGINTERNINLINE int
SWIG_PERL_DECL_ARGS_2(SV * obj,size_t * val)2169 SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
2170 {
2171 int res = SWIG_TypeError;
2172 #ifdef SWIG_LONG_LONG_AVAILABLE
2173 if (sizeof(size_t) <= sizeof(unsigned long)) {
2174 #endif
2175 unsigned long v;
2176 res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
2177 if (SWIG_IsOK(res) && val) *val = (size_t)(v);
2178 #ifdef SWIG_LONG_LONG_AVAILABLE
2179 } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
2180 unsigned long long v;
2181 res = SWIG_AsVal_unsigned_SS_long_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
2182 if (SWIG_IsOK(res) && val) *val = (size_t)(v);
2183 }
2184 #endif
2185 return res;
2186 }
2187
2188
2189 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(unsigned long value)2190 SWIG_From_unsigned_SS_long SWIG_PERL_DECL_ARGS_1(unsigned long value)
2191 {
2192 SV *sv;
2193 if (UVSIZE >= sizeof(value) || value <= UV_MAX)
2194 sv = newSVuv(value);
2195 else
2196 sv = newSVpvf("%lu", value);
2197 return sv_2mortal(sv);
2198 }
2199
2200
2201 #include <stdio.h>
2202 #if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__BORLANDC__) || defined(_WATCOM)
2203 # ifndef snprintf
2204 # define snprintf _snprintf
2205 # endif
2206 #endif
2207
2208
2209 #ifdef SWIG_LONG_LONG_AVAILABLE
2210 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(unsigned long long value)2211 SWIG_From_unsigned_SS_long_SS_long SWIG_PERL_DECL_ARGS_1(unsigned long long value)
2212 {
2213 SV *sv;
2214 if (UVSIZE >= sizeof(value) || value <= UV_MAX)
2215 sv = newSVuv((UV)(value));
2216 else {
2217 //sv = newSVpvf("%llu", value); doesn't work in non 64bit Perl
2218 char temp[256];
2219 sprintf(temp, "%llu", value);
2220 sv = newSVpv(temp, 0);
2221 }
2222 return sv_2mortal(sv);
2223 }
2224 #endif
2225
2226
2227 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(size_t value)2228 SWIG_From_size_t SWIG_PERL_DECL_ARGS_1(size_t value)
2229 {
2230 #ifdef SWIG_LONG_LONG_AVAILABLE
2231 if (sizeof(size_t) <= sizeof(unsigned long)) {
2232 #endif
2233 return SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1((unsigned long)(value));
2234 #ifdef SWIG_LONG_LONG_AVAILABLE
2235 } else {
2236 /* assume sizeof(size_t) <= sizeof(unsigned long long) */
2237 return SWIG_From_unsigned_SS_long_SS_long SWIG_PERL_CALL_ARGS_1((unsigned long long)(value));
2238 }
2239 #endif
2240 }
2241
2242 #ifdef __cplusplus
2243 extern "C" {
2244 #endif
2245
2246 #ifdef PERL_OBJECT
2247 #define MAGIC_CLASS _wrap_Math__GSL__Rstat_var::
2248 class _wrap_Math__GSL__Rstat_var : public CPerlObj {
2249 public:
2250 #else
2251 #define MAGIC_CLASS
2252 #endif
swig_magic_readonly(pTHX_ SV * SWIGUNUSEDPARM (sv),MAGIC * SWIGUNUSEDPARM (mg))2253 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
2254 MAGIC_PPERL
2255 croak("Value is read-only.");
2256 return 0;
2257 }
2258
2259
2260 #ifdef PERL_OBJECT
2261 };
2262 #endif
2263
2264 #ifdef __cplusplus
2265 }
2266 #endif
2267
2268 #ifdef __cplusplus
2269 extern "C" {
2270 #endif
XS(_wrap_gsl_error)2271 XS(_wrap_gsl_error) {
2272 {
2273 char *arg1 = (char *) 0 ;
2274 char *arg2 = (char *) 0 ;
2275 int arg3 ;
2276 int arg4 ;
2277 int res1 ;
2278 char *buf1 = 0 ;
2279 int alloc1 = 0 ;
2280 int res2 ;
2281 char *buf2 = 0 ;
2282 int alloc2 = 0 ;
2283 int val3 ;
2284 int ecode3 = 0 ;
2285 int val4 ;
2286 int ecode4 = 0 ;
2287 int argvi = 0;
2288 dXSARGS;
2289
2290 if ((items < 4) || (items > 4)) {
2291 SWIG_croak("Usage: gsl_error(reason,file,line,gsl_errno);");
2292 }
2293 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2294 if (!SWIG_IsOK(res1)) {
2295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_error" "', argument " "1"" of type '" "char const *""'");
2296 }
2297 arg1 = (char *)(buf1);
2298 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2299 if (!SWIG_IsOK(res2)) {
2300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_error" "', argument " "2"" of type '" "char const *""'");
2301 }
2302 arg2 = (char *)(buf2);
2303 ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2304 if (!SWIG_IsOK(ecode3)) {
2305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_error" "', argument " "3"" of type '" "int""'");
2306 }
2307 arg3 = (int)(val3);
2308 ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
2309 if (!SWIG_IsOK(ecode4)) {
2310 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gsl_error" "', argument " "4"" of type '" "int""'");
2311 }
2312 arg4 = (int)(val4);
2313 gsl_error((char const *)arg1,(char const *)arg2,arg3,arg4);
2314 ST(argvi) = &PL_sv_undef;
2315 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2316 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2317
2318
2319 XSRETURN(argvi);
2320 fail:
2321 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2322 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2323
2324
2325 SWIG_croak_null();
2326 }
2327 }
2328
2329
XS(_wrap_gsl_stream_printf)2330 XS(_wrap_gsl_stream_printf) {
2331 {
2332 char *arg1 = (char *) 0 ;
2333 char *arg2 = (char *) 0 ;
2334 int arg3 ;
2335 char *arg4 = (char *) 0 ;
2336 int res1 ;
2337 char *buf1 = 0 ;
2338 int alloc1 = 0 ;
2339 int res2 ;
2340 char *buf2 = 0 ;
2341 int alloc2 = 0 ;
2342 int val3 ;
2343 int ecode3 = 0 ;
2344 int res4 ;
2345 char *buf4 = 0 ;
2346 int alloc4 = 0 ;
2347 int argvi = 0;
2348 dXSARGS;
2349
2350 if ((items < 4) || (items > 4)) {
2351 SWIG_croak("Usage: gsl_stream_printf(label,file,line,reason);");
2352 }
2353 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2354 if (!SWIG_IsOK(res1)) {
2355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_stream_printf" "', argument " "1"" of type '" "char const *""'");
2356 }
2357 arg1 = (char *)(buf1);
2358 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2359 if (!SWIG_IsOK(res2)) {
2360 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_stream_printf" "', argument " "2"" of type '" "char const *""'");
2361 }
2362 arg2 = (char *)(buf2);
2363 ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2364 if (!SWIG_IsOK(ecode3)) {
2365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gsl_stream_printf" "', argument " "3"" of type '" "int""'");
2366 }
2367 arg3 = (int)(val3);
2368 res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
2369 if (!SWIG_IsOK(res4)) {
2370 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gsl_stream_printf" "', argument " "4"" of type '" "char const *""'");
2371 }
2372 arg4 = (char *)(buf4);
2373 gsl_stream_printf((char const *)arg1,(char const *)arg2,arg3,(char const *)arg4);
2374 ST(argvi) = &PL_sv_undef;
2375 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2376 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2377
2378 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2379 XSRETURN(argvi);
2380 fail:
2381 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2382 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2383
2384 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2385 SWIG_croak_null();
2386 }
2387 }
2388
2389
XS(_wrap_gsl_strerror)2390 XS(_wrap_gsl_strerror) {
2391 {
2392 int arg1 ;
2393 int val1 ;
2394 int ecode1 = 0 ;
2395 int argvi = 0;
2396 char *result = 0 ;
2397 dXSARGS;
2398
2399 if ((items < 1) || (items > 1)) {
2400 SWIG_croak("Usage: gsl_strerror(gsl_errno);");
2401 }
2402 ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2403 if (!SWIG_IsOK(ecode1)) {
2404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_strerror" "', argument " "1"" of type '" "int""'");
2405 }
2406 arg1 = (int)(val1);
2407 result = (char *)gsl_strerror(arg1);
2408 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2409
2410 XSRETURN(argvi);
2411 fail:
2412
2413 SWIG_croak_null();
2414 }
2415 }
2416
2417
XS(_wrap_gsl_set_error_handler)2418 XS(_wrap_gsl_set_error_handler) {
2419 {
2420 gsl_error_handler_t *arg1 = (gsl_error_handler_t *) 0 ;
2421 int argvi = 0;
2422 gsl_error_handler_t *result = 0 ;
2423 dXSARGS;
2424
2425 if ((items < 1) || (items > 1)) {
2426 SWIG_croak("Usage: gsl_set_error_handler(new_handler);");
2427 }
2428 {
2429 int res = SWIG_ConvertFunctionPtr(ST(0), (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void);
2430 if (!SWIG_IsOK(res)) {
2431 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gsl_set_error_handler" "', argument " "1"" of type '" "gsl_error_handler_t *""'");
2432 }
2433 }
2434 result = (gsl_error_handler_t *)gsl_set_error_handler(arg1);
2435 ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void); argvi++ ;
2436
2437 XSRETURN(argvi);
2438 fail:
2439
2440 SWIG_croak_null();
2441 }
2442 }
2443
2444
XS(_wrap_gsl_set_error_handler_off)2445 XS(_wrap_gsl_set_error_handler_off) {
2446 {
2447 int argvi = 0;
2448 gsl_error_handler_t *result = 0 ;
2449 dXSARGS;
2450
2451 if ((items < 0) || (items > 0)) {
2452 SWIG_croak("Usage: gsl_set_error_handler_off();");
2453 }
2454 result = (gsl_error_handler_t *)gsl_set_error_handler_off();
2455 ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_int__void); argvi++ ;
2456 XSRETURN(argvi);
2457 fail:
2458 SWIG_croak_null();
2459 }
2460 }
2461
2462
XS(_wrap_gsl_set_stream_handler)2463 XS(_wrap_gsl_set_stream_handler) {
2464 {
2465 gsl_stream_handler_t *arg1 = (gsl_stream_handler_t *) 0 ;
2466 int argvi = 0;
2467 gsl_stream_handler_t *result = 0 ;
2468 dXSARGS;
2469
2470 if ((items < 1) || (items > 1)) {
2471 SWIG_croak("Usage: gsl_set_stream_handler(new_handler);");
2472 }
2473 {
2474 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);
2475 if (!SWIG_IsOK(res)) {
2476 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gsl_set_stream_handler" "', argument " "1"" of type '" "gsl_stream_handler_t *""'");
2477 }
2478 }
2479 result = (gsl_stream_handler_t *)gsl_set_stream_handler(arg1);
2480 ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void); argvi++ ;
2481
2482 XSRETURN(argvi);
2483 fail:
2484
2485 SWIG_croak_null();
2486 }
2487 }
2488
2489
XS(_wrap_gsl_set_stream)2490 XS(_wrap_gsl_set_stream) {
2491 {
2492 FILE *arg1 = (FILE *) 0 ;
2493 void *argp1 = 0 ;
2494 int res1 = 0 ;
2495 int argvi = 0;
2496 FILE *result = 0 ;
2497 dXSARGS;
2498
2499 if ((items < 1) || (items > 1)) {
2500 SWIG_croak("Usage: gsl_set_stream(new_stream);");
2501 }
2502 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_FILE, 0 | 0 );
2503 if (!SWIG_IsOK(res1)) {
2504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_set_stream" "', argument " "1"" of type '" "FILE *""'");
2505 }
2506 arg1 = (FILE *)(argp1);
2507 result = (FILE *)gsl_set_stream(arg1);
2508 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 | 0); argvi++ ;
2509
2510 XSRETURN(argvi);
2511 fail:
2512
2513 SWIG_croak_null();
2514 }
2515 }
2516
2517
XS(_wrap_gsl_rstat_quantile_workspace_p_set)2518 XS(_wrap_gsl_rstat_quantile_workspace_p_set) {
2519 {
2520 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
2521 double arg2 ;
2522 void *argp1 = 0 ;
2523 int res1 = 0 ;
2524 double val2 ;
2525 int ecode2 = 0 ;
2526 int argvi = 0;
2527 dXSARGS;
2528
2529 if ((items < 2) || (items > 2)) {
2530 SWIG_croak("Usage: gsl_rstat_quantile_workspace_p_set(self,p);");
2531 }
2532 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
2533 if (!SWIG_IsOK(res1)) {
2534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_quantile_workspace_p_set" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
2535 }
2536 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
2537 ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2538 if (!SWIG_IsOK(ecode2)) {
2539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_rstat_quantile_workspace_p_set" "', argument " "2"" of type '" "double""'");
2540 }
2541 arg2 = (double)(val2);
2542 if (arg1) (arg1)->p = arg2;
2543 ST(argvi) = &PL_sv_undef;
2544
2545
2546 XSRETURN(argvi);
2547 fail:
2548
2549
2550 SWIG_croak_null();
2551 }
2552 }
2553
2554
XS(_wrap_gsl_rstat_quantile_workspace_p_get)2555 XS(_wrap_gsl_rstat_quantile_workspace_p_get) {
2556 {
2557 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
2558 void *argp1 = 0 ;
2559 int res1 = 0 ;
2560 int argvi = 0;
2561 double result;
2562 dXSARGS;
2563
2564 if ((items < 1) || (items > 1)) {
2565 SWIG_croak("Usage: gsl_rstat_quantile_workspace_p_get(self);");
2566 }
2567 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
2568 if (!SWIG_IsOK(res1)) {
2569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_quantile_workspace_p_get" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
2570 }
2571 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
2572 result = (double) ((arg1)->p);
2573 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
2574
2575 XSRETURN(argvi);
2576 fail:
2577
2578 SWIG_croak_null();
2579 }
2580 }
2581
2582
XS(_wrap_gsl_rstat_quantile_workspace_q_set)2583 XS(_wrap_gsl_rstat_quantile_workspace_q_set) {
2584 {
2585 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
2586 double *arg2 ;
2587 void *argp1 = 0 ;
2588 int res1 = 0 ;
2589 void *argp2 = 0 ;
2590 int res2 = 0 ;
2591 int argvi = 0;
2592 dXSARGS;
2593
2594 if ((items < 2) || (items > 2)) {
2595 SWIG_croak("Usage: gsl_rstat_quantile_workspace_q_set(self,q);");
2596 }
2597 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
2598 if (!SWIG_IsOK(res1)) {
2599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_quantile_workspace_q_set" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
2600 }
2601 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
2602 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_double, 0 | 0 );
2603 if (!SWIG_IsOK(res2)) {
2604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_rstat_quantile_workspace_q_set" "', argument " "2"" of type '" "double [5]""'");
2605 }
2606 arg2 = (double *)(argp2);
2607 {
2608 if (arg2) {
2609 size_t ii = 0;
2610 for (; ii < (size_t)5; ++ii) *(double *)&arg1->q[ii] = *((double *)arg2 + ii);
2611 } else {
2612 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""q""' of type '""double [5]""'");
2613 }
2614 }
2615 ST(argvi) = &PL_sv_undef;
2616
2617
2618 XSRETURN(argvi);
2619 fail:
2620
2621
2622 SWIG_croak_null();
2623 }
2624 }
2625
2626
XS(_wrap_gsl_rstat_quantile_workspace_q_get)2627 XS(_wrap_gsl_rstat_quantile_workspace_q_get) {
2628 {
2629 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
2630 void *argp1 = 0 ;
2631 int res1 = 0 ;
2632 int argvi = 0;
2633 double *result = 0 ;
2634 dXSARGS;
2635
2636 if ((items < 1) || (items > 1)) {
2637 SWIG_croak("Usage: gsl_rstat_quantile_workspace_q_get(self);");
2638 }
2639 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
2640 if (!SWIG_IsOK(res1)) {
2641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_quantile_workspace_q_get" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
2642 }
2643 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
2644 result = (double *)(double *) ((arg1)->q);
2645 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0); argvi++ ;
2646
2647 XSRETURN(argvi);
2648 fail:
2649
2650 SWIG_croak_null();
2651 }
2652 }
2653
2654
XS(_wrap_gsl_rstat_quantile_workspace_npos_set)2655 XS(_wrap_gsl_rstat_quantile_workspace_npos_set) {
2656 {
2657 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
2658 int *arg2 ;
2659 void *argp1 = 0 ;
2660 int res1 = 0 ;
2661 void *argp2 = 0 ;
2662 int res2 = 0 ;
2663 int argvi = 0;
2664 dXSARGS;
2665
2666 if ((items < 2) || (items > 2)) {
2667 SWIG_croak("Usage: gsl_rstat_quantile_workspace_npos_set(self,npos);");
2668 }
2669 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
2670 if (!SWIG_IsOK(res1)) {
2671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_quantile_workspace_npos_set" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
2672 }
2673 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
2674 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_int, 0 | 0 );
2675 if (!SWIG_IsOK(res2)) {
2676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_rstat_quantile_workspace_npos_set" "', argument " "2"" of type '" "int [5]""'");
2677 }
2678 arg2 = (int *)(argp2);
2679 {
2680 if (arg2) {
2681 size_t ii = 0;
2682 for (; ii < (size_t)5; ++ii) *(int *)&arg1->npos[ii] = *((int *)arg2 + ii);
2683 } else {
2684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""npos""' of type '""int [5]""'");
2685 }
2686 }
2687 ST(argvi) = &PL_sv_undef;
2688
2689
2690 XSRETURN(argvi);
2691 fail:
2692
2693
2694 SWIG_croak_null();
2695 }
2696 }
2697
2698
XS(_wrap_gsl_rstat_quantile_workspace_npos_get)2699 XS(_wrap_gsl_rstat_quantile_workspace_npos_get) {
2700 {
2701 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
2702 void *argp1 = 0 ;
2703 int res1 = 0 ;
2704 int argvi = 0;
2705 int *result = 0 ;
2706 dXSARGS;
2707
2708 if ((items < 1) || (items > 1)) {
2709 SWIG_croak("Usage: gsl_rstat_quantile_workspace_npos_get(self);");
2710 }
2711 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
2712 if (!SWIG_IsOK(res1)) {
2713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_quantile_workspace_npos_get" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
2714 }
2715 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
2716 result = (int *)(int *) ((arg1)->npos);
2717 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0); argvi++ ;
2718
2719 XSRETURN(argvi);
2720 fail:
2721
2722 SWIG_croak_null();
2723 }
2724 }
2725
2726
XS(_wrap_gsl_rstat_quantile_workspace_np_set)2727 XS(_wrap_gsl_rstat_quantile_workspace_np_set) {
2728 {
2729 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
2730 double *arg2 ;
2731 void *argp1 = 0 ;
2732 int res1 = 0 ;
2733 void *argp2 = 0 ;
2734 int res2 = 0 ;
2735 int argvi = 0;
2736 dXSARGS;
2737
2738 if ((items < 2) || (items > 2)) {
2739 SWIG_croak("Usage: gsl_rstat_quantile_workspace_np_set(self,np);");
2740 }
2741 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
2742 if (!SWIG_IsOK(res1)) {
2743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_quantile_workspace_np_set" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
2744 }
2745 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
2746 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_double, 0 | 0 );
2747 if (!SWIG_IsOK(res2)) {
2748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_rstat_quantile_workspace_np_set" "', argument " "2"" of type '" "double [5]""'");
2749 }
2750 arg2 = (double *)(argp2);
2751 {
2752 if (arg2) {
2753 size_t ii = 0;
2754 for (; ii < (size_t)5; ++ii) *(double *)&arg1->np[ii] = *((double *)arg2 + ii);
2755 } else {
2756 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""np""' of type '""double [5]""'");
2757 }
2758 }
2759 ST(argvi) = &PL_sv_undef;
2760
2761
2762 XSRETURN(argvi);
2763 fail:
2764
2765
2766 SWIG_croak_null();
2767 }
2768 }
2769
2770
XS(_wrap_gsl_rstat_quantile_workspace_np_get)2771 XS(_wrap_gsl_rstat_quantile_workspace_np_get) {
2772 {
2773 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
2774 void *argp1 = 0 ;
2775 int res1 = 0 ;
2776 int argvi = 0;
2777 double *result = 0 ;
2778 dXSARGS;
2779
2780 if ((items < 1) || (items > 1)) {
2781 SWIG_croak("Usage: gsl_rstat_quantile_workspace_np_get(self);");
2782 }
2783 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
2784 if (!SWIG_IsOK(res1)) {
2785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_quantile_workspace_np_get" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
2786 }
2787 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
2788 result = (double *)(double *) ((arg1)->np);
2789 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0); argvi++ ;
2790
2791 XSRETURN(argvi);
2792 fail:
2793
2794 SWIG_croak_null();
2795 }
2796 }
2797
2798
XS(_wrap_gsl_rstat_quantile_workspace_dnp_set)2799 XS(_wrap_gsl_rstat_quantile_workspace_dnp_set) {
2800 {
2801 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
2802 double *arg2 ;
2803 void *argp1 = 0 ;
2804 int res1 = 0 ;
2805 void *argp2 = 0 ;
2806 int res2 = 0 ;
2807 int argvi = 0;
2808 dXSARGS;
2809
2810 if ((items < 2) || (items > 2)) {
2811 SWIG_croak("Usage: gsl_rstat_quantile_workspace_dnp_set(self,dnp);");
2812 }
2813 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
2814 if (!SWIG_IsOK(res1)) {
2815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_quantile_workspace_dnp_set" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
2816 }
2817 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
2818 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_double, 0 | 0 );
2819 if (!SWIG_IsOK(res2)) {
2820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_rstat_quantile_workspace_dnp_set" "', argument " "2"" of type '" "double [5]""'");
2821 }
2822 arg2 = (double *)(argp2);
2823 {
2824 if (arg2) {
2825 size_t ii = 0;
2826 for (; ii < (size_t)5; ++ii) *(double *)&arg1->dnp[ii] = *((double *)arg2 + ii);
2827 } else {
2828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""dnp""' of type '""double [5]""'");
2829 }
2830 }
2831 ST(argvi) = &PL_sv_undef;
2832
2833
2834 XSRETURN(argvi);
2835 fail:
2836
2837
2838 SWIG_croak_null();
2839 }
2840 }
2841
2842
XS(_wrap_gsl_rstat_quantile_workspace_dnp_get)2843 XS(_wrap_gsl_rstat_quantile_workspace_dnp_get) {
2844 {
2845 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
2846 void *argp1 = 0 ;
2847 int res1 = 0 ;
2848 int argvi = 0;
2849 double *result = 0 ;
2850 dXSARGS;
2851
2852 if ((items < 1) || (items > 1)) {
2853 SWIG_croak("Usage: gsl_rstat_quantile_workspace_dnp_get(self);");
2854 }
2855 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
2856 if (!SWIG_IsOK(res1)) {
2857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_quantile_workspace_dnp_get" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
2858 }
2859 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
2860 result = (double *)(double *) ((arg1)->dnp);
2861 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0); argvi++ ;
2862
2863 XSRETURN(argvi);
2864 fail:
2865
2866 SWIG_croak_null();
2867 }
2868 }
2869
2870
XS(_wrap_gsl_rstat_quantile_workspace_n_set)2871 XS(_wrap_gsl_rstat_quantile_workspace_n_set) {
2872 {
2873 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
2874 size_t arg2 ;
2875 void *argp1 = 0 ;
2876 int res1 = 0 ;
2877 size_t val2 ;
2878 int ecode2 = 0 ;
2879 int argvi = 0;
2880 dXSARGS;
2881
2882 if ((items < 2) || (items > 2)) {
2883 SWIG_croak("Usage: gsl_rstat_quantile_workspace_n_set(self,n);");
2884 }
2885 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
2886 if (!SWIG_IsOK(res1)) {
2887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_quantile_workspace_n_set" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
2888 }
2889 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
2890 ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2891 if (!SWIG_IsOK(ecode2)) {
2892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_rstat_quantile_workspace_n_set" "', argument " "2"" of type '" "size_t""'");
2893 }
2894 arg2 = (size_t)(val2);
2895 if (arg1) (arg1)->n = arg2;
2896 ST(argvi) = &PL_sv_undef;
2897
2898
2899 XSRETURN(argvi);
2900 fail:
2901
2902
2903 SWIG_croak_null();
2904 }
2905 }
2906
2907
XS(_wrap_gsl_rstat_quantile_workspace_n_get)2908 XS(_wrap_gsl_rstat_quantile_workspace_n_get) {
2909 {
2910 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
2911 void *argp1 = 0 ;
2912 int res1 = 0 ;
2913 int argvi = 0;
2914 size_t result;
2915 dXSARGS;
2916
2917 if ((items < 1) || (items > 1)) {
2918 SWIG_croak("Usage: gsl_rstat_quantile_workspace_n_get(self);");
2919 }
2920 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
2921 if (!SWIG_IsOK(res1)) {
2922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_quantile_workspace_n_get" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
2923 }
2924 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
2925 result = ((arg1)->n);
2926 ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1((size_t)(result)); argvi++ ;
2927
2928 XSRETURN(argvi);
2929 fail:
2930
2931 SWIG_croak_null();
2932 }
2933 }
2934
2935
XS(_wrap_new_gsl_rstat_quantile_workspace)2936 XS(_wrap_new_gsl_rstat_quantile_workspace) {
2937 {
2938 int argvi = 0;
2939 gsl_rstat_quantile_workspace *result = 0 ;
2940 dXSARGS;
2941
2942 if ((items < 0) || (items > 0)) {
2943 SWIG_croak("Usage: new_gsl_rstat_quantile_workspace();");
2944 }
2945 result = (gsl_rstat_quantile_workspace *)calloc(1, sizeof(gsl_rstat_quantile_workspace));
2946 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gsl_rstat_quantile_workspace, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
2947 XSRETURN(argvi);
2948 fail:
2949 SWIG_croak_null();
2950 }
2951 }
2952
2953
XS(_wrap_delete_gsl_rstat_quantile_workspace)2954 XS(_wrap_delete_gsl_rstat_quantile_workspace) {
2955 {
2956 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
2957 void *argp1 = 0 ;
2958 int res1 = 0 ;
2959 int argvi = 0;
2960 dXSARGS;
2961
2962 if ((items < 1) || (items > 1)) {
2963 SWIG_croak("Usage: delete_gsl_rstat_quantile_workspace(self);");
2964 }
2965 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, SWIG_POINTER_DISOWN | 0 );
2966 if (!SWIG_IsOK(res1)) {
2967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gsl_rstat_quantile_workspace" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
2968 }
2969 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
2970 free((char *) arg1);
2971 ST(argvi) = &PL_sv_undef;
2972
2973 XSRETURN(argvi);
2974 fail:
2975
2976 SWIG_croak_null();
2977 }
2978 }
2979
2980
XS(_wrap_gsl_rstat_quantile_alloc)2981 XS(_wrap_gsl_rstat_quantile_alloc) {
2982 {
2983 double arg1 ;
2984 double val1 ;
2985 int ecode1 = 0 ;
2986 int argvi = 0;
2987 gsl_rstat_quantile_workspace *result = 0 ;
2988 dXSARGS;
2989
2990 if ((items < 1) || (items > 1)) {
2991 SWIG_croak("Usage: gsl_rstat_quantile_alloc(p);");
2992 }
2993 ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2994 if (!SWIG_IsOK(ecode1)) {
2995 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_rstat_quantile_alloc" "', argument " "1"" of type '" "double""'");
2996 }
2997 arg1 = (double)(val1);
2998 result = (gsl_rstat_quantile_workspace *)gsl_rstat_quantile_alloc(arg1);
2999 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | SWIG_SHADOW); argvi++ ;
3000
3001 XSRETURN(argvi);
3002 fail:
3003
3004 SWIG_croak_null();
3005 }
3006 }
3007
3008
XS(_wrap_gsl_rstat_quantile_free)3009 XS(_wrap_gsl_rstat_quantile_free) {
3010 {
3011 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
3012 void *argp1 = 0 ;
3013 int res1 = 0 ;
3014 int argvi = 0;
3015 dXSARGS;
3016
3017 if ((items < 1) || (items > 1)) {
3018 SWIG_croak("Usage: gsl_rstat_quantile_free(w);");
3019 }
3020 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
3021 if (!SWIG_IsOK(res1)) {
3022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_quantile_free" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
3023 }
3024 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
3025 gsl_rstat_quantile_free(arg1);
3026 ST(argvi) = &PL_sv_undef;
3027
3028 XSRETURN(argvi);
3029 fail:
3030
3031 SWIG_croak_null();
3032 }
3033 }
3034
3035
XS(_wrap_gsl_rstat_quantile_reset)3036 XS(_wrap_gsl_rstat_quantile_reset) {
3037 {
3038 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
3039 void *argp1 = 0 ;
3040 int res1 = 0 ;
3041 int argvi = 0;
3042 int result;
3043 dXSARGS;
3044
3045 if ((items < 1) || (items > 1)) {
3046 SWIG_croak("Usage: gsl_rstat_quantile_reset(w);");
3047 }
3048 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
3049 if (!SWIG_IsOK(res1)) {
3050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_quantile_reset" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
3051 }
3052 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
3053 result = (int)gsl_rstat_quantile_reset(arg1);
3054 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3055
3056 XSRETURN(argvi);
3057 fail:
3058
3059 SWIG_croak_null();
3060 }
3061 }
3062
3063
XS(_wrap_gsl_rstat_quantile_add)3064 XS(_wrap_gsl_rstat_quantile_add) {
3065 {
3066 double arg1 ;
3067 gsl_rstat_quantile_workspace *arg2 = (gsl_rstat_quantile_workspace *) 0 ;
3068 double val1 ;
3069 int ecode1 = 0 ;
3070 void *argp2 = 0 ;
3071 int res2 = 0 ;
3072 int argvi = 0;
3073 int result;
3074 dXSARGS;
3075
3076 if ((items < 2) || (items > 2)) {
3077 SWIG_croak("Usage: gsl_rstat_quantile_add(x,w);");
3078 }
3079 ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
3080 if (!SWIG_IsOK(ecode1)) {
3081 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_rstat_quantile_add" "', argument " "1"" of type '" "double""'");
3082 }
3083 arg1 = (double)(val1);
3084 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
3085 if (!SWIG_IsOK(res2)) {
3086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_rstat_quantile_add" "', argument " "2"" of type '" "gsl_rstat_quantile_workspace *""'");
3087 }
3088 arg2 = (gsl_rstat_quantile_workspace *)(argp2);
3089 result = (int)gsl_rstat_quantile_add(arg1,arg2);
3090 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3091
3092
3093 XSRETURN(argvi);
3094 fail:
3095
3096
3097 SWIG_croak_null();
3098 }
3099 }
3100
3101
XS(_wrap_gsl_rstat_quantile_get)3102 XS(_wrap_gsl_rstat_quantile_get) {
3103 {
3104 gsl_rstat_quantile_workspace *arg1 = (gsl_rstat_quantile_workspace *) 0 ;
3105 void *argp1 = 0 ;
3106 int res1 = 0 ;
3107 int argvi = 0;
3108 double result;
3109 dXSARGS;
3110
3111 if ((items < 1) || (items > 1)) {
3112 SWIG_croak("Usage: gsl_rstat_quantile_get(w);");
3113 }
3114 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | 0 );
3115 if (!SWIG_IsOK(res1)) {
3116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_quantile_get" "', argument " "1"" of type '" "gsl_rstat_quantile_workspace *""'");
3117 }
3118 arg1 = (gsl_rstat_quantile_workspace *)(argp1);
3119 result = (double)gsl_rstat_quantile_get(arg1);
3120 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3121
3122 XSRETURN(argvi);
3123 fail:
3124
3125 SWIG_croak_null();
3126 }
3127 }
3128
3129
XS(_wrap_gsl_rstat_workspace_min_set)3130 XS(_wrap_gsl_rstat_workspace_min_set) {
3131 {
3132 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3133 double arg2 ;
3134 void *argp1 = 0 ;
3135 int res1 = 0 ;
3136 double val2 ;
3137 int ecode2 = 0 ;
3138 int argvi = 0;
3139 dXSARGS;
3140
3141 if ((items < 2) || (items > 2)) {
3142 SWIG_croak("Usage: gsl_rstat_workspace_min_set(self,min);");
3143 }
3144 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3145 if (!SWIG_IsOK(res1)) {
3146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_min_set" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3147 }
3148 arg1 = (gsl_rstat_workspace *)(argp1);
3149 ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
3150 if (!SWIG_IsOK(ecode2)) {
3151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_rstat_workspace_min_set" "', argument " "2"" of type '" "double""'");
3152 }
3153 arg2 = (double)(val2);
3154 if (arg1) (arg1)->min = arg2;
3155 ST(argvi) = &PL_sv_undef;
3156
3157
3158 XSRETURN(argvi);
3159 fail:
3160
3161
3162 SWIG_croak_null();
3163 }
3164 }
3165
3166
XS(_wrap_gsl_rstat_workspace_min_get)3167 XS(_wrap_gsl_rstat_workspace_min_get) {
3168 {
3169 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3170 void *argp1 = 0 ;
3171 int res1 = 0 ;
3172 int argvi = 0;
3173 double result;
3174 dXSARGS;
3175
3176 if ((items < 1) || (items > 1)) {
3177 SWIG_croak("Usage: gsl_rstat_workspace_min_get(self);");
3178 }
3179 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3180 if (!SWIG_IsOK(res1)) {
3181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_min_get" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3182 }
3183 arg1 = (gsl_rstat_workspace *)(argp1);
3184 result = (double) ((arg1)->min);
3185 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3186
3187 XSRETURN(argvi);
3188 fail:
3189
3190 SWIG_croak_null();
3191 }
3192 }
3193
3194
XS(_wrap_gsl_rstat_workspace_max_set)3195 XS(_wrap_gsl_rstat_workspace_max_set) {
3196 {
3197 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3198 double arg2 ;
3199 void *argp1 = 0 ;
3200 int res1 = 0 ;
3201 double val2 ;
3202 int ecode2 = 0 ;
3203 int argvi = 0;
3204 dXSARGS;
3205
3206 if ((items < 2) || (items > 2)) {
3207 SWIG_croak("Usage: gsl_rstat_workspace_max_set(self,max);");
3208 }
3209 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3210 if (!SWIG_IsOK(res1)) {
3211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_max_set" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3212 }
3213 arg1 = (gsl_rstat_workspace *)(argp1);
3214 ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
3215 if (!SWIG_IsOK(ecode2)) {
3216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_rstat_workspace_max_set" "', argument " "2"" of type '" "double""'");
3217 }
3218 arg2 = (double)(val2);
3219 if (arg1) (arg1)->max = arg2;
3220 ST(argvi) = &PL_sv_undef;
3221
3222
3223 XSRETURN(argvi);
3224 fail:
3225
3226
3227 SWIG_croak_null();
3228 }
3229 }
3230
3231
XS(_wrap_gsl_rstat_workspace_max_get)3232 XS(_wrap_gsl_rstat_workspace_max_get) {
3233 {
3234 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3235 void *argp1 = 0 ;
3236 int res1 = 0 ;
3237 int argvi = 0;
3238 double result;
3239 dXSARGS;
3240
3241 if ((items < 1) || (items > 1)) {
3242 SWIG_croak("Usage: gsl_rstat_workspace_max_get(self);");
3243 }
3244 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3245 if (!SWIG_IsOK(res1)) {
3246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_max_get" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3247 }
3248 arg1 = (gsl_rstat_workspace *)(argp1);
3249 result = (double) ((arg1)->max);
3250 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3251
3252 XSRETURN(argvi);
3253 fail:
3254
3255 SWIG_croak_null();
3256 }
3257 }
3258
3259
XS(_wrap_gsl_rstat_workspace_mean_set)3260 XS(_wrap_gsl_rstat_workspace_mean_set) {
3261 {
3262 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3263 double arg2 ;
3264 void *argp1 = 0 ;
3265 int res1 = 0 ;
3266 double val2 ;
3267 int ecode2 = 0 ;
3268 int argvi = 0;
3269 dXSARGS;
3270
3271 if ((items < 2) || (items > 2)) {
3272 SWIG_croak("Usage: gsl_rstat_workspace_mean_set(self,mean);");
3273 }
3274 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3275 if (!SWIG_IsOK(res1)) {
3276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_mean_set" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3277 }
3278 arg1 = (gsl_rstat_workspace *)(argp1);
3279 ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
3280 if (!SWIG_IsOK(ecode2)) {
3281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_rstat_workspace_mean_set" "', argument " "2"" of type '" "double""'");
3282 }
3283 arg2 = (double)(val2);
3284 if (arg1) (arg1)->mean = arg2;
3285 ST(argvi) = &PL_sv_undef;
3286
3287
3288 XSRETURN(argvi);
3289 fail:
3290
3291
3292 SWIG_croak_null();
3293 }
3294 }
3295
3296
XS(_wrap_gsl_rstat_workspace_mean_get)3297 XS(_wrap_gsl_rstat_workspace_mean_get) {
3298 {
3299 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3300 void *argp1 = 0 ;
3301 int res1 = 0 ;
3302 int argvi = 0;
3303 double result;
3304 dXSARGS;
3305
3306 if ((items < 1) || (items > 1)) {
3307 SWIG_croak("Usage: gsl_rstat_workspace_mean_get(self);");
3308 }
3309 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3310 if (!SWIG_IsOK(res1)) {
3311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_mean_get" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3312 }
3313 arg1 = (gsl_rstat_workspace *)(argp1);
3314 result = (double) ((arg1)->mean);
3315 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3316
3317 XSRETURN(argvi);
3318 fail:
3319
3320 SWIG_croak_null();
3321 }
3322 }
3323
3324
XS(_wrap_gsl_rstat_workspace_M2_set)3325 XS(_wrap_gsl_rstat_workspace_M2_set) {
3326 {
3327 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3328 double arg2 ;
3329 void *argp1 = 0 ;
3330 int res1 = 0 ;
3331 double val2 ;
3332 int ecode2 = 0 ;
3333 int argvi = 0;
3334 dXSARGS;
3335
3336 if ((items < 2) || (items > 2)) {
3337 SWIG_croak("Usage: gsl_rstat_workspace_M2_set(self,M2);");
3338 }
3339 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3340 if (!SWIG_IsOK(res1)) {
3341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_M2_set" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3342 }
3343 arg1 = (gsl_rstat_workspace *)(argp1);
3344 ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
3345 if (!SWIG_IsOK(ecode2)) {
3346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_rstat_workspace_M2_set" "', argument " "2"" of type '" "double""'");
3347 }
3348 arg2 = (double)(val2);
3349 if (arg1) (arg1)->M2 = arg2;
3350 ST(argvi) = &PL_sv_undef;
3351
3352
3353 XSRETURN(argvi);
3354 fail:
3355
3356
3357 SWIG_croak_null();
3358 }
3359 }
3360
3361
XS(_wrap_gsl_rstat_workspace_M2_get)3362 XS(_wrap_gsl_rstat_workspace_M2_get) {
3363 {
3364 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3365 void *argp1 = 0 ;
3366 int res1 = 0 ;
3367 int argvi = 0;
3368 double result;
3369 dXSARGS;
3370
3371 if ((items < 1) || (items > 1)) {
3372 SWIG_croak("Usage: gsl_rstat_workspace_M2_get(self);");
3373 }
3374 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3375 if (!SWIG_IsOK(res1)) {
3376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_M2_get" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3377 }
3378 arg1 = (gsl_rstat_workspace *)(argp1);
3379 result = (double) ((arg1)->M2);
3380 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3381
3382 XSRETURN(argvi);
3383 fail:
3384
3385 SWIG_croak_null();
3386 }
3387 }
3388
3389
XS(_wrap_gsl_rstat_workspace_M3_set)3390 XS(_wrap_gsl_rstat_workspace_M3_set) {
3391 {
3392 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3393 double arg2 ;
3394 void *argp1 = 0 ;
3395 int res1 = 0 ;
3396 double val2 ;
3397 int ecode2 = 0 ;
3398 int argvi = 0;
3399 dXSARGS;
3400
3401 if ((items < 2) || (items > 2)) {
3402 SWIG_croak("Usage: gsl_rstat_workspace_M3_set(self,M3);");
3403 }
3404 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3405 if (!SWIG_IsOK(res1)) {
3406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_M3_set" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3407 }
3408 arg1 = (gsl_rstat_workspace *)(argp1);
3409 ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
3410 if (!SWIG_IsOK(ecode2)) {
3411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_rstat_workspace_M3_set" "', argument " "2"" of type '" "double""'");
3412 }
3413 arg2 = (double)(val2);
3414 if (arg1) (arg1)->M3 = arg2;
3415 ST(argvi) = &PL_sv_undef;
3416
3417
3418 XSRETURN(argvi);
3419 fail:
3420
3421
3422 SWIG_croak_null();
3423 }
3424 }
3425
3426
XS(_wrap_gsl_rstat_workspace_M3_get)3427 XS(_wrap_gsl_rstat_workspace_M3_get) {
3428 {
3429 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3430 void *argp1 = 0 ;
3431 int res1 = 0 ;
3432 int argvi = 0;
3433 double result;
3434 dXSARGS;
3435
3436 if ((items < 1) || (items > 1)) {
3437 SWIG_croak("Usage: gsl_rstat_workspace_M3_get(self);");
3438 }
3439 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3440 if (!SWIG_IsOK(res1)) {
3441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_M3_get" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3442 }
3443 arg1 = (gsl_rstat_workspace *)(argp1);
3444 result = (double) ((arg1)->M3);
3445 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3446
3447 XSRETURN(argvi);
3448 fail:
3449
3450 SWIG_croak_null();
3451 }
3452 }
3453
3454
XS(_wrap_gsl_rstat_workspace_M4_set)3455 XS(_wrap_gsl_rstat_workspace_M4_set) {
3456 {
3457 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3458 double arg2 ;
3459 void *argp1 = 0 ;
3460 int res1 = 0 ;
3461 double val2 ;
3462 int ecode2 = 0 ;
3463 int argvi = 0;
3464 dXSARGS;
3465
3466 if ((items < 2) || (items > 2)) {
3467 SWIG_croak("Usage: gsl_rstat_workspace_M4_set(self,M4);");
3468 }
3469 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3470 if (!SWIG_IsOK(res1)) {
3471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_M4_set" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3472 }
3473 arg1 = (gsl_rstat_workspace *)(argp1);
3474 ecode2 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
3475 if (!SWIG_IsOK(ecode2)) {
3476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_rstat_workspace_M4_set" "', argument " "2"" of type '" "double""'");
3477 }
3478 arg2 = (double)(val2);
3479 if (arg1) (arg1)->M4 = arg2;
3480 ST(argvi) = &PL_sv_undef;
3481
3482
3483 XSRETURN(argvi);
3484 fail:
3485
3486
3487 SWIG_croak_null();
3488 }
3489 }
3490
3491
XS(_wrap_gsl_rstat_workspace_M4_get)3492 XS(_wrap_gsl_rstat_workspace_M4_get) {
3493 {
3494 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3495 void *argp1 = 0 ;
3496 int res1 = 0 ;
3497 int argvi = 0;
3498 double result;
3499 dXSARGS;
3500
3501 if ((items < 1) || (items > 1)) {
3502 SWIG_croak("Usage: gsl_rstat_workspace_M4_get(self);");
3503 }
3504 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3505 if (!SWIG_IsOK(res1)) {
3506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_M4_get" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3507 }
3508 arg1 = (gsl_rstat_workspace *)(argp1);
3509 result = (double) ((arg1)->M4);
3510 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3511
3512 XSRETURN(argvi);
3513 fail:
3514
3515 SWIG_croak_null();
3516 }
3517 }
3518
3519
XS(_wrap_gsl_rstat_workspace_n_set)3520 XS(_wrap_gsl_rstat_workspace_n_set) {
3521 {
3522 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3523 size_t arg2 ;
3524 void *argp1 = 0 ;
3525 int res1 = 0 ;
3526 size_t val2 ;
3527 int ecode2 = 0 ;
3528 int argvi = 0;
3529 dXSARGS;
3530
3531 if ((items < 2) || (items > 2)) {
3532 SWIG_croak("Usage: gsl_rstat_workspace_n_set(self,n);");
3533 }
3534 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3535 if (!SWIG_IsOK(res1)) {
3536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_n_set" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3537 }
3538 arg1 = (gsl_rstat_workspace *)(argp1);
3539 ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
3540 if (!SWIG_IsOK(ecode2)) {
3541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gsl_rstat_workspace_n_set" "', argument " "2"" of type '" "size_t""'");
3542 }
3543 arg2 = (size_t)(val2);
3544 if (arg1) (arg1)->n = arg2;
3545 ST(argvi) = &PL_sv_undef;
3546
3547
3548 XSRETURN(argvi);
3549 fail:
3550
3551
3552 SWIG_croak_null();
3553 }
3554 }
3555
3556
XS(_wrap_gsl_rstat_workspace_n_get)3557 XS(_wrap_gsl_rstat_workspace_n_get) {
3558 {
3559 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3560 void *argp1 = 0 ;
3561 int res1 = 0 ;
3562 int argvi = 0;
3563 size_t result;
3564 dXSARGS;
3565
3566 if ((items < 1) || (items > 1)) {
3567 SWIG_croak("Usage: gsl_rstat_workspace_n_get(self);");
3568 }
3569 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3570 if (!SWIG_IsOK(res1)) {
3571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_n_get" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3572 }
3573 arg1 = (gsl_rstat_workspace *)(argp1);
3574 result = ((arg1)->n);
3575 ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1((size_t)(result)); argvi++ ;
3576
3577 XSRETURN(argvi);
3578 fail:
3579
3580 SWIG_croak_null();
3581 }
3582 }
3583
3584
XS(_wrap_gsl_rstat_workspace_median_workspace_p_set)3585 XS(_wrap_gsl_rstat_workspace_median_workspace_p_set) {
3586 {
3587 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3588 gsl_rstat_quantile_workspace *arg2 = (gsl_rstat_quantile_workspace *) 0 ;
3589 void *argp1 = 0 ;
3590 int res1 = 0 ;
3591 void *argp2 = 0 ;
3592 int res2 = 0 ;
3593 int argvi = 0;
3594 dXSARGS;
3595
3596 if ((items < 2) || (items > 2)) {
3597 SWIG_croak("Usage: gsl_rstat_workspace_median_workspace_p_set(self,median_workspace_p);");
3598 }
3599 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3600 if (!SWIG_IsOK(res1)) {
3601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_median_workspace_p_set" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3602 }
3603 arg1 = (gsl_rstat_workspace *)(argp1);
3604 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_gsl_rstat_quantile_workspace, SWIG_POINTER_DISOWN | 0 );
3605 if (!SWIG_IsOK(res2)) {
3606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_rstat_workspace_median_workspace_p_set" "', argument " "2"" of type '" "gsl_rstat_quantile_workspace *""'");
3607 }
3608 arg2 = (gsl_rstat_quantile_workspace *)(argp2);
3609 if (arg1) (arg1)->median_workspace_p = arg2;
3610 ST(argvi) = &PL_sv_undef;
3611
3612
3613 XSRETURN(argvi);
3614 fail:
3615
3616
3617 SWIG_croak_null();
3618 }
3619 }
3620
3621
XS(_wrap_gsl_rstat_workspace_median_workspace_p_get)3622 XS(_wrap_gsl_rstat_workspace_median_workspace_p_get) {
3623 {
3624 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3625 void *argp1 = 0 ;
3626 int res1 = 0 ;
3627 int argvi = 0;
3628 gsl_rstat_quantile_workspace *result = 0 ;
3629 dXSARGS;
3630
3631 if ((items < 1) || (items > 1)) {
3632 SWIG_croak("Usage: gsl_rstat_workspace_median_workspace_p_get(self);");
3633 }
3634 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3635 if (!SWIG_IsOK(res1)) {
3636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_workspace_median_workspace_p_get" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3637 }
3638 arg1 = (gsl_rstat_workspace *)(argp1);
3639 result = (gsl_rstat_quantile_workspace *) ((arg1)->median_workspace_p);
3640 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gsl_rstat_quantile_workspace, 0 | SWIG_SHADOW); argvi++ ;
3641
3642 XSRETURN(argvi);
3643 fail:
3644
3645 SWIG_croak_null();
3646 }
3647 }
3648
3649
XS(_wrap_new_gsl_rstat_workspace)3650 XS(_wrap_new_gsl_rstat_workspace) {
3651 {
3652 int argvi = 0;
3653 gsl_rstat_workspace *result = 0 ;
3654 dXSARGS;
3655
3656 if ((items < 0) || (items > 0)) {
3657 SWIG_croak("Usage: new_gsl_rstat_workspace();");
3658 }
3659 result = (gsl_rstat_workspace *)calloc(1, sizeof(gsl_rstat_workspace));
3660 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gsl_rstat_workspace, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
3661 XSRETURN(argvi);
3662 fail:
3663 SWIG_croak_null();
3664 }
3665 }
3666
3667
XS(_wrap_delete_gsl_rstat_workspace)3668 XS(_wrap_delete_gsl_rstat_workspace) {
3669 {
3670 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3671 void *argp1 = 0 ;
3672 int res1 = 0 ;
3673 int argvi = 0;
3674 dXSARGS;
3675
3676 if ((items < 1) || (items > 1)) {
3677 SWIG_croak("Usage: delete_gsl_rstat_workspace(self);");
3678 }
3679 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, SWIG_POINTER_DISOWN | 0 );
3680 if (!SWIG_IsOK(res1)) {
3681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gsl_rstat_workspace" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3682 }
3683 arg1 = (gsl_rstat_workspace *)(argp1);
3684 free((char *) arg1);
3685 ST(argvi) = &PL_sv_undef;
3686
3687 XSRETURN(argvi);
3688 fail:
3689
3690 SWIG_croak_null();
3691 }
3692 }
3693
3694
XS(_wrap_gsl_rstat_alloc)3695 XS(_wrap_gsl_rstat_alloc) {
3696 {
3697 int argvi = 0;
3698 gsl_rstat_workspace *result = 0 ;
3699 dXSARGS;
3700
3701 if ((items < 0) || (items > 0)) {
3702 SWIG_croak("Usage: gsl_rstat_alloc();");
3703 }
3704 result = (gsl_rstat_workspace *)gsl_rstat_alloc();
3705 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gsl_rstat_workspace, 0 | SWIG_SHADOW); argvi++ ;
3706 XSRETURN(argvi);
3707 fail:
3708 SWIG_croak_null();
3709 }
3710 }
3711
3712
XS(_wrap_gsl_rstat_free)3713 XS(_wrap_gsl_rstat_free) {
3714 {
3715 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3716 void *argp1 = 0 ;
3717 int res1 = 0 ;
3718 int argvi = 0;
3719 dXSARGS;
3720
3721 if ((items < 1) || (items > 1)) {
3722 SWIG_croak("Usage: gsl_rstat_free(w);");
3723 }
3724 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3725 if (!SWIG_IsOK(res1)) {
3726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_free" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
3727 }
3728 arg1 = (gsl_rstat_workspace *)(argp1);
3729 gsl_rstat_free(arg1);
3730 ST(argvi) = &PL_sv_undef;
3731
3732 XSRETURN(argvi);
3733 fail:
3734
3735 SWIG_croak_null();
3736 }
3737 }
3738
3739
XS(_wrap_gsl_rstat_n)3740 XS(_wrap_gsl_rstat_n) {
3741 {
3742 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3743 void *argp1 = 0 ;
3744 int res1 = 0 ;
3745 int argvi = 0;
3746 size_t result;
3747 dXSARGS;
3748
3749 if ((items < 1) || (items > 1)) {
3750 SWIG_croak("Usage: gsl_rstat_n(w);");
3751 }
3752 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3753 if (!SWIG_IsOK(res1)) {
3754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_n" "', argument " "1"" of type '" "gsl_rstat_workspace const *""'");
3755 }
3756 arg1 = (gsl_rstat_workspace *)(argp1);
3757 result = gsl_rstat_n((gsl_rstat_workspace const *)arg1);
3758 ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1((size_t)(result)); argvi++ ;
3759
3760 XSRETURN(argvi);
3761 fail:
3762
3763 SWIG_croak_null();
3764 }
3765 }
3766
3767
XS(_wrap_gsl_rstat_add)3768 XS(_wrap_gsl_rstat_add) {
3769 {
3770 double arg1 ;
3771 gsl_rstat_workspace *arg2 = (gsl_rstat_workspace *) 0 ;
3772 double val1 ;
3773 int ecode1 = 0 ;
3774 void *argp2 = 0 ;
3775 int res2 = 0 ;
3776 int argvi = 0;
3777 int result;
3778 dXSARGS;
3779
3780 if ((items < 2) || (items > 2)) {
3781 SWIG_croak("Usage: gsl_rstat_add(x,w);");
3782 }
3783 ecode1 = SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
3784 if (!SWIG_IsOK(ecode1)) {
3785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gsl_rstat_add" "', argument " "1"" of type '" "double""'");
3786 }
3787 arg1 = (double)(val1);
3788 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3789 if (!SWIG_IsOK(res2)) {
3790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gsl_rstat_add" "', argument " "2"" of type '" "gsl_rstat_workspace *""'");
3791 }
3792 arg2 = (gsl_rstat_workspace *)(argp2);
3793 result = (int)gsl_rstat_add(arg1,arg2);
3794 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3795
3796
3797 XSRETURN(argvi);
3798 fail:
3799
3800
3801 SWIG_croak_null();
3802 }
3803 }
3804
3805
XS(_wrap_gsl_rstat_min)3806 XS(_wrap_gsl_rstat_min) {
3807 {
3808 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3809 void *argp1 = 0 ;
3810 int res1 = 0 ;
3811 int argvi = 0;
3812 double result;
3813 dXSARGS;
3814
3815 if ((items < 1) || (items > 1)) {
3816 SWIG_croak("Usage: gsl_rstat_min(w);");
3817 }
3818 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3819 if (!SWIG_IsOK(res1)) {
3820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_min" "', argument " "1"" of type '" "gsl_rstat_workspace const *""'");
3821 }
3822 arg1 = (gsl_rstat_workspace *)(argp1);
3823 result = (double)gsl_rstat_min((gsl_rstat_workspace const *)arg1);
3824 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3825
3826 XSRETURN(argvi);
3827 fail:
3828
3829 SWIG_croak_null();
3830 }
3831 }
3832
3833
XS(_wrap_gsl_rstat_max)3834 XS(_wrap_gsl_rstat_max) {
3835 {
3836 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3837 void *argp1 = 0 ;
3838 int res1 = 0 ;
3839 int argvi = 0;
3840 double result;
3841 dXSARGS;
3842
3843 if ((items < 1) || (items > 1)) {
3844 SWIG_croak("Usage: gsl_rstat_max(w);");
3845 }
3846 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3847 if (!SWIG_IsOK(res1)) {
3848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_max" "', argument " "1"" of type '" "gsl_rstat_workspace const *""'");
3849 }
3850 arg1 = (gsl_rstat_workspace *)(argp1);
3851 result = (double)gsl_rstat_max((gsl_rstat_workspace const *)arg1);
3852 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3853
3854 XSRETURN(argvi);
3855 fail:
3856
3857 SWIG_croak_null();
3858 }
3859 }
3860
3861
XS(_wrap_gsl_rstat_mean)3862 XS(_wrap_gsl_rstat_mean) {
3863 {
3864 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3865 void *argp1 = 0 ;
3866 int res1 = 0 ;
3867 int argvi = 0;
3868 double result;
3869 dXSARGS;
3870
3871 if ((items < 1) || (items > 1)) {
3872 SWIG_croak("Usage: gsl_rstat_mean(w);");
3873 }
3874 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3875 if (!SWIG_IsOK(res1)) {
3876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_mean" "', argument " "1"" of type '" "gsl_rstat_workspace const *""'");
3877 }
3878 arg1 = (gsl_rstat_workspace *)(argp1);
3879 result = (double)gsl_rstat_mean((gsl_rstat_workspace const *)arg1);
3880 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3881
3882 XSRETURN(argvi);
3883 fail:
3884
3885 SWIG_croak_null();
3886 }
3887 }
3888
3889
XS(_wrap_gsl_rstat_variance)3890 XS(_wrap_gsl_rstat_variance) {
3891 {
3892 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3893 void *argp1 = 0 ;
3894 int res1 = 0 ;
3895 int argvi = 0;
3896 double result;
3897 dXSARGS;
3898
3899 if ((items < 1) || (items > 1)) {
3900 SWIG_croak("Usage: gsl_rstat_variance(w);");
3901 }
3902 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3903 if (!SWIG_IsOK(res1)) {
3904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_variance" "', argument " "1"" of type '" "gsl_rstat_workspace const *""'");
3905 }
3906 arg1 = (gsl_rstat_workspace *)(argp1);
3907 result = (double)gsl_rstat_variance((gsl_rstat_workspace const *)arg1);
3908 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3909
3910 XSRETURN(argvi);
3911 fail:
3912
3913 SWIG_croak_null();
3914 }
3915 }
3916
3917
XS(_wrap_gsl_rstat_sd)3918 XS(_wrap_gsl_rstat_sd) {
3919 {
3920 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3921 void *argp1 = 0 ;
3922 int res1 = 0 ;
3923 int argvi = 0;
3924 double result;
3925 dXSARGS;
3926
3927 if ((items < 1) || (items > 1)) {
3928 SWIG_croak("Usage: gsl_rstat_sd(w);");
3929 }
3930 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3931 if (!SWIG_IsOK(res1)) {
3932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_sd" "', argument " "1"" of type '" "gsl_rstat_workspace const *""'");
3933 }
3934 arg1 = (gsl_rstat_workspace *)(argp1);
3935 result = (double)gsl_rstat_sd((gsl_rstat_workspace const *)arg1);
3936 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3937
3938 XSRETURN(argvi);
3939 fail:
3940
3941 SWIG_croak_null();
3942 }
3943 }
3944
3945
XS(_wrap_gsl_rstat_rms)3946 XS(_wrap_gsl_rstat_rms) {
3947 {
3948 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3949 void *argp1 = 0 ;
3950 int res1 = 0 ;
3951 int argvi = 0;
3952 double result;
3953 dXSARGS;
3954
3955 if ((items < 1) || (items > 1)) {
3956 SWIG_croak("Usage: gsl_rstat_rms(w);");
3957 }
3958 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3959 if (!SWIG_IsOK(res1)) {
3960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_rms" "', argument " "1"" of type '" "gsl_rstat_workspace const *""'");
3961 }
3962 arg1 = (gsl_rstat_workspace *)(argp1);
3963 result = (double)gsl_rstat_rms((gsl_rstat_workspace const *)arg1);
3964 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3965
3966 XSRETURN(argvi);
3967 fail:
3968
3969 SWIG_croak_null();
3970 }
3971 }
3972
3973
XS(_wrap_gsl_rstat_sd_mean)3974 XS(_wrap_gsl_rstat_sd_mean) {
3975 {
3976 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
3977 void *argp1 = 0 ;
3978 int res1 = 0 ;
3979 int argvi = 0;
3980 double result;
3981 dXSARGS;
3982
3983 if ((items < 1) || (items > 1)) {
3984 SWIG_croak("Usage: gsl_rstat_sd_mean(w);");
3985 }
3986 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
3987 if (!SWIG_IsOK(res1)) {
3988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_sd_mean" "', argument " "1"" of type '" "gsl_rstat_workspace const *""'");
3989 }
3990 arg1 = (gsl_rstat_workspace *)(argp1);
3991 result = (double)gsl_rstat_sd_mean((gsl_rstat_workspace const *)arg1);
3992 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
3993
3994 XSRETURN(argvi);
3995 fail:
3996
3997 SWIG_croak_null();
3998 }
3999 }
4000
4001
XS(_wrap_gsl_rstat_median)4002 XS(_wrap_gsl_rstat_median) {
4003 {
4004 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
4005 void *argp1 = 0 ;
4006 int res1 = 0 ;
4007 int argvi = 0;
4008 double result;
4009 dXSARGS;
4010
4011 if ((items < 1) || (items > 1)) {
4012 SWIG_croak("Usage: gsl_rstat_median(w);");
4013 }
4014 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
4015 if (!SWIG_IsOK(res1)) {
4016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_median" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
4017 }
4018 arg1 = (gsl_rstat_workspace *)(argp1);
4019 result = (double)gsl_rstat_median(arg1);
4020 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
4021
4022 XSRETURN(argvi);
4023 fail:
4024
4025 SWIG_croak_null();
4026 }
4027 }
4028
4029
XS(_wrap_gsl_rstat_skew)4030 XS(_wrap_gsl_rstat_skew) {
4031 {
4032 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
4033 void *argp1 = 0 ;
4034 int res1 = 0 ;
4035 int argvi = 0;
4036 double result;
4037 dXSARGS;
4038
4039 if ((items < 1) || (items > 1)) {
4040 SWIG_croak("Usage: gsl_rstat_skew(w);");
4041 }
4042 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
4043 if (!SWIG_IsOK(res1)) {
4044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_skew" "', argument " "1"" of type '" "gsl_rstat_workspace const *""'");
4045 }
4046 arg1 = (gsl_rstat_workspace *)(argp1);
4047 result = (double)gsl_rstat_skew((gsl_rstat_workspace const *)arg1);
4048 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
4049
4050 XSRETURN(argvi);
4051 fail:
4052
4053 SWIG_croak_null();
4054 }
4055 }
4056
4057
XS(_wrap_gsl_rstat_kurtosis)4058 XS(_wrap_gsl_rstat_kurtosis) {
4059 {
4060 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
4061 void *argp1 = 0 ;
4062 int res1 = 0 ;
4063 int argvi = 0;
4064 double result;
4065 dXSARGS;
4066
4067 if ((items < 1) || (items > 1)) {
4068 SWIG_croak("Usage: gsl_rstat_kurtosis(w);");
4069 }
4070 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
4071 if (!SWIG_IsOK(res1)) {
4072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_kurtosis" "', argument " "1"" of type '" "gsl_rstat_workspace const *""'");
4073 }
4074 arg1 = (gsl_rstat_workspace *)(argp1);
4075 result = (double)gsl_rstat_kurtosis((gsl_rstat_workspace const *)arg1);
4076 ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(result)); argvi++ ;
4077
4078 XSRETURN(argvi);
4079 fail:
4080
4081 SWIG_croak_null();
4082 }
4083 }
4084
4085
XS(_wrap_gsl_rstat_reset)4086 XS(_wrap_gsl_rstat_reset) {
4087 {
4088 gsl_rstat_workspace *arg1 = (gsl_rstat_workspace *) 0 ;
4089 void *argp1 = 0 ;
4090 int res1 = 0 ;
4091 int argvi = 0;
4092 int result;
4093 dXSARGS;
4094
4095 if ((items < 1) || (items > 1)) {
4096 SWIG_croak("Usage: gsl_rstat_reset(w);");
4097 }
4098 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_gsl_rstat_workspace, 0 | 0 );
4099 if (!SWIG_IsOK(res1)) {
4100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gsl_rstat_reset" "', argument " "1"" of type '" "gsl_rstat_workspace *""'");
4101 }
4102 arg1 = (gsl_rstat_workspace *)(argp1);
4103 result = (int)gsl_rstat_reset(arg1);
4104 ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
4105
4106 XSRETURN(argvi);
4107 fail:
4108
4109 SWIG_croak_null();
4110 }
4111 }
4112
4113
4114
4115 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
4116
4117 static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
4118 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
4119 static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
4120 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};
4121 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};
4122 static swig_type_info _swigt__p_gsl_rstat_quantile_workspace = {"_p_gsl_rstat_quantile_workspace", "gsl_rstat_quantile_workspace *", 0, 0, (void*)"Math::GSL::Rstat::gsl_rstat_quantile_workspace", 0};
4123 static swig_type_info _swigt__p_gsl_rstat_workspace = {"_p_gsl_rstat_workspace", "gsl_rstat_workspace *", 0, 0, (void*)"Math::GSL::Rstat::gsl_rstat_workspace", 0};
4124 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
4125
4126 static swig_type_info *swig_type_initial[] = {
4127 &_swigt__p_FILE,
4128 &_swigt__p_char,
4129 &_swigt__p_double,
4130 &_swigt__p_f_p_q_const__char_p_q_const__char_int_int__void,
4131 &_swigt__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void,
4132 &_swigt__p_gsl_rstat_quantile_workspace,
4133 &_swigt__p_gsl_rstat_workspace,
4134 &_swigt__p_int,
4135 };
4136
4137 static swig_cast_info _swigc__p_FILE[] = { {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
4138 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
4139 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
4140 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}};
4141 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}};
4142 static swig_cast_info _swigc__p_gsl_rstat_quantile_workspace[] = { {&_swigt__p_gsl_rstat_quantile_workspace, 0, 0, 0},{0, 0, 0, 0}};
4143 static swig_cast_info _swigc__p_gsl_rstat_workspace[] = { {&_swigt__p_gsl_rstat_workspace, 0, 0, 0},{0, 0, 0, 0}};
4144 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
4145
4146 static swig_cast_info *swig_cast_initial[] = {
4147 _swigc__p_FILE,
4148 _swigc__p_char,
4149 _swigc__p_double,
4150 _swigc__p_f_p_q_const__char_p_q_const__char_int_int__void,
4151 _swigc__p_f_p_q_const__char_p_q_const__char_int_p_q_const__char__void,
4152 _swigc__p_gsl_rstat_quantile_workspace,
4153 _swigc__p_gsl_rstat_workspace,
4154 _swigc__p_int,
4155 };
4156
4157
4158 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
4159
4160 static swig_constant_info swig_constants[] = {
4161 {0,0,0,0,0,0}
4162 };
4163 #ifdef __cplusplus
4164 }
4165 #endif
4166 static swig_variable_info swig_variables[] = {
4167 {0,0,0,0}
4168 };
4169 static swig_command_info swig_commands[] = {
4170 {"Math::GSL::Rstatc::gsl_error", _wrap_gsl_error},
4171 {"Math::GSL::Rstatc::gsl_stream_printf", _wrap_gsl_stream_printf},
4172 {"Math::GSL::Rstatc::gsl_strerror", _wrap_gsl_strerror},
4173 {"Math::GSL::Rstatc::gsl_set_error_handler", _wrap_gsl_set_error_handler},
4174 {"Math::GSL::Rstatc::gsl_set_error_handler_off", _wrap_gsl_set_error_handler_off},
4175 {"Math::GSL::Rstatc::gsl_set_stream_handler", _wrap_gsl_set_stream_handler},
4176 {"Math::GSL::Rstatc::gsl_set_stream", _wrap_gsl_set_stream},
4177 {"Math::GSL::Rstatc::gsl_rstat_quantile_workspace_p_set", _wrap_gsl_rstat_quantile_workspace_p_set},
4178 {"Math::GSL::Rstatc::gsl_rstat_quantile_workspace_p_get", _wrap_gsl_rstat_quantile_workspace_p_get},
4179 {"Math::GSL::Rstatc::gsl_rstat_quantile_workspace_q_set", _wrap_gsl_rstat_quantile_workspace_q_set},
4180 {"Math::GSL::Rstatc::gsl_rstat_quantile_workspace_q_get", _wrap_gsl_rstat_quantile_workspace_q_get},
4181 {"Math::GSL::Rstatc::gsl_rstat_quantile_workspace_npos_set", _wrap_gsl_rstat_quantile_workspace_npos_set},
4182 {"Math::GSL::Rstatc::gsl_rstat_quantile_workspace_npos_get", _wrap_gsl_rstat_quantile_workspace_npos_get},
4183 {"Math::GSL::Rstatc::gsl_rstat_quantile_workspace_np_set", _wrap_gsl_rstat_quantile_workspace_np_set},
4184 {"Math::GSL::Rstatc::gsl_rstat_quantile_workspace_np_get", _wrap_gsl_rstat_quantile_workspace_np_get},
4185 {"Math::GSL::Rstatc::gsl_rstat_quantile_workspace_dnp_set", _wrap_gsl_rstat_quantile_workspace_dnp_set},
4186 {"Math::GSL::Rstatc::gsl_rstat_quantile_workspace_dnp_get", _wrap_gsl_rstat_quantile_workspace_dnp_get},
4187 {"Math::GSL::Rstatc::gsl_rstat_quantile_workspace_n_set", _wrap_gsl_rstat_quantile_workspace_n_set},
4188 {"Math::GSL::Rstatc::gsl_rstat_quantile_workspace_n_get", _wrap_gsl_rstat_quantile_workspace_n_get},
4189 {"Math::GSL::Rstatc::new_gsl_rstat_quantile_workspace", _wrap_new_gsl_rstat_quantile_workspace},
4190 {"Math::GSL::Rstatc::delete_gsl_rstat_quantile_workspace", _wrap_delete_gsl_rstat_quantile_workspace},
4191 {"Math::GSL::Rstatc::gsl_rstat_quantile_alloc", _wrap_gsl_rstat_quantile_alloc},
4192 {"Math::GSL::Rstatc::gsl_rstat_quantile_free", _wrap_gsl_rstat_quantile_free},
4193 {"Math::GSL::Rstatc::gsl_rstat_quantile_reset", _wrap_gsl_rstat_quantile_reset},
4194 {"Math::GSL::Rstatc::gsl_rstat_quantile_add", _wrap_gsl_rstat_quantile_add},
4195 {"Math::GSL::Rstatc::gsl_rstat_quantile_get", _wrap_gsl_rstat_quantile_get},
4196 {"Math::GSL::Rstatc::gsl_rstat_workspace_min_set", _wrap_gsl_rstat_workspace_min_set},
4197 {"Math::GSL::Rstatc::gsl_rstat_workspace_min_get", _wrap_gsl_rstat_workspace_min_get},
4198 {"Math::GSL::Rstatc::gsl_rstat_workspace_max_set", _wrap_gsl_rstat_workspace_max_set},
4199 {"Math::GSL::Rstatc::gsl_rstat_workspace_max_get", _wrap_gsl_rstat_workspace_max_get},
4200 {"Math::GSL::Rstatc::gsl_rstat_workspace_mean_set", _wrap_gsl_rstat_workspace_mean_set},
4201 {"Math::GSL::Rstatc::gsl_rstat_workspace_mean_get", _wrap_gsl_rstat_workspace_mean_get},
4202 {"Math::GSL::Rstatc::gsl_rstat_workspace_M2_set", _wrap_gsl_rstat_workspace_M2_set},
4203 {"Math::GSL::Rstatc::gsl_rstat_workspace_M2_get", _wrap_gsl_rstat_workspace_M2_get},
4204 {"Math::GSL::Rstatc::gsl_rstat_workspace_M3_set", _wrap_gsl_rstat_workspace_M3_set},
4205 {"Math::GSL::Rstatc::gsl_rstat_workspace_M3_get", _wrap_gsl_rstat_workspace_M3_get},
4206 {"Math::GSL::Rstatc::gsl_rstat_workspace_M4_set", _wrap_gsl_rstat_workspace_M4_set},
4207 {"Math::GSL::Rstatc::gsl_rstat_workspace_M4_get", _wrap_gsl_rstat_workspace_M4_get},
4208 {"Math::GSL::Rstatc::gsl_rstat_workspace_n_set", _wrap_gsl_rstat_workspace_n_set},
4209 {"Math::GSL::Rstatc::gsl_rstat_workspace_n_get", _wrap_gsl_rstat_workspace_n_get},
4210 {"Math::GSL::Rstatc::gsl_rstat_workspace_median_workspace_p_set", _wrap_gsl_rstat_workspace_median_workspace_p_set},
4211 {"Math::GSL::Rstatc::gsl_rstat_workspace_median_workspace_p_get", _wrap_gsl_rstat_workspace_median_workspace_p_get},
4212 {"Math::GSL::Rstatc::new_gsl_rstat_workspace", _wrap_new_gsl_rstat_workspace},
4213 {"Math::GSL::Rstatc::delete_gsl_rstat_workspace", _wrap_delete_gsl_rstat_workspace},
4214 {"Math::GSL::Rstatc::gsl_rstat_alloc", _wrap_gsl_rstat_alloc},
4215 {"Math::GSL::Rstatc::gsl_rstat_free", _wrap_gsl_rstat_free},
4216 {"Math::GSL::Rstatc::gsl_rstat_n", _wrap_gsl_rstat_n},
4217 {"Math::GSL::Rstatc::gsl_rstat_add", _wrap_gsl_rstat_add},
4218 {"Math::GSL::Rstatc::gsl_rstat_min", _wrap_gsl_rstat_min},
4219 {"Math::GSL::Rstatc::gsl_rstat_max", _wrap_gsl_rstat_max},
4220 {"Math::GSL::Rstatc::gsl_rstat_mean", _wrap_gsl_rstat_mean},
4221 {"Math::GSL::Rstatc::gsl_rstat_variance", _wrap_gsl_rstat_variance},
4222 {"Math::GSL::Rstatc::gsl_rstat_sd", _wrap_gsl_rstat_sd},
4223 {"Math::GSL::Rstatc::gsl_rstat_rms", _wrap_gsl_rstat_rms},
4224 {"Math::GSL::Rstatc::gsl_rstat_sd_mean", _wrap_gsl_rstat_sd_mean},
4225 {"Math::GSL::Rstatc::gsl_rstat_median", _wrap_gsl_rstat_median},
4226 {"Math::GSL::Rstatc::gsl_rstat_skew", _wrap_gsl_rstat_skew},
4227 {"Math::GSL::Rstatc::gsl_rstat_kurtosis", _wrap_gsl_rstat_kurtosis},
4228 {"Math::GSL::Rstatc::gsl_rstat_reset", _wrap_gsl_rstat_reset},
4229 {0,0}
4230 };
4231 /* -----------------------------------------------------------------------------
4232 * Type initialization:
4233 * This problem is tough by the requirement that no dynamic
4234 * memory is used. Also, since swig_type_info structures store pointers to
4235 * swig_cast_info structures and swig_cast_info structures store pointers back
4236 * to swig_type_info structures, we need some lookup code at initialization.
4237 * The idea is that swig generates all the structures that are needed.
4238 * The runtime then collects these partially filled structures.
4239 * The SWIG_InitializeModule function takes these initial arrays out of
4240 * swig_module, and does all the lookup, filling in the swig_module.types
4241 * array with the correct data and linking the correct swig_cast_info
4242 * structures together.
4243 *
4244 * The generated swig_type_info structures are assigned statically to an initial
4245 * array. We just loop through that array, and handle each type individually.
4246 * First we lookup if this type has been already loaded, and if so, use the
4247 * loaded structure instead of the generated one. Then we have to fill in the
4248 * cast linked list. The cast data is initially stored in something like a
4249 * two-dimensional array. Each row corresponds to a type (there are the same
4250 * number of rows as there are in the swig_type_initial array). Each entry in
4251 * a column is one of the swig_cast_info structures for that type.
4252 * The cast_initial array is actually an array of arrays, because each row has
4253 * a variable number of columns. So to actually build the cast linked list,
4254 * we find the array of casts associated with the type, and loop through it
4255 * adding the casts to the list. The one last trick we need to do is making
4256 * sure the type pointer in the swig_cast_info struct is correct.
4257 *
4258 * First off, we lookup the cast->type name to see if it is already loaded.
4259 * There are three cases to handle:
4260 * 1) If the cast->type has already been loaded AND the type we are adding
4261 * casting info to has not been loaded (it is in this module), THEN we
4262 * replace the cast->type pointer with the type pointer that has already
4263 * been loaded.
4264 * 2) If BOTH types (the one we are adding casting info to, and the
4265 * cast->type) are loaded, THEN the cast info has already been loaded by
4266 * the previous module so we just ignore it.
4267 * 3) Finally, if cast->type has not already been loaded, then we add that
4268 * swig_cast_info to the linked list (because the cast->type) pointer will
4269 * be correct.
4270 * ----------------------------------------------------------------------------- */
4271
4272 #ifdef __cplusplus
4273 extern "C" {
4274 #if 0
4275 } /* c-mode */
4276 #endif
4277 #endif
4278
4279 #if 0
4280 #define SWIGRUNTIME_DEBUG
4281 #endif
4282
4283
4284 SWIGRUNTIME void
SWIG_InitializeModule(void * clientdata)4285 SWIG_InitializeModule(void *clientdata) {
4286 size_t i;
4287 swig_module_info *module_head, *iter;
4288 int init;
4289
4290 /* check to see if the circular list has been setup, if not, set it up */
4291 if (swig_module.next==0) {
4292 /* Initialize the swig_module */
4293 swig_module.type_initial = swig_type_initial;
4294 swig_module.cast_initial = swig_cast_initial;
4295 swig_module.next = &swig_module;
4296 init = 1;
4297 } else {
4298 init = 0;
4299 }
4300
4301 /* Try and load any already created modules */
4302 module_head = SWIG_GetModule(clientdata);
4303 if (!module_head) {
4304 /* This is the first module loaded for this interpreter */
4305 /* so set the swig module into the interpreter */
4306 SWIG_SetModule(clientdata, &swig_module);
4307 } else {
4308 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
4309 iter=module_head;
4310 do {
4311 if (iter==&swig_module) {
4312 /* Our module is already in the list, so there's nothing more to do. */
4313 return;
4314 }
4315 iter=iter->next;
4316 } while (iter!= module_head);
4317
4318 /* otherwise we must add our module into the list */
4319 swig_module.next = module_head->next;
4320 module_head->next = &swig_module;
4321 }
4322
4323 /* When multiple interpreters are used, a module could have already been initialized in
4324 a different interpreter, but not yet have a pointer in this interpreter.
4325 In this case, we do not want to continue adding types... everything should be
4326 set up already */
4327 if (init == 0) return;
4328
4329 /* Now work on filling in swig_module.types */
4330 #ifdef SWIGRUNTIME_DEBUG
4331 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
4332 #endif
4333 for (i = 0; i < swig_module.size; ++i) {
4334 swig_type_info *type = 0;
4335 swig_type_info *ret;
4336 swig_cast_info *cast;
4337
4338 #ifdef SWIGRUNTIME_DEBUG
4339 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
4340 #endif
4341
4342 /* if there is another module already loaded */
4343 if (swig_module.next != &swig_module) {
4344 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
4345 }
4346 if (type) {
4347 /* Overwrite clientdata field */
4348 #ifdef SWIGRUNTIME_DEBUG
4349 printf("SWIG_InitializeModule: found type %s\n", type->name);
4350 #endif
4351 if (swig_module.type_initial[i]->clientdata) {
4352 type->clientdata = swig_module.type_initial[i]->clientdata;
4353 #ifdef SWIGRUNTIME_DEBUG
4354 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
4355 #endif
4356 }
4357 } else {
4358 type = swig_module.type_initial[i];
4359 }
4360
4361 /* Insert casting types */
4362 cast = swig_module.cast_initial[i];
4363 while (cast->type) {
4364 /* Don't need to add information already in the list */
4365 ret = 0;
4366 #ifdef SWIGRUNTIME_DEBUG
4367 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
4368 #endif
4369 if (swig_module.next != &swig_module) {
4370 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
4371 #ifdef SWIGRUNTIME_DEBUG
4372 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
4373 #endif
4374 }
4375 if (ret) {
4376 if (type == swig_module.type_initial[i]) {
4377 #ifdef SWIGRUNTIME_DEBUG
4378 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
4379 #endif
4380 cast->type = ret;
4381 ret = 0;
4382 } else {
4383 /* Check for casting already in the list */
4384 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
4385 #ifdef SWIGRUNTIME_DEBUG
4386 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
4387 #endif
4388 if (!ocast) ret = 0;
4389 }
4390 }
4391
4392 if (!ret) {
4393 #ifdef SWIGRUNTIME_DEBUG
4394 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
4395 #endif
4396 if (type->cast) {
4397 type->cast->prev = cast;
4398 cast->next = type->cast;
4399 }
4400 type->cast = cast;
4401 }
4402 cast++;
4403 }
4404 /* Set entry in modules->types array equal to the type */
4405 swig_module.types[i] = type;
4406 }
4407 swig_module.types[i] = 0;
4408
4409 #ifdef SWIGRUNTIME_DEBUG
4410 printf("**** SWIG_InitializeModule: Cast List ******\n");
4411 for (i = 0; i < swig_module.size; ++i) {
4412 int j = 0;
4413 swig_cast_info *cast = swig_module.cast_initial[i];
4414 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
4415 while (cast->type) {
4416 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
4417 cast++;
4418 ++j;
4419 }
4420 printf("---- Total casts: %d\n",j);
4421 }
4422 printf("**** SWIG_InitializeModule: Cast List ******\n");
4423 #endif
4424 }
4425
4426 /* This function will propagate the clientdata field of type to
4427 * any new swig_type_info structures that have been added into the list
4428 * of equivalent types. It is like calling
4429 * SWIG_TypeClientData(type, clientdata) a second time.
4430 */
4431 SWIGRUNTIME void
SWIG_PropagateClientData(void)4432 SWIG_PropagateClientData(void) {
4433 size_t i;
4434 swig_cast_info *equiv;
4435 static int init_run = 0;
4436
4437 if (init_run) return;
4438 init_run = 1;
4439
4440 for (i = 0; i < swig_module.size; i++) {
4441 if (swig_module.types[i]->clientdata) {
4442 equiv = swig_module.types[i]->cast;
4443 while (equiv) {
4444 if (!equiv->converter) {
4445 if (equiv->type && !equiv->type->clientdata)
4446 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
4447 }
4448 equiv = equiv->next;
4449 }
4450 }
4451 }
4452 }
4453
4454 #ifdef __cplusplus
4455 #if 0
4456 {
4457 /* c-mode */
4458 #endif
4459 }
4460 #endif
4461
4462
4463
4464 #if defined(__cplusplus) && ! defined(XSPROTO)
4465 extern "C"
4466 #endif
4467
XS(SWIG_init)4468 XS(SWIG_init) {
4469 dXSARGS;
4470 int i;
4471 (void)items;
4472
4473 SWIG_InitializeModule(0);
4474
4475 /* Install commands */
4476 for (i = 0; swig_commands[i].name; i++) {
4477 /* Casts only needed for Perl < 5.10. */
4478 #ifdef __cplusplus
4479 newXS(const_cast<char*>(swig_commands[i].name), swig_commands[i].wrapper, const_cast<char*>(__FILE__));
4480 #else
4481 newXS((char*)swig_commands[i].name, swig_commands[i].wrapper, (char*)__FILE__);
4482 #endif
4483 }
4484
4485 /* Install variables */
4486 for (i = 0; swig_variables[i].name; i++) {
4487 SV *sv;
4488 sv = get_sv(swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
4489 if (swig_variables[i].type) {
4490 SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
4491 } else {
4492 sv_setiv(sv,(IV) 0);
4493 }
4494 swig_create_magic(sv, swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
4495 }
4496
4497 /* Install constant */
4498 for (i = 0; swig_constants[i].type; i++) {
4499 SV *sv;
4500 sv = get_sv(swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
4501 switch(swig_constants[i].type) {
4502 case SWIG_INT:
4503 sv_setiv(sv, (IV) swig_constants[i].lvalue);
4504 break;
4505 case SWIG_FLOAT:
4506 sv_setnv(sv, (double) swig_constants[i].dvalue);
4507 break;
4508 case SWIG_STRING:
4509 sv_setpv(sv, (const char *) swig_constants[i].pvalue);
4510 break;
4511 case SWIG_POINTER:
4512 SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
4513 break;
4514 case SWIG_BINARY:
4515 SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
4516 break;
4517 default:
4518 break;
4519 }
4520 SvREADONLY_on(sv);
4521 }
4522
4523 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4524 SV *sv = get_sv((char*) SWIG_prefix "GSL_VERSION", TRUE | 0x2 | GV_ADDMULTI);
4525 sv_setsv(sv, SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)(2.7)));
4526 SvREADONLY_on(sv);
4527 } while(0) /*@SWIG@*/;
4528 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4529 SV *sv = get_sv((char*) SWIG_prefix "GSL_MAJOR_VERSION", TRUE | 0x2 | GV_ADDMULTI);
4530 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(2)));
4531 SvREADONLY_on(sv);
4532 } while(0) /*@SWIG@*/;
4533 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4534 SV *sv = get_sv((char*) SWIG_prefix "GSL_MINOR_VERSION", TRUE | 0x2 | GV_ADDMULTI);
4535 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(7)));
4536 SvREADONLY_on(sv);
4537 } while(0) /*@SWIG@*/;
4538 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4539 SV *sv = get_sv((char*) SWIG_prefix "GSL_POSZERO", TRUE | 0x2 | GV_ADDMULTI);
4540 sv_setsv(sv, SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)((+0.0))));
4541 SvREADONLY_on(sv);
4542 } while(0) /*@SWIG@*/;
4543 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4544 SV *sv = get_sv((char*) SWIG_prefix "GSL_NEGZERO", TRUE | 0x2 | GV_ADDMULTI);
4545 sv_setsv(sv, SWIG_From_double SWIG_PERL_CALL_ARGS_1((double)((-0.0))));
4546 SvREADONLY_on(sv);
4547 } while(0) /*@SWIG@*/;
4548 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4549 SV *sv = get_sv((char*) SWIG_prefix "GSL_SUCCESS", TRUE | 0x2 | GV_ADDMULTI);
4550 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_SUCCESS)));
4551 SvREADONLY_on(sv);
4552 } while(0) /*@SWIG@*/;
4553 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4554 SV *sv = get_sv((char*) SWIG_prefix "GSL_FAILURE", TRUE | 0x2 | GV_ADDMULTI);
4555 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_FAILURE)));
4556 SvREADONLY_on(sv);
4557 } while(0) /*@SWIG@*/;
4558 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4559 SV *sv = get_sv((char*) SWIG_prefix "GSL_CONTINUE", TRUE | 0x2 | GV_ADDMULTI);
4560 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_CONTINUE)));
4561 SvREADONLY_on(sv);
4562 } while(0) /*@SWIG@*/;
4563 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4564 SV *sv = get_sv((char*) SWIG_prefix "GSL_EDOM", TRUE | 0x2 | GV_ADDMULTI);
4565 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EDOM)));
4566 SvREADONLY_on(sv);
4567 } while(0) /*@SWIG@*/;
4568 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4569 SV *sv = get_sv((char*) SWIG_prefix "GSL_ERANGE", TRUE | 0x2 | GV_ADDMULTI);
4570 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ERANGE)));
4571 SvREADONLY_on(sv);
4572 } while(0) /*@SWIG@*/;
4573 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4574 SV *sv = get_sv((char*) SWIG_prefix "GSL_EFAULT", TRUE | 0x2 | GV_ADDMULTI);
4575 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EFAULT)));
4576 SvREADONLY_on(sv);
4577 } while(0) /*@SWIG@*/;
4578 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4579 SV *sv = get_sv((char*) SWIG_prefix "GSL_EINVAL", TRUE | 0x2 | GV_ADDMULTI);
4580 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EINVAL)));
4581 SvREADONLY_on(sv);
4582 } while(0) /*@SWIG@*/;
4583 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4584 SV *sv = get_sv((char*) SWIG_prefix "GSL_EFAILED", TRUE | 0x2 | GV_ADDMULTI);
4585 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EFAILED)));
4586 SvREADONLY_on(sv);
4587 } while(0) /*@SWIG@*/;
4588 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4589 SV *sv = get_sv((char*) SWIG_prefix "GSL_EFACTOR", TRUE | 0x2 | GV_ADDMULTI);
4590 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EFACTOR)));
4591 SvREADONLY_on(sv);
4592 } while(0) /*@SWIG@*/;
4593 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4594 SV *sv = get_sv((char*) SWIG_prefix "GSL_ESANITY", TRUE | 0x2 | GV_ADDMULTI);
4595 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ESANITY)));
4596 SvREADONLY_on(sv);
4597 } while(0) /*@SWIG@*/;
4598 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4599 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOMEM", TRUE | 0x2 | GV_ADDMULTI);
4600 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOMEM)));
4601 SvREADONLY_on(sv);
4602 } while(0) /*@SWIG@*/;
4603 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4604 SV *sv = get_sv((char*) SWIG_prefix "GSL_EBADFUNC", TRUE | 0x2 | GV_ADDMULTI);
4605 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EBADFUNC)));
4606 SvREADONLY_on(sv);
4607 } while(0) /*@SWIG@*/;
4608 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4609 SV *sv = get_sv((char*) SWIG_prefix "GSL_ERUNAWAY", TRUE | 0x2 | GV_ADDMULTI);
4610 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ERUNAWAY)));
4611 SvREADONLY_on(sv);
4612 } while(0) /*@SWIG@*/;
4613 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4614 SV *sv = get_sv((char*) SWIG_prefix "GSL_EMAXITER", TRUE | 0x2 | GV_ADDMULTI);
4615 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EMAXITER)));
4616 SvREADONLY_on(sv);
4617 } while(0) /*@SWIG@*/;
4618 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4619 SV *sv = get_sv((char*) SWIG_prefix "GSL_EZERODIV", TRUE | 0x2 | GV_ADDMULTI);
4620 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EZERODIV)));
4621 SvREADONLY_on(sv);
4622 } while(0) /*@SWIG@*/;
4623 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4624 SV *sv = get_sv((char*) SWIG_prefix "GSL_EBADTOL", TRUE | 0x2 | GV_ADDMULTI);
4625 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EBADTOL)));
4626 SvREADONLY_on(sv);
4627 } while(0) /*@SWIG@*/;
4628 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4629 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOL", TRUE | 0x2 | GV_ADDMULTI);
4630 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOL)));
4631 SvREADONLY_on(sv);
4632 } while(0) /*@SWIG@*/;
4633 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4634 SV *sv = get_sv((char*) SWIG_prefix "GSL_EUNDRFLW", TRUE | 0x2 | GV_ADDMULTI);
4635 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EUNDRFLW)));
4636 SvREADONLY_on(sv);
4637 } while(0) /*@SWIG@*/;
4638 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4639 SV *sv = get_sv((char*) SWIG_prefix "GSL_EOVRFLW", TRUE | 0x2 | GV_ADDMULTI);
4640 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EOVRFLW)));
4641 SvREADONLY_on(sv);
4642 } while(0) /*@SWIG@*/;
4643 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4644 SV *sv = get_sv((char*) SWIG_prefix "GSL_ELOSS", TRUE | 0x2 | GV_ADDMULTI);
4645 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ELOSS)));
4646 SvREADONLY_on(sv);
4647 } while(0) /*@SWIG@*/;
4648 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4649 SV *sv = get_sv((char*) SWIG_prefix "GSL_EROUND", TRUE | 0x2 | GV_ADDMULTI);
4650 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EROUND)));
4651 SvREADONLY_on(sv);
4652 } while(0) /*@SWIG@*/;
4653 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4654 SV *sv = get_sv((char*) SWIG_prefix "GSL_EBADLEN", TRUE | 0x2 | GV_ADDMULTI);
4655 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EBADLEN)));
4656 SvREADONLY_on(sv);
4657 } while(0) /*@SWIG@*/;
4658 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4659 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOTSQR", TRUE | 0x2 | GV_ADDMULTI);
4660 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOTSQR)));
4661 SvREADONLY_on(sv);
4662 } while(0) /*@SWIG@*/;
4663 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4664 SV *sv = get_sv((char*) SWIG_prefix "GSL_ESING", TRUE | 0x2 | GV_ADDMULTI);
4665 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ESING)));
4666 SvREADONLY_on(sv);
4667 } while(0) /*@SWIG@*/;
4668 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4669 SV *sv = get_sv((char*) SWIG_prefix "GSL_EDIVERGE", TRUE | 0x2 | GV_ADDMULTI);
4670 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EDIVERGE)));
4671 SvREADONLY_on(sv);
4672 } while(0) /*@SWIG@*/;
4673 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4674 SV *sv = get_sv((char*) SWIG_prefix "GSL_EUNSUP", TRUE | 0x2 | GV_ADDMULTI);
4675 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EUNSUP)));
4676 SvREADONLY_on(sv);
4677 } while(0) /*@SWIG@*/;
4678 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4679 SV *sv = get_sv((char*) SWIG_prefix "GSL_EUNIMPL", TRUE | 0x2 | GV_ADDMULTI);
4680 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EUNIMPL)));
4681 SvREADONLY_on(sv);
4682 } while(0) /*@SWIG@*/;
4683 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4684 SV *sv = get_sv((char*) SWIG_prefix "GSL_ECACHE", TRUE | 0x2 | GV_ADDMULTI);
4685 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ECACHE)));
4686 SvREADONLY_on(sv);
4687 } while(0) /*@SWIG@*/;
4688 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4689 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETABLE", TRUE | 0x2 | GV_ADDMULTI);
4690 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETABLE)));
4691 SvREADONLY_on(sv);
4692 } while(0) /*@SWIG@*/;
4693 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4694 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOPROG", TRUE | 0x2 | GV_ADDMULTI);
4695 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOPROG)));
4696 SvREADONLY_on(sv);
4697 } while(0) /*@SWIG@*/;
4698 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4699 SV *sv = get_sv((char*) SWIG_prefix "GSL_ENOPROGJ", TRUE | 0x2 | GV_ADDMULTI);
4700 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ENOPROGJ)));
4701 SvREADONLY_on(sv);
4702 } while(0) /*@SWIG@*/;
4703 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4704 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOLF", TRUE | 0x2 | GV_ADDMULTI);
4705 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOLF)));
4706 SvREADONLY_on(sv);
4707 } while(0) /*@SWIG@*/;
4708 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4709 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOLX", TRUE | 0x2 | GV_ADDMULTI);
4710 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOLX)));
4711 SvREADONLY_on(sv);
4712 } while(0) /*@SWIG@*/;
4713 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4714 SV *sv = get_sv((char*) SWIG_prefix "GSL_ETOLG", TRUE | 0x2 | GV_ADDMULTI);
4715 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_ETOLG)));
4716 SvREADONLY_on(sv);
4717 } while(0) /*@SWIG@*/;
4718 /*@SWIG:/usr/share/swig4.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4719 SV *sv = get_sv((char*) SWIG_prefix "GSL_EOF", TRUE | 0x2 | GV_ADDMULTI);
4720 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(GSL_EOF)));
4721 SvREADONLY_on(sv);
4722 } while(0) /*@SWIG@*/;
4723 SWIG_TypeClientData(SWIGTYPE_p_gsl_rstat_quantile_workspace, (void*) "Math::GSL::Rstat::gsl_rstat_quantile_workspace");
4724 SWIG_TypeClientData(SWIGTYPE_p_gsl_rstat_workspace, (void*) "Math::GSL::Rstat::gsl_rstat_workspace");
4725 ST(0) = &PL_sv_yes;
4726 XSRETURN(1);
4727 }
4728
4729