PLplot  5.9.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
plplotcmodulePYTHON_wrap.c
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 2.0.10
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13 
14 /* -----------------------------------------------------------------------------
15  * This section contains generic SWIG labels for method/variable
16  * declarations/attributes, and other compiler dependent labels.
17  * ----------------------------------------------------------------------------- */
18 
19 /* template workaround for compilers that cannot correctly implement the C++ standard */
20 #ifndef SWIGTEMPLATEDISAMBIGUATOR
21 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
22 # define SWIGTEMPLATEDISAMBIGUATOR template
23 # elif defined(__HP_aCC)
24 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
25 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
26 # define SWIGTEMPLATEDISAMBIGUATOR template
27 # else
28 # define SWIGTEMPLATEDISAMBIGUATOR
29 # endif
30 #endif
31 
32 /* inline attribute */
33 #ifndef SWIGINLINE
34 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
35 # define SWIGINLINE inline
36 # else
37 # define SWIGINLINE
38 # endif
39 #endif
40 
41 /* attribute recognised by some compilers to avoid 'unused' warnings */
42 #ifndef SWIGUNUSED
43 # if defined(__GNUC__)
44 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
45 # define SWIGUNUSED __attribute__ ((__unused__))
46 # else
47 # define SWIGUNUSED
48 # endif
49 # elif defined(__ICC)
50 # define SWIGUNUSED __attribute__ ((__unused__))
51 # else
52 # define SWIGUNUSED
53 # endif
54 #endif
55 
56 #ifndef SWIG_MSC_UNSUPPRESS_4505
57 # if defined(_MSC_VER)
58 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
59 # endif
60 #endif
61 
62 #ifndef SWIGUNUSEDPARM
63 # ifdef __cplusplus
64 # define SWIGUNUSEDPARM(p)
65 # else
66 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
67 # endif
68 #endif
69 
70 /* internal SWIG method */
71 #ifndef SWIGINTERN
72 # define SWIGINTERN static SWIGUNUSED
73 #endif
74 
75 /* internal inline SWIG method */
76 #ifndef SWIGINTERNINLINE
77 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
78 #endif
79 
80 /* exporting methods */
81 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
82 # ifndef GCC_HASCLASSVISIBILITY
83 # define GCC_HASCLASSVISIBILITY
84 # endif
85 #endif
86 
87 #ifndef SWIGEXPORT
88 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
89 # if defined(STATIC_LINKED)
90 # define SWIGEXPORT
91 # else
92 # define SWIGEXPORT __declspec(dllexport)
93 # endif
94 # else
95 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
96 # define SWIGEXPORT __attribute__ ((visibility("default")))
97 # else
98 # define SWIGEXPORT
99 # endif
100 # endif
101 #endif
102 
103 /* calling conventions for Windows */
104 #ifndef SWIGSTDCALL
105 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
106 # define SWIGSTDCALL __stdcall
107 # else
108 # define SWIGSTDCALL
109 # endif
110 #endif
111 
112 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
113 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
114 # define _CRT_SECURE_NO_DEPRECATE
115 #endif
116 
117 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
118 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
119 # define _SCL_SECURE_NO_DEPRECATE
120 #endif
121 
122 
123 
124 /* Python.h has to appear first */
125 #include <Python.h>
126 
127 /* -----------------------------------------------------------------------------
128  * swigrun.swg
129  *
130  * This file contains generic C API SWIG runtime support for pointer
131  * type checking.
132  * ----------------------------------------------------------------------------- */
133 
134 /* This should only be incremented when either the layout of swig_type_info changes,
135  or for whatever reason, the runtime changes incompatibly */
136 #define SWIG_RUNTIME_VERSION "4"
137 
138 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
139 #ifdef SWIG_TYPE_TABLE
140 # define SWIG_QUOTE_STRING(x) #x
141 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
142 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
143 #else
144 # define SWIG_TYPE_TABLE_NAME
145 #endif
146 
147 /*
148  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
149  creating a static or dynamic library from the SWIG runtime code.
150  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
151 
152  But only do this if strictly necessary, ie, if you have problems
153  with your compiler or suchlike.
154 */
155 
156 #ifndef SWIGRUNTIME
157 # define SWIGRUNTIME SWIGINTERN
158 #endif
159 
160 #ifndef SWIGRUNTIMEINLINE
161 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
162 #endif
163 
164 /* Generic buffer size */
165 #ifndef SWIG_BUFFER_SIZE
166 # define SWIG_BUFFER_SIZE 1024
167 #endif
168 
169 /* Flags for pointer conversions */
170 #define SWIG_POINTER_DISOWN 0x1
171 #define SWIG_CAST_NEW_MEMORY 0x2
172 
173 /* Flags for new pointer objects */
174 #define SWIG_POINTER_OWN 0x1
175 
176 
177 /*
178  Flags/methods for returning states.
179 
180  The SWIG conversion methods, as ConvertPtr, return an integer
181  that tells if the conversion was successful or not. And if not,
182  an error code can be returned (see swigerrors.swg for the codes).
183 
184  Use the following macros/flags to set or process the returning
185  states.
186 
187  In old versions of SWIG, code such as the following was usually written:
188 
189  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
190  // success code
191  } else {
192  //fail code
193  }
194 
195  Now you can be more explicit:
196 
197  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
198  if (SWIG_IsOK(res)) {
199  // success code
200  } else {
201  // fail code
202  }
203 
204  which is the same really, but now you can also do
205 
206  Type *ptr;
207  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
208  if (SWIG_IsOK(res)) {
209  // success code
210  if (SWIG_IsNewObj(res) {
211  ...
212  delete *ptr;
213  } else {
214  ...
215  }
216  } else {
217  // fail code
218  }
219 
220  I.e., now SWIG_ConvertPtr can return new objects and you can
221  identify the case and take care of the deallocation. Of course that
222  also requires SWIG_ConvertPtr to return new result values, such as
223 
224  int SWIG_ConvertPtr(obj, ptr,...) {
225  if (<obj is ok>) {
226  if (<need new object>) {
227  *ptr = <ptr to new allocated object>;
228  return SWIG_NEWOBJ;
229  } else {
230  *ptr = <ptr to old object>;
231  return SWIG_OLDOBJ;
232  }
233  } else {
234  return SWIG_BADOBJ;
235  }
236  }
237 
238  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
239  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
240  SWIG errors code.
241 
242  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
243  allows to return the 'cast rank', for example, if you have this
244 
245  int food(double)
246  int fooi(int);
247 
248  and you call
249 
250  food(1) // cast rank '1' (1 -> 1.0)
251  fooi(1) // cast rank '0'
252 
253  just use the SWIG_AddCast()/SWIG_CheckState()
254 */
255 
256 #define SWIG_OK (0)
257 #define SWIG_ERROR (-1)
258 #define SWIG_IsOK(r) (r >= 0)
259 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
260 
261 /* The CastRankLimit says how many bits are used for the cast rank */
262 #define SWIG_CASTRANKLIMIT (1 << 8)
263 /* The NewMask denotes the object was created (using new/malloc) */
264 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
265 /* The TmpMask is for in/out typemaps that use temporal objects */
266 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
267 /* Simple returning values */
268 #define SWIG_BADOBJ (SWIG_ERROR)
269 #define SWIG_OLDOBJ (SWIG_OK)
270 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
271 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
272 /* Check, add and del mask methods */
273 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
274 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
275 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
276 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
277 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
278 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
279 
280 /* Cast-Rank Mode */
281 #if defined(SWIG_CASTRANK_MODE)
282 # ifndef SWIG_TypeRank
283 # define SWIG_TypeRank unsigned long
284 # endif
285 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
286 # define SWIG_MAXCASTRANK (2)
287 # endif
288 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
289 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
290 SWIGINTERNINLINE int SWIG_AddCast(int r) {
291  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
292 }
293 SWIGINTERNINLINE int SWIG_CheckState(int r) {
294  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
295 }
296 #else /* no cast-rank mode */
297 # define SWIG_AddCast(r) (r)
298 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
299 #endif
300 
301 
302 #include <string.h>
303 
304 #ifdef __cplusplus
305 extern "C" {
306 #endif
307 
308 typedef void *(*swig_converter_func)(void *, int *);
309 typedef struct swig_type_info *(*swig_dycast_func)(void **);
310 
311 /* Structure to store information on one type */
312 typedef struct swig_type_info {
313  const char *name; /* mangled name of this type */
314  const char *str; /* human readable name of this type */
315  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
316  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
317  void *clientdata; /* language specific type data */
318  int owndata; /* flag if the structure owns the clientdata */
320 
321 /* Structure to store a type and conversion function used for casting */
322 typedef struct swig_cast_info {
323  swig_type_info *type; /* pointer to type that is equivalent to this type */
324  swig_converter_func converter; /* function to cast the void pointers */
325  struct swig_cast_info *next; /* pointer to next cast in linked list */
326  struct swig_cast_info *prev; /* pointer to the previous cast */
328 
329 /* Structure used to store module information
330  * Each module generates one structure like this, and the runtime collects
331  * all of these structures and stores them in a circularly linked list.*/
332 typedef struct swig_module_info {
333  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
334  size_t size; /* Number of types in this module */
335  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
336  swig_type_info **type_initial; /* Array of initially generated type structures */
337  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
338  void *clientdata; /* Language specific module data */
340 
341 /*
342  Compare two type names skipping the space characters, therefore
343  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
344 
345  Return 0 when the two name types are equivalent, as in
346  strncmp, but skipping ' '.
347 */
348 SWIGRUNTIME int
349 SWIG_TypeNameComp(const char *f1, const char *l1,
350  const char *f2, const char *l2) {
351  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
352  while ((*f1 == ' ') && (f1 != l1)) ++f1;
353  while ((*f2 == ' ') && (f2 != l2)) ++f2;
354  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
355  }
356  return (int)((l1 - f1) - (l2 - f2));
357 }
358 
359 /*
360  Check type equivalence in a name list like <name1>|<name2>|...
361  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
362 */
363 SWIGRUNTIME int
364 SWIG_TypeCmp(const char *nb, const char *tb) {
365  int equiv = 1;
366  const char* te = tb + strlen(tb);
367  const char* ne = nb;
368  while (equiv != 0 && *ne) {
369  for (nb = ne; *ne; ++ne) {
370  if (*ne == '|') break;
371  }
372  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
373  if (*ne) ++ne;
374  }
375  return equiv;
376 }
377 
378 /*
379  Check type equivalence in a name list like <name1>|<name2>|...
380  Return 0 if not equal, 1 if equal
381 */
382 SWIGRUNTIME int
383 SWIG_TypeEquiv(const char *nb, const char *tb) {
384  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
385 }
386 
387 /*
388  Check the typename
389 */
391 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
392  if (ty) {
393  swig_cast_info *iter = ty->cast;
394  while (iter) {
395  if (strcmp(iter->type->name, c) == 0) {
396  if (iter == ty->cast)
397  return iter;
398  /* Move iter to the top of the linked list */
399  iter->prev->next = iter->next;
400  if (iter->next)
401  iter->next->prev = iter->prev;
402  iter->next = ty->cast;
403  iter->prev = 0;
404  if (ty->cast) ty->cast->prev = iter;
405  ty->cast = iter;
406  return iter;
407  }
408  iter = iter->next;
409  }
410  }
411  return 0;
412 }
413 
414 /*
415  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
416 */
419  if (ty) {
420  swig_cast_info *iter = ty->cast;
421  while (iter) {
422  if (iter->type == from) {
423  if (iter == ty->cast)
424  return iter;
425  /* Move iter to the top of the linked list */
426  iter->prev->next = iter->next;
427  if (iter->next)
428  iter->next->prev = iter->prev;
429  iter->next = ty->cast;
430  iter->prev = 0;
431  if (ty->cast) ty->cast->prev = iter;
432  ty->cast = iter;
433  return iter;
434  }
435  iter = iter->next;
436  }
437  }
438  return 0;
439 }
440 
441 /*
442  Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
446  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
447 }
448 
449 /*
450  Dynamic pointer casting. Down an inheritance hierarchy
451 */
454  swig_type_info *lastty = ty;
455  if (!ty || !ty->dcast) return ty;
456  while (ty && (ty->dcast)) {
457  ty = (*ty->dcast)(ptr);
458  if (ty) lastty = ty;
459  }
460  return lastty;
461 }
462 
463 /*
464  Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
468  return ty->name;
469 }
470 
471 /*
472  Return the pretty name associated with this type,
473  that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
477  /* The "str" field contains the equivalent pretty names of the
478  type, separated by vertical-bar characters. We choose
479  to print the last name, as it is often (?) the most
480  specific. */
481  if (!type) return NULL;
482  if (type->str != NULL) {
483  const char *last_name = type->str;
484  const char *s;
485  for (s = type->str; *s; s++)
486  if (*s == '|') last_name = s+1;
487  return last_name;
488  }
489  else
490  return type->name;
491 }
492 
493 /*
494  Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
498  swig_cast_info *cast = ti->cast;
499  /* if (ti->clientdata == clientdata) return; */
500  ti->clientdata = clientdata;
501 
502  while (cast) {
503  if (!cast->converter) {
504  swig_type_info *tc = cast->type;
505  if (!tc->clientdata) {
506  SWIG_TypeClientData(tc, clientdata);
507  }
508  }
509  cast = cast->next;
510  }
511 }
512 SWIGRUNTIME void
514  SWIG_TypeClientData(ti, clientdata);
515  ti->owndata = 1;
516 }
517 
518 /*
519  Search for a swig_type_info structure only by mangled name
520  Search is a O(log #types)
521 
522  We start searching at module start, and finish searching when start == end.
523  Note: if start == end at the beginning of the function, we go all the way around
524  the circular list.
525 */
528  swig_module_info *end,
529  const char *name) {
530  swig_module_info *iter = start;
531  do {
532  if (iter->size) {
533  register size_t l = 0;
534  register size_t r = iter->size - 1;
535  do {
536  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537  register size_t i = (l + r) >> 1;
538  const char *iname = iter->types[i]->name;
539  if (iname) {
540  register int compare = strcmp(name, iname);
541  if (compare == 0) {
542  return iter->types[i];
543  } else if (compare < 0) {
544  if (i) {
545  r = i - 1;
546  } else {
547  break;
548  }
549  } else if (compare > 0) {
550  l = i + 1;
551  }
552  } else {
553  break; /* should never happen */
554  }
555  } while (l <= r);
556  }
557  iter = iter->next;
558  } while (iter != end);
559  return 0;
560 }
561 
562 /*
563  Search for a swig_type_info structure for either a mangled name or a human readable name.
564  It first searches the mangled names of the types, which is a O(log #types)
565  If a type is not found it then searches the human readable names, which is O(#types).
566 
567  We start searching at module start, and finish searching when start == end.
568  Note: if start == end at the beginning of the function, we go all the way around
569  the circular list.
570 */
573  swig_module_info *end,
574  const char *name) {
575  /* STEP 1: Search the name field using binary search */
576  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577  if (ret) {
578  return ret;
579  } else {
580  /* STEP 2: If the type hasn't been found, do a complete search
581  of the str field (the human readable name) */
582  swig_module_info *iter = start;
583  do {
584  register size_t i = 0;
585  for (; i < iter->size; ++i) {
586  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587  return iter->types[i];
588  }
589  iter = iter->next;
590  } while (iter != end);
591  }
592 
593  /* neither found a match */
594  return 0;
595 }
596 
597 /*
598  Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602  static const char hex[17] = "0123456789abcdef";
603  register const unsigned char *u = (unsigned char *) ptr;
604  register const unsigned char *eu = u + sz;
605  for (; u != eu; ++u) {
606  register unsigned char uu = *u;
607  *(c++) = hex[(uu & 0xf0) >> 4];
608  *(c++) = hex[uu & 0xf];
609  }
610  return c;
611 }
612 
613 /*
614  Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618  register unsigned char *u = (unsigned char *) ptr;
619  register const unsigned char *eu = u + sz;
620  for (; u != eu; ++u) {
621  register char d = *(c++);
622  register unsigned char uu;
623  if ((d >= '0') && (d <= '9'))
624  uu = ((d - '0') << 4);
625  else if ((d >= 'a') && (d <= 'f'))
626  uu = ((d - ('a'-10)) << 4);
627  else
628  return (char *) 0;
629  d = *(c++);
630  if ((d >= '0') && (d <= '9'))
631  uu |= (d - '0');
632  else if ((d >= 'a') && (d <= 'f'))
633  uu |= (d - ('a'-10));
634  else
635  return (char *) 0;
636  *u = uu;
637  }
638  return c;
639 }
640 
641 /*
642  Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646  char *r = buff;
647  if ((2*sizeof(void *) + 2) > bsz) return 0;
648  *(r++) = '_';
649  r = SWIG_PackData(r,&ptr,sizeof(void *));
650  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651  strcpy(r,name);
652  return buff;
653 }
654 
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657  if (*c != '_') {
658  if (strcmp(c,"NULL") == 0) {
659  *ptr = (void *) 0;
660  return name;
661  } else {
662  return 0;
663  }
664  }
665  return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667 
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670  char *r = buff;
671  size_t lname = (name ? strlen(name) : 0);
672  if ((2*sz + 2 + lname) > bsz) return 0;
673  *(r++) = '_';
674  r = SWIG_PackData(r,ptr,sz);
675  if (lname) {
676  strncpy(r,name,lname+1);
677  } else {
678  *r = 0;
679  }
680  return buff;
681 }
682 
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685  if (*c != '_') {
686  if (strcmp(c,"NULL") == 0) {
687  memset(ptr,0,sz);
688  return name;
689  } else {
690  return 0;
691  }
692  }
693  return SWIG_UnpackData(++c,ptr,sz);
694 }
695 
696 #ifdef __cplusplus
697 }
698 #endif
699 
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714 
715 
716 
717 /* Compatibility macros for Python 3 */
718 #if PY_VERSION_HEX >= 0x03000000
719 
720 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
721 #define PyInt_Check(x) PyLong_Check(x)
722 #define PyInt_AsLong(x) PyLong_AsLong(x)
723 #define PyInt_FromLong(x) PyLong_FromLong(x)
724 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
725 #define PyString_Check(name) PyBytes_Check(name)
726 #define PyString_FromString(x) PyUnicode_FromString(x)
727 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
728 #define PyString_AsString(str) PyBytes_AsString(str)
729 #define PyString_Size(str) PyBytes_Size(str)
730 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
731 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
732 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
733 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
734 
735 #endif
736 
737 #ifndef Py_TYPE
738 # define Py_TYPE(op) ((op)->ob_type)
739 #endif
740 
741 /* SWIG APIs for compatibility of both Python 2 & 3 */
742 
743 #if PY_VERSION_HEX >= 0x03000000
744 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
745 #else
746 # define SWIG_Python_str_FromFormat PyString_FromFormat
747 #endif
748 
749 
750 /* Warning: This function will allocate a new string in Python 3,
751  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
752  */
753 SWIGINTERN char*
755 {
756 #if PY_VERSION_HEX >= 0x03000000
757  char *cstr;
758  char *newstr;
759  Py_ssize_t len;
760  str = PyUnicode_AsUTF8String(str);
761  PyBytes_AsStringAndSize(str, &cstr, &len);
762  newstr = (char *) malloc(len+1);
763  memcpy(newstr, cstr, len+1);
764  Py_XDECREF(str);
765  return newstr;
766 #else
767  return PyString_AsString(str);
768 #endif
769 }
770 
771 #if PY_VERSION_HEX >= 0x03000000
772 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
773 #else
774 # define SWIG_Python_str_DelForPy3(x)
775 #endif
776 
777 
778 SWIGINTERN PyObject*
780 {
781 #if PY_VERSION_HEX >= 0x03000000
782  return PyUnicode_FromString(c);
783 #else
784  return PyString_FromString(c);
785 #endif
786 }
787 
788 /* Add PyOS_snprintf for old Pythons */
789 #if PY_VERSION_HEX < 0x02020000
790 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
791 # define PyOS_snprintf _snprintf
792 # else
793 # define PyOS_snprintf snprintf
794 # endif
795 #endif
796 
797 /* A crude PyString_FromFormat implementation for old Pythons */
798 #if PY_VERSION_HEX < 0x02020000
799 
800 #ifndef SWIG_PYBUFFER_SIZE
801 # define SWIG_PYBUFFER_SIZE 1024
802 #endif
803 
804 static PyObject *
805 PyString_FromFormat(const char *fmt, ...) {
806  va_list ap;
807  char buf[SWIG_PYBUFFER_SIZE * 2];
808  int res;
809  va_start(ap, fmt);
810  res = vsnprintf(buf, sizeof(buf), fmt, ap);
811  va_end(ap);
812  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
813 }
814 #endif
815 
816 /* Add PyObject_Del for old Pythons */
817 #if PY_VERSION_HEX < 0x01060000
818 # define PyObject_Del(op) PyMem_DEL((op))
819 #endif
820 #ifndef PyObject_DEL
821 # define PyObject_DEL PyObject_Del
822 #endif
823 
824 /* A crude PyExc_StopIteration exception for old Pythons */
825 #if PY_VERSION_HEX < 0x02020000
826 # ifndef PyExc_StopIteration
827 # define PyExc_StopIteration PyExc_RuntimeError
828 # endif
829 # ifndef PyObject_GenericGetAttr
830 # define PyObject_GenericGetAttr 0
831 # endif
832 #endif
833 
834 /* Py_NotImplemented is defined in 2.1 and up. */
835 #if PY_VERSION_HEX < 0x02010000
836 # ifndef Py_NotImplemented
837 # define Py_NotImplemented PyExc_RuntimeError
838 # endif
839 #endif
840 
841 /* A crude PyString_AsStringAndSize implementation for old Pythons */
842 #if PY_VERSION_HEX < 0x02010000
843 # ifndef PyString_AsStringAndSize
844 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
845 # endif
846 #endif
847 
848 /* PySequence_Size for old Pythons */
849 #if PY_VERSION_HEX < 0x02000000
850 # ifndef PySequence_Size
851 # define PySequence_Size PySequence_Length
852 # endif
853 #endif
854 
855 /* PyBool_FromLong for old Pythons */
856 #if PY_VERSION_HEX < 0x02030000
857 static
858 PyObject *PyBool_FromLong(long ok)
859 {
860  PyObject *result = ok ? Py_True : Py_False;
861  Py_INCREF(result);
862  return result;
863 }
864 #endif
865 
866 /* Py_ssize_t for old Pythons */
867 /* This code is as recommended by: */
868 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
869 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
870 typedef int Py_ssize_t;
871 # define PY_SSIZE_T_MAX INT_MAX
872 # define PY_SSIZE_T_MIN INT_MIN
873 typedef inquiry lenfunc;
874 typedef intargfunc ssizeargfunc;
875 typedef intintargfunc ssizessizeargfunc;
876 typedef intobjargproc ssizeobjargproc;
877 typedef intintobjargproc ssizessizeobjargproc;
878 typedef getreadbufferproc readbufferproc;
879 typedef getwritebufferproc writebufferproc;
880 typedef getsegcountproc segcountproc;
881 typedef getcharbufferproc charbufferproc;
882 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
883 {
884  long result = 0;
885  PyObject *i = PyNumber_Int(x);
886  if (i) {
887  result = PyInt_AsLong(i);
888  Py_DECREF(i);
889  }
890  return result;
891 }
892 #endif
893 
894 #if PY_VERSION_HEX < 0x02050000
895 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
896 #endif
897 
898 #if PY_VERSION_HEX < 0x02040000
899 #define Py_VISIT(op) \
900  do { \
901  if (op) { \
902  int vret = visit((op), arg); \
903  if (vret) \
904  return vret; \
905  } \
906  } while (0)
907 #endif
908 
909 #if PY_VERSION_HEX < 0x02030000
910 typedef struct {
911  PyTypeObject type;
912  PyNumberMethods as_number;
913  PyMappingMethods as_mapping;
914  PySequenceMethods as_sequence;
915  PyBufferProcs as_buffer;
916  PyObject *name, *slots;
918 #endif
919 
920 #if PY_VERSION_HEX < 0x02030000
921 typedef destructor freefunc;
922 #endif
923 
924 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
925  (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
926  (PY_MAJOR_VERSION > 3))
927 # define SWIGPY_USE_CAPSULE
928 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
929 #endif
930 
931 #if PY_VERSION_HEX < 0x03020000
932 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
933 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
934 #endif
935 
936 /* -----------------------------------------------------------------------------
937  * error manipulation
938  * ----------------------------------------------------------------------------- */
939 
940 SWIGRUNTIME PyObject*
942  PyObject* type = 0;
943  switch(code) {
944  case SWIG_MemoryError:
945  type = PyExc_MemoryError;
946  break;
947  case SWIG_IOError:
948  type = PyExc_IOError;
949  break;
950  case SWIG_RuntimeError:
951  type = PyExc_RuntimeError;
952  break;
953  case SWIG_IndexError:
954  type = PyExc_IndexError;
955  break;
956  case SWIG_TypeError:
957  type = PyExc_TypeError;
958  break;
959  case SWIG_DivisionByZero:
960  type = PyExc_ZeroDivisionError;
961  break;
962  case SWIG_OverflowError:
963  type = PyExc_OverflowError;
964  break;
965  case SWIG_SyntaxError:
966  type = PyExc_SyntaxError;
967  break;
968  case SWIG_ValueError:
969  type = PyExc_ValueError;
970  break;
971  case SWIG_SystemError:
972  type = PyExc_SystemError;
973  break;
974  case SWIG_AttributeError:
975  type = PyExc_AttributeError;
976  break;
977  default:
978  type = PyExc_RuntimeError;
979  }
980  return type;
981 }
982 
983 
984 SWIGRUNTIME void
985 SWIG_Python_AddErrorMsg(const char* mesg)
986 {
987  PyObject *type = 0;
988  PyObject *value = 0;
989  PyObject *traceback = 0;
990 
991  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
992  if (value) {
993  char *tmp;
994  PyObject *old_str = PyObject_Str(value);
995  PyErr_Clear();
996  Py_XINCREF(type);
997 
998  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1000  Py_DECREF(old_str);
1001  Py_DECREF(value);
1002  } else {
1003  PyErr_SetString(PyExc_RuntimeError, mesg);
1004  }
1005 }
1006 
1007 #if defined(SWIG_PYTHON_NO_THREADS)
1008 # if defined(SWIG_PYTHON_THREADS)
1009 # undef SWIG_PYTHON_THREADS
1010 # endif
1011 #endif
1012 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1013 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1014 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1015 # define SWIG_PYTHON_USE_GIL
1016 # endif
1017 # endif
1018 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1019 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1020 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1021 # endif
1022 # ifdef __cplusplus /* C++ code */
1023  class SWIG_Python_Thread_Block {
1024  bool status;
1025  PyGILState_STATE state;
1026  public:
1027  void end() { if (status) { PyGILState_Release(state); status = false;} }
1028  SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1029  ~SWIG_Python_Thread_Block() { end(); }
1030  };
1031  class SWIG_Python_Thread_Allow {
1032  bool status;
1033  PyThreadState *save;
1034  public:
1035  void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1036  SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1037  ~SWIG_Python_Thread_Allow() { end(); }
1038  };
1039 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1040 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1041 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1042 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1043 # else /* C code */
1044 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1045 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1046 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1047 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1048 # endif
1049 # else /* Old thread way, not implemented, user must provide it */
1050 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1051 # define SWIG_PYTHON_INITIALIZE_THREADS
1052 # endif
1053 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1054 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1055 # endif
1056 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1057 # define SWIG_PYTHON_THREAD_END_BLOCK
1058 # endif
1059 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1060 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1061 # endif
1062 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1063 # define SWIG_PYTHON_THREAD_END_ALLOW
1064 # endif
1065 # endif
1066 #else /* No thread support */
1067 # define SWIG_PYTHON_INITIALIZE_THREADS
1068 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1069 # define SWIG_PYTHON_THREAD_END_BLOCK
1070 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1071 # define SWIG_PYTHON_THREAD_END_ALLOW
1072 #endif
1073 
1074 /* -----------------------------------------------------------------------------
1075  * Python API portion that goes into the runtime
1076  * ----------------------------------------------------------------------------- */
1077 
1078 #ifdef __cplusplus
1079 extern "C" {
1080 #endif
1081 
1082 /* -----------------------------------------------------------------------------
1083  * Constant declarations
1084  * ----------------------------------------------------------------------------- */
1085 
1086 /* Constant Types */
1087 #define SWIG_PY_POINTER 4
1088 #define SWIG_PY_BINARY 5
1089 
1090 /* Constant information structure */
1091 typedef struct swig_const_info {
1092  int type;
1093  char *name;
1094  long lvalue;
1095  double dvalue;
1096  void *pvalue;
1098 } swig_const_info;
1099 
1100 
1101 /* -----------------------------------------------------------------------------
1102  * Wrapper of PyInstanceMethod_New() used in Python 3
1103  * It is exported to the generated module, used for -fastproxy
1104  * ----------------------------------------------------------------------------- */
1105 #if PY_VERSION_HEX >= 0x03000000
1106 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1107 {
1108  return PyInstanceMethod_New(func);
1109 }
1110 #else
1111 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1112 {
1113  return NULL;
1114 }
1115 #endif
1116 
1117 #ifdef __cplusplus
1118 }
1119 #endif
1120 
1121 
1122 /* -----------------------------------------------------------------------------
1123  * pyrun.swg
1124  *
1125  * This file contains the runtime support for Python modules
1126  * and includes code for managing global variables and pointer
1127  * type checking.
1128  *
1129  * ----------------------------------------------------------------------------- */
1130 
1131 /* Common SWIG API */
1132 
1133 /* for raw pointers */
1134 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1135 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1136 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1137 
1138 #ifdef SWIGPYTHON_BUILTIN
1139 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1140 #else
1141 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1142 #endif
1143 
1144 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1145 
1146 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1147 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1148 #define swig_owntype int
1149 
1150 /* for raw packed data */
1151 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1152 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1153 
1154 /* for class or struct pointers */
1155 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1156 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1157 
1158 /* for C or C++ function pointers */
1159 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1160 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1161 
1162 /* for C++ member pointers, ie, member methods */
1163 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1164 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1165 
1166 
1167 /* Runtime API */
1168 
1169 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1170 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1171 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1172 
1173 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1174 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1175 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1176 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1177 #define SWIG_fail goto fail
1178 
1179 
1180 /* Runtime API implementation */
1181 
1182 /* Error manipulation */
1183 
1184 SWIGINTERN void
1185 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1187  PyErr_SetObject(errtype, obj);
1188  Py_DECREF(obj);
1190 }
1191 
1192 SWIGINTERN void
1193 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1195  PyErr_SetString(errtype, msg);
1197 }
1198 
1199 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1200 
1201 /* Set a constant value */
1202 
1203 #if defined(SWIGPYTHON_BUILTIN)
1204 
1205 SWIGINTERN void
1206 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1207  PyObject *s = PyString_InternFromString(key);
1208  PyList_Append(seq, s);
1209  Py_DECREF(s);
1210 }
1211 
1212 SWIGINTERN void
1213 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1214 #if PY_VERSION_HEX < 0x02030000
1215  PyDict_SetItemString(d, (char *)name, obj);
1216 #else
1217  PyDict_SetItemString(d, name, obj);
1218 #endif
1219  Py_DECREF(obj);
1220  if (public_interface)
1221  SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1222 }
1223 
1224 #else
1225 
1226 SWIGINTERN void
1227 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1228 #if PY_VERSION_HEX < 0x02030000
1229  PyDict_SetItemString(d, (char *)name, obj);
1230 #else
1231  PyDict_SetItemString(d, name, obj);
1232 #endif
1233  Py_DECREF(obj);
1234 }
1235 
1236 #endif
1237 
1238 /* Append a value to the result obj */
1239 
1240 SWIGINTERN PyObject*
1241 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1242 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1243  if (!result) {
1244  result = obj;
1245  } else if (result == Py_None) {
1246  Py_DECREF(result);
1247  result = obj;
1248  } else {
1249  if (!PyList_Check(result)) {
1250  PyObject *o2 = result;
1251  result = PyList_New(1);
1252  PyList_SetItem(result, 0, o2);
1253  }
1254  PyList_Append(result,obj);
1255  Py_DECREF(obj);
1256  }
1257  return result;
1258 #else
1259  PyObject* o2;
1260  PyObject* o3;
1261  if (!result) {
1262  result = obj;
1263  } else if (result == Py_None) {
1264  Py_DECREF(result);
1265  result = obj;
1266  } else {
1267  if (!PyTuple_Check(result)) {
1268  o2 = result;
1269  result = PyTuple_New(1);
1270  PyTuple_SET_ITEM(result, 0, o2);
1271  }
1272  o3 = PyTuple_New(1);
1273  PyTuple_SET_ITEM(o3, 0, obj);
1274  o2 = result;
1275  result = PySequence_Concat(o2, o3);
1276  Py_DECREF(o2);
1277  Py_DECREF(o3);
1278  }
1279  return result;
1280 #endif
1281 }
1282 
1283 /* Unpack the argument tuple */
1284 
1285 SWIGINTERN int
1286 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1287 {
1288  if (!args) {
1289  if (!min && !max) {
1290  return 1;
1291  } else {
1292  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1293  name, (min == max ? "" : "at least "), (int)min);
1294  return 0;
1295  }
1296  }
1297  if (!PyTuple_Check(args)) {
1298  if (min <= 1 && max >= 1) {
1299  register int i;
1300  objs[0] = args;
1301  for (i = 1; i < max; ++i) {
1302  objs[i] = 0;
1303  }
1304  return 2;
1305  }
1306  PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1307  return 0;
1308  } else {
1309  register Py_ssize_t l = PyTuple_GET_SIZE(args);
1310  if (l < min) {
1311  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1312  name, (min == max ? "" : "at least "), (int)min, (int)l);
1313  return 0;
1314  } else if (l > max) {
1315  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1316  name, (min == max ? "" : "at most "), (int)max, (int)l);
1317  return 0;
1318  } else {
1319  register int i;
1320  for (i = 0; i < l; ++i) {
1321  objs[i] = PyTuple_GET_ITEM(args, i);
1322  }
1323  for (; l < max; ++l) {
1324  objs[l] = 0;
1325  }
1326  return i + 1;
1327  }
1328  }
1329 }
1330 
1331 /* A functor is a function object with one single object argument */
1332 #if PY_VERSION_HEX >= 0x02020000
1333 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1334 #else
1335 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1336 #endif
1337 
1338 /*
1339  Helper for static pointer initialization for both C and C++ code, for example
1340  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1341 */
1342 #ifdef __cplusplus
1343 #define SWIG_STATIC_POINTER(var) var
1344 #else
1345 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1346 #endif
1347 
1348 /* -----------------------------------------------------------------------------
1349  * Pointer declarations
1350  * ----------------------------------------------------------------------------- */
1351 
1352 /* Flags for new pointer objects */
1353 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1354 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1355 
1356 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1357 
1358 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1359 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1360 
1361 #ifdef __cplusplus
1362 extern "C" {
1363 #endif
1364 
1365 /* How to access Py_None */
1366 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1367 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1368 # ifndef SWIG_PYTHON_BUILD_NONE
1369 # define SWIG_PYTHON_BUILD_NONE
1370 # endif
1371 # endif
1372 #endif
1373 
1374 #ifdef SWIG_PYTHON_BUILD_NONE
1375 # ifdef Py_None
1376 # undef Py_None
1377 # define Py_None SWIG_Py_None()
1378 # endif
1379 SWIGRUNTIMEINLINE PyObject *
1380 _SWIG_Py_None(void)
1381 {
1382  PyObject *none = Py_BuildValue((char*)"");
1383  Py_DECREF(none);
1384  return none;
1385 }
1386 SWIGRUNTIME PyObject *
1387 SWIG_Py_None(void)
1388 {
1389  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1390  return none;
1391 }
1392 #endif
1393 
1394 /* The python void return value */
1395 
1396 SWIGRUNTIMEINLINE PyObject *
1398 {
1399  PyObject *none = Py_None;
1400  Py_INCREF(none);
1401  return none;
1402 }
1403 
1404 /* SwigPyClientData */
1405 
1406 typedef struct {
1407  PyObject *klass;
1408  PyObject *newraw;
1409  PyObject *newargs;
1410  PyObject *destroy;
1411  int delargs;
1413  PyTypeObject *pytype;
1415 
1416 SWIGRUNTIMEINLINE int
1418 {
1420  return data ? data->implicitconv : 0;
1421 }
1422 
1423 SWIGRUNTIMEINLINE PyObject *
1425  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1426  PyObject *klass = data ? data->klass : 0;
1427  return (klass ? klass : PyExc_RuntimeError);
1428 }
1429 
1430 
1432 SwigPyClientData_New(PyObject* obj)
1433 {
1434  if (!obj) {
1435  return 0;
1436  } else {
1437  SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1438  /* the klass element */
1439  data->klass = obj;
1440  Py_INCREF(data->klass);
1441  /* the newraw method and newargs arguments used to create a new raw instance */
1442  if (PyClass_Check(obj)) {
1443  data->newraw = 0;
1444  data->newargs = obj;
1445  Py_INCREF(obj);
1446  } else {
1447 #if (PY_VERSION_HEX < 0x02020000)
1448  data->newraw = 0;
1449 #else
1450  data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1451 #endif
1452  if (data->newraw) {
1453  Py_INCREF(data->newraw);
1454  data->newargs = PyTuple_New(1);
1455  PyTuple_SetItem(data->newargs, 0, obj);
1456  } else {
1457  data->newargs = obj;
1458  }
1459  Py_INCREF(data->newargs);
1460  }
1461  /* the destroy method, aka as the C++ delete method */
1462  data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1463  if (PyErr_Occurred()) {
1464  PyErr_Clear();
1465  data->destroy = 0;
1466  }
1467  if (data->destroy) {
1468  int flags;
1469  Py_INCREF(data->destroy);
1470  flags = PyCFunction_GET_FLAGS(data->destroy);
1471 #ifdef METH_O
1472  data->delargs = !(flags & (METH_O));
1473 #else
1474  data->delargs = 0;
1475 #endif
1476  } else {
1477  data->delargs = 0;
1478  }
1479  data->implicitconv = 0;
1480  data->pytype = 0;
1481  return data;
1482  }
1483 }
1484 
1485 SWIGRUNTIME void
1487  Py_XDECREF(data->newraw);
1488  Py_XDECREF(data->newargs);
1489  Py_XDECREF(data->destroy);
1490 }
1491 
1492 /* =============== SwigPyObject =====================*/
1493 
1494 typedef struct {
1495  PyObject_HEAD
1496  void *ptr;
1498  int own;
1499  PyObject *next;
1500 #ifdef SWIGPYTHON_BUILTIN
1501  PyObject *dict;
1502 #endif
1503 } SwigPyObject;
1504 
1505 SWIGRUNTIME PyObject *
1507 {
1508  return PyLong_FromVoidPtr(v->ptr);
1509 }
1510 
1511 SWIGRUNTIME PyObject *
1512 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1513 {
1514  PyObject *res = NULL;
1515  PyObject *args = PyTuple_New(1);
1516  if (args) {
1517  if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1518  PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1519  if (ofmt) {
1520 #if PY_VERSION_HEX >= 0x03000000
1521  res = PyUnicode_Format(ofmt,args);
1522 #else
1523  res = PyString_Format(ofmt,args);
1524 #endif
1525  Py_DECREF(ofmt);
1526  }
1527  Py_DECREF(args);
1528  }
1529  }
1530  return res;
1531 }
1532 
1533 SWIGRUNTIME PyObject *
1535 {
1536  return SwigPyObject_format("%o",v);
1537 }
1538 
1539 SWIGRUNTIME PyObject *
1541 {
1542  return SwigPyObject_format("%x",v);
1543 }
1544 
1545 SWIGRUNTIME PyObject *
1546 #ifdef METH_NOARGS
1548 #else
1549 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1550 #endif
1551 {
1552  const char *name = SWIG_TypePrettyName(v->ty);
1553  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1554  if (v->next) {
1555 # ifdef METH_NOARGS
1556  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1557 # else
1558  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1559 # endif
1560 # if PY_VERSION_HEX >= 0x03000000
1561  PyObject *joined = PyUnicode_Concat(repr, nrep);
1562  Py_DecRef(repr);
1563  Py_DecRef(nrep);
1564  repr = joined;
1565 # else
1566  PyString_ConcatAndDel(&repr,nrep);
1567 # endif
1568  }
1569  return repr;
1570 }
1571 
1572 SWIGRUNTIME int
1574 {
1575  char *str;
1576 #ifdef METH_NOARGS
1577  PyObject *repr = SwigPyObject_repr(v);
1578 #else
1579  PyObject *repr = SwigPyObject_repr(v, NULL);
1580 #endif
1581  if (repr) {
1582  str = SWIG_Python_str_AsChar(repr);
1583  fputs(str, fp);
1585  Py_DECREF(repr);
1586  return 0;
1587  } else {
1588  return 1;
1589  }
1590 }
1591 
1592 SWIGRUNTIME PyObject *
1594 {
1595  char result[SWIG_BUFFER_SIZE];
1596  return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1597  SWIG_Python_str_FromChar(result) : 0;
1598 }
1599 
1600 SWIGRUNTIME int
1602 {
1603  void *i = v->ptr;
1604  void *j = w->ptr;
1605  return (i < j) ? -1 : ((i > j) ? 1 : 0);
1606 }
1607 
1608 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1609 SWIGRUNTIME PyObject*
1611 {
1612  PyObject* res;
1613  if( op != Py_EQ && op != Py_NE ) {
1614  Py_INCREF(Py_NotImplemented);
1615  return Py_NotImplemented;
1616  }
1617  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1618  return res;
1619 }
1620 
1621 
1622 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1623 
1624 #ifdef SWIGPYTHON_BUILTIN
1625 static swig_type_info *SwigPyObject_stype = 0;
1626 SWIGRUNTIME PyTypeObject*
1627 SwigPyObject_type(void) {
1628  SwigPyClientData *cd;
1629  assert(SwigPyObject_stype);
1630  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1631  assert(cd);
1632  assert(cd->pytype);
1633  return cd->pytype;
1634 }
1635 #else
1636 SWIGRUNTIME PyTypeObject*
1638  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1639  return type;
1640 }
1641 #endif
1642 
1644 SwigPyObject_Check(PyObject *op) {
1645 #ifdef SWIGPYTHON_BUILTIN
1646  PyTypeObject *target_tp = SwigPyObject_type();
1647  if (PyType_IsSubtype(op->ob_type, target_tp))
1648  return 1;
1649  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1650 #else
1651  return (Py_TYPE(op) == SwigPyObject_type())
1652  || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1653 #endif
1654 }
1655 
1656 SWIGRUNTIME PyObject *
1657 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1658 
1659 SWIGRUNTIME void
1661 {
1662  SwigPyObject *sobj = (SwigPyObject *) v;
1663  PyObject *next = sobj->next;
1664  if (sobj->own == SWIG_POINTER_OWN) {
1665  swig_type_info *ty = sobj->ty;
1666  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1667  PyObject *destroy = data ? data->destroy : 0;
1668  if (destroy) {
1669  /* destroy is always a VARARGS method */
1670  PyObject *res;
1671  if (data->delargs) {
1672  /* we need to create a temporary object to carry the destroy operation */
1673  PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1674  res = SWIG_Python_CallFunctor(destroy, tmp);
1675  Py_DECREF(tmp);
1676  } else {
1677  PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1678  PyObject *mself = PyCFunction_GET_SELF(destroy);
1679  res = ((*meth)(mself, v));
1680  }
1681  Py_XDECREF(res);
1682  }
1683 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1684  else {
1685  const char *name = SWIG_TypePrettyName(ty);
1686  printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1687  }
1688 #endif
1689  }
1690  Py_XDECREF(next);
1691  PyObject_DEL(v);
1692 }
1693 
1694 SWIGRUNTIME PyObject*
1695 SwigPyObject_append(PyObject* v, PyObject* next)
1696 {
1697  SwigPyObject *sobj = (SwigPyObject *) v;
1698 #ifndef METH_O
1699  PyObject *tmp = 0;
1700  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1701  next = tmp;
1702 #endif
1703  if (!SwigPyObject_Check(next)) {
1704  return NULL;
1705  }
1706  sobj->next = next;
1707  Py_INCREF(next);
1708  return SWIG_Py_Void();
1709 }
1710 
1711 SWIGRUNTIME PyObject*
1712 #ifdef METH_NOARGS
1713 SwigPyObject_next(PyObject* v)
1714 #else
1715 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1716 #endif
1717 {
1718  SwigPyObject *sobj = (SwigPyObject *) v;
1719  if (sobj->next) {
1720  Py_INCREF(sobj->next);
1721  return sobj->next;
1722  } else {
1723  return SWIG_Py_Void();
1724  }
1725 }
1726 
1727 SWIGINTERN PyObject*
1728 #ifdef METH_NOARGS
1729 SwigPyObject_disown(PyObject *v)
1730 #else
1731 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1732 #endif
1733 {
1734  SwigPyObject *sobj = (SwigPyObject *)v;
1735  sobj->own = 0;
1736  return SWIG_Py_Void();
1737 }
1738 
1739 SWIGINTERN PyObject*
1740 #ifdef METH_NOARGS
1741 SwigPyObject_acquire(PyObject *v)
1742 #else
1743 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1744 #endif
1745 {
1746  SwigPyObject *sobj = (SwigPyObject *)v;
1747  sobj->own = SWIG_POINTER_OWN;
1748  return SWIG_Py_Void();
1749 }
1750 
1751 SWIGINTERN PyObject*
1752 SwigPyObject_own(PyObject *v, PyObject *args)
1753 {
1754  PyObject *val = 0;
1755 #if (PY_VERSION_HEX < 0x02020000)
1756  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1757 #elif (PY_VERSION_HEX < 0x02050000)
1758  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1759 #else
1760  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1761 #endif
1762  {
1763  return NULL;
1764  }
1765  else
1766  {
1767  SwigPyObject *sobj = (SwigPyObject *)v;
1768  PyObject *obj = PyBool_FromLong(sobj->own);
1769  if (val) {
1770 #ifdef METH_NOARGS
1771  if (PyObject_IsTrue(val)) {
1773  } else {
1775  }
1776 #else
1777  if (PyObject_IsTrue(val)) {
1778  SwigPyObject_acquire(v,args);
1779  } else {
1780  SwigPyObject_disown(v,args);
1781  }
1782 #endif
1783  }
1784  return obj;
1785  }
1786 }
1787 
1788 #ifdef METH_O
1789 static PyMethodDef
1790 swigobject_methods[] = {
1791  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1792  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
1793  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1794  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1795  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1796  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1797  {0, 0, 0, 0}
1798 };
1799 #else
1800 static PyMethodDef
1801 swigobject_methods[] = {
1802  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1803  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1804  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1805  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1806  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1807  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1808  {0, 0, 0, 0}
1809 };
1810 #endif
1811 
1812 #if PY_VERSION_HEX < 0x02020000
1813 SWIGINTERN PyObject *
1815 {
1816  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1817 }
1818 #endif
1819 
1820 SWIGRUNTIME PyTypeObject*
1822  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1823 
1824  static PyNumberMethods SwigPyObject_as_number = {
1825  (binaryfunc)0, /*nb_add*/
1826  (binaryfunc)0, /*nb_subtract*/
1827  (binaryfunc)0, /*nb_multiply*/
1828  /* nb_divide removed in Python 3 */
1829 #if PY_VERSION_HEX < 0x03000000
1830  (binaryfunc)0, /*nb_divide*/
1831 #endif
1832  (binaryfunc)0, /*nb_remainder*/
1833  (binaryfunc)0, /*nb_divmod*/
1834  (ternaryfunc)0,/*nb_power*/
1835  (unaryfunc)0, /*nb_negative*/
1836  (unaryfunc)0, /*nb_positive*/
1837  (unaryfunc)0, /*nb_absolute*/
1838  (inquiry)0, /*nb_nonzero*/
1839  0, /*nb_invert*/
1840  0, /*nb_lshift*/
1841  0, /*nb_rshift*/
1842  0, /*nb_and*/
1843  0, /*nb_xor*/
1844  0, /*nb_or*/
1845 #if PY_VERSION_HEX < 0x03000000
1846  0, /*nb_coerce*/
1847 #endif
1848  (unaryfunc)SwigPyObject_long, /*nb_int*/
1849 #if PY_VERSION_HEX < 0x03000000
1850  (unaryfunc)SwigPyObject_long, /*nb_long*/
1851 #else
1852  0, /*nb_reserved*/
1853 #endif
1854  (unaryfunc)0, /*nb_float*/
1855 #if PY_VERSION_HEX < 0x03000000
1856  (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1857  (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1858 #endif
1859 #if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1860  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1861 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1862  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1863 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1864  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1865 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1866  0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1867 #endif
1868  };
1869 
1870  static PyTypeObject swigpyobject_type;
1871  static int type_init = 0;
1872  if (!type_init) {
1873  const PyTypeObject tmp = {
1874  /* PyObject header changed in Python 3 */
1875 #if PY_VERSION_HEX >= 0x03000000
1876  PyVarObject_HEAD_INIT(NULL, 0)
1877 #else
1878  PyObject_HEAD_INIT(NULL)
1879  0, /* ob_size */
1880 #endif
1881  (char *)"SwigPyObject", /* tp_name */
1882  sizeof(SwigPyObject), /* tp_basicsize */
1883  0, /* tp_itemsize */
1884  (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1885  (printfunc)SwigPyObject_print, /* tp_print */
1886 #if PY_VERSION_HEX < 0x02020000
1887  (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1888 #else
1889  (getattrfunc)0, /* tp_getattr */
1890 #endif
1891  (setattrfunc)0, /* tp_setattr */
1892 #if PY_VERSION_HEX >= 0x03000000
1893  0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1894 #else
1895  (cmpfunc)SwigPyObject_compare, /* tp_compare */
1896 #endif
1897  (reprfunc)SwigPyObject_repr, /* tp_repr */
1898  &SwigPyObject_as_number, /* tp_as_number */
1899  0, /* tp_as_sequence */
1900  0, /* tp_as_mapping */
1901  (hashfunc)0, /* tp_hash */
1902  (ternaryfunc)0, /* tp_call */
1903  (reprfunc)SwigPyObject_str, /* tp_str */
1904  PyObject_GenericGetAttr, /* tp_getattro */
1905  0, /* tp_setattro */
1906  0, /* tp_as_buffer */
1907  Py_TPFLAGS_DEFAULT, /* tp_flags */
1908  swigobject_doc, /* tp_doc */
1909  0, /* tp_traverse */
1910  0, /* tp_clear */
1911  (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1912  0, /* tp_weaklistoffset */
1913 #if PY_VERSION_HEX >= 0x02020000
1914  0, /* tp_iter */
1915  0, /* tp_iternext */
1916  swigobject_methods, /* tp_methods */
1917  0, /* tp_members */
1918  0, /* tp_getset */
1919  0, /* tp_base */
1920  0, /* tp_dict */
1921  0, /* tp_descr_get */
1922  0, /* tp_descr_set */
1923  0, /* tp_dictoffset */
1924  0, /* tp_init */
1925  0, /* tp_alloc */
1926  0, /* tp_new */
1927  0, /* tp_free */
1928  0, /* tp_is_gc */
1929  0, /* tp_bases */
1930  0, /* tp_mro */
1931  0, /* tp_cache */
1932  0, /* tp_subclasses */
1933  0, /* tp_weaklist */
1934 #endif
1935 #if PY_VERSION_HEX >= 0x02030000
1936  0, /* tp_del */
1937 #endif
1938 #if PY_VERSION_HEX >= 0x02060000
1939  0, /* tp_version */
1940 #endif
1941 #ifdef COUNT_ALLOCS
1942  0,0,0,0 /* tp_alloc -> tp_next */
1943 #endif
1944  };
1945  swigpyobject_type = tmp;
1946  type_init = 1;
1947 #if PY_VERSION_HEX < 0x02020000
1948  swigpyobject_type.ob_type = &PyType_Type;
1949 #else
1950  if (PyType_Ready(&swigpyobject_type) < 0)
1951  return NULL;
1952 #endif
1953  }
1954  return &swigpyobject_type;
1955 }
1956 
1957 SWIGRUNTIME PyObject *
1958 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1959 {
1960  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1961  if (sobj) {
1962  sobj->ptr = ptr;
1963  sobj->ty = ty;
1964  sobj->own = own;
1965  sobj->next = 0;
1966  }
1967  return (PyObject *)sobj;
1968 }
1969 
1970 /* -----------------------------------------------------------------------------
1971  * Implements a simple Swig Packed type, and use it instead of string
1972  * ----------------------------------------------------------------------------- */
1973 
1974 typedef struct {
1975  PyObject_HEAD
1976  void *pack;
1978  size_t size;
1979 } SwigPyPacked;
1980 
1981 SWIGRUNTIME int
1983 {
1984  char result[SWIG_BUFFER_SIZE];
1985  fputs("<Swig Packed ", fp);
1986  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1987  fputs("at ", fp);
1988  fputs(result, fp);
1989  }
1990  fputs(v->ty->name,fp);
1991  fputs(">", fp);
1992  return 0;
1993 }
1994 
1995 SWIGRUNTIME PyObject *
1997 {
1998  char result[SWIG_BUFFER_SIZE];
1999  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2000  return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2001  } else {
2002  return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2003  }
2004 }
2005 
2006 SWIGRUNTIME PyObject *
2008 {
2009  char result[SWIG_BUFFER_SIZE];
2010  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2011  return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2012  } else {
2013  return SWIG_Python_str_FromChar(v->ty->name);
2014  }
2015 }
2016 
2017 SWIGRUNTIME int
2019 {
2020  size_t i = v->size;
2021  size_t j = w->size;
2022  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2023  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2024 }
2025 
2026 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2027 
2028 SWIGRUNTIME PyTypeObject*
2030  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2031  return type;
2032 }
2033 
2035 SwigPyPacked_Check(PyObject *op) {
2036  return ((op)->ob_type == SwigPyPacked_TypeOnce())
2037  || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2038 }
2039 
2040 SWIGRUNTIME void
2042 {
2043  if (SwigPyPacked_Check(v)) {
2044  SwigPyPacked *sobj = (SwigPyPacked *) v;
2045  free(sobj->pack);
2046  }
2047  PyObject_DEL(v);
2048 }
2049 
2050 SWIGRUNTIME PyTypeObject*
2052  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2053  static PyTypeObject swigpypacked_type;
2054  static int type_init = 0;
2055  if (!type_init) {
2056  const PyTypeObject tmp = {
2057  /* PyObject header changed in Python 3 */
2058 #if PY_VERSION_HEX>=0x03000000
2059  PyVarObject_HEAD_INIT(NULL, 0)
2060 #else
2061  PyObject_HEAD_INIT(NULL)
2062  0, /* ob_size */
2063 #endif
2064  (char *)"SwigPyPacked", /* tp_name */
2065  sizeof(SwigPyPacked), /* tp_basicsize */
2066  0, /* tp_itemsize */
2067  (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2068  (printfunc)SwigPyPacked_print, /* tp_print */
2069  (getattrfunc)0, /* tp_getattr */
2070  (setattrfunc)0, /* tp_setattr */
2071 #if PY_VERSION_HEX>=0x03000000
2072  0, /* tp_reserved in 3.0.1 */
2073 #else
2074  (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2075 #endif
2076  (reprfunc)SwigPyPacked_repr, /* tp_repr */
2077  0, /* tp_as_number */
2078  0, /* tp_as_sequence */
2079  0, /* tp_as_mapping */
2080  (hashfunc)0, /* tp_hash */
2081  (ternaryfunc)0, /* tp_call */
2082  (reprfunc)SwigPyPacked_str, /* tp_str */
2083  PyObject_GenericGetAttr, /* tp_getattro */
2084  0, /* tp_setattro */
2085  0, /* tp_as_buffer */
2086  Py_TPFLAGS_DEFAULT, /* tp_flags */
2087  swigpacked_doc, /* tp_doc */
2088  0, /* tp_traverse */
2089  0, /* tp_clear */
2090  0, /* tp_richcompare */
2091  0, /* tp_weaklistoffset */
2092 #if PY_VERSION_HEX >= 0x02020000
2093  0, /* tp_iter */
2094  0, /* tp_iternext */
2095  0, /* tp_methods */
2096  0, /* tp_members */
2097  0, /* tp_getset */
2098  0, /* tp_base */
2099  0, /* tp_dict */
2100  0, /* tp_descr_get */
2101  0, /* tp_descr_set */
2102  0, /* tp_dictoffset */
2103  0, /* tp_init */
2104  0, /* tp_alloc */
2105  0, /* tp_new */
2106  0, /* tp_free */
2107  0, /* tp_is_gc */
2108  0, /* tp_bases */
2109  0, /* tp_mro */
2110  0, /* tp_cache */
2111  0, /* tp_subclasses */
2112  0, /* tp_weaklist */
2113 #endif
2114 #if PY_VERSION_HEX >= 0x02030000
2115  0, /* tp_del */
2116 #endif
2117 #if PY_VERSION_HEX >= 0x02060000
2118  0, /* tp_version */
2119 #endif
2120 #ifdef COUNT_ALLOCS
2121  0,0,0,0 /* tp_alloc -> tp_next */
2122 #endif
2123  };
2124  swigpypacked_type = tmp;
2125  type_init = 1;
2126 #if PY_VERSION_HEX < 0x02020000
2127  swigpypacked_type.ob_type = &PyType_Type;
2128 #else
2129  if (PyType_Ready(&swigpypacked_type) < 0)
2130  return NULL;
2131 #endif
2132  }
2133  return &swigpypacked_type;
2134 }
2135 
2136 SWIGRUNTIME PyObject *
2137 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2138 {
2139  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2140  if (sobj) {
2141  void *pack = malloc(size);
2142  if (pack) {
2143  memcpy(pack, ptr, size);
2144  sobj->pack = pack;
2145  sobj->ty = ty;
2146  sobj->size = size;
2147  } else {
2148  PyObject_DEL((PyObject *) sobj);
2149  sobj = 0;
2150  }
2151  }
2152  return (PyObject *) sobj;
2153 }
2154 
2156 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2157 {
2158  if (SwigPyPacked_Check(obj)) {
2159  SwigPyPacked *sobj = (SwigPyPacked *)obj;
2160  if (sobj->size != size) return 0;
2161  memcpy(ptr, sobj->pack, size);
2162  return sobj->ty;
2163  } else {
2164  return 0;
2165  }
2166 }
2167 
2168 /* -----------------------------------------------------------------------------
2169  * pointers/data manipulation
2170  * ----------------------------------------------------------------------------- */
2171 
2172 SWIGRUNTIMEINLINE PyObject *
2174 {
2175  return SWIG_Python_str_FromChar("this");
2176 }
2177 
2178 static PyObject *swig_this = NULL;
2179 
2180 SWIGRUNTIME PyObject *
2182 {
2183  if (swig_this == NULL)
2184  swig_this = _SWIG_This();
2185  return swig_this;
2186 }
2187 
2188 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2189 
2190 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2191 #if PY_VERSION_HEX>=0x03000000
2192 #define SWIG_PYTHON_SLOW_GETSET_THIS
2193 #endif
2194 
2196 SWIG_Python_GetSwigThis(PyObject *pyobj)
2197 {
2198  PyObject *obj;
2199 
2200  if (SwigPyObject_Check(pyobj))
2201  return (SwigPyObject *) pyobj;
2202 
2203 #ifdef SWIGPYTHON_BUILTIN
2204  (void)obj;
2205 # ifdef PyWeakref_CheckProxy
2206  if (PyWeakref_CheckProxy(pyobj)) {
2207  pyobj = PyWeakref_GET_OBJECT(pyobj);
2208  if (pyobj && SwigPyObject_Check(pyobj))
2209  return (SwigPyObject*) pyobj;
2210  }
2211 # endif
2212  return NULL;
2213 #else
2214 
2215  obj = 0;
2216 
2217 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2218  if (PyInstance_Check(pyobj)) {
2219  obj = _PyInstance_Lookup(pyobj, SWIG_This());
2220  } else {
2221  PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2222  if (dictptr != NULL) {
2223  PyObject *dict = *dictptr;
2224  obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2225  } else {
2226 #ifdef PyWeakref_CheckProxy
2227  if (PyWeakref_CheckProxy(pyobj)) {
2228  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2229  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2230  }
2231 #endif
2232  obj = PyObject_GetAttr(pyobj,SWIG_This());
2233  if (obj) {
2234  Py_DECREF(obj);
2235  } else {
2236  if (PyErr_Occurred()) PyErr_Clear();
2237  return 0;
2238  }
2239  }
2240  }
2241 #else
2242  obj = PyObject_GetAttr(pyobj,SWIG_This());
2243  if (obj) {
2244  Py_DECREF(obj);
2245  } else {
2246  if (PyErr_Occurred()) PyErr_Clear();
2247  return 0;
2248  }
2249 #endif
2250  if (obj && !SwigPyObject_Check(obj)) {
2251  /* a PyObject is called 'this', try to get the 'real this'
2252  SwigPyObject from it */
2253  return SWIG_Python_GetSwigThis(obj);
2254  }
2255  return (SwigPyObject *)obj;
2256 #endif
2257 }
2258 
2259 /* Acquire a pointer value */
2260 
2261 SWIGRUNTIME int
2262 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2263  if (own == SWIG_POINTER_OWN) {
2265  if (sobj) {
2266  int oldown = sobj->own;
2267  sobj->own = own;
2268  return oldown;
2269  }
2270  }
2271  return 0;
2272 }
2273 
2274 /* Convert a pointer value */
2275 
2276 SWIGRUNTIME int
2277 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2278  int res;
2279  SwigPyObject *sobj;
2280 
2281  if (!obj)
2282  return SWIG_ERROR;
2283  if (obj == Py_None) {
2284  if (ptr)
2285  *ptr = 0;
2286  return SWIG_OK;
2287  }
2288 
2289  res = SWIG_ERROR;
2290 
2291  sobj = SWIG_Python_GetSwigThis(obj);
2292  if (own)
2293  *own = 0;
2294  while (sobj) {
2295  void *vptr = sobj->ptr;
2296  if (ty) {
2297  swig_type_info *to = sobj->ty;
2298  if (to == ty) {
2299  /* no type cast needed */
2300  if (ptr) *ptr = vptr;
2301  break;
2302  } else {
2303  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2304  if (!tc) {
2305  sobj = (SwigPyObject *)sobj->next;
2306  } else {
2307  if (ptr) {
2308  int newmemory = 0;
2309  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2310  if (newmemory == SWIG_CAST_NEW_MEMORY) {
2311  assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2312  if (own)
2313  *own = *own | SWIG_CAST_NEW_MEMORY;
2314  }
2315  }
2316  break;
2317  }
2318  }
2319  } else {
2320  if (ptr) *ptr = vptr;
2321  break;
2322  }
2323  }
2324  if (sobj) {
2325  if (own)
2326  *own = *own | sobj->own;
2327  if (flags & SWIG_POINTER_DISOWN) {
2328  sobj->own = 0;
2329  }
2330  res = SWIG_OK;
2331  } else {
2332  if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2333  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2334  if (data && !data->implicitconv) {
2335  PyObject *klass = data->klass;
2336  if (klass) {
2337  PyObject *impconv;
2338  data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2339  impconv = SWIG_Python_CallFunctor(klass, obj);
2340  data->implicitconv = 0;
2341  if (PyErr_Occurred()) {
2342  PyErr_Clear();
2343  impconv = 0;
2344  }
2345  if (impconv) {
2346  SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2347  if (iobj) {
2348  void *vptr;
2349  res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2350  if (SWIG_IsOK(res)) {
2351  if (ptr) {
2352  *ptr = vptr;
2353  /* transfer the ownership to 'ptr' */
2354  iobj->own = 0;
2355  res = SWIG_AddCast(res);
2356  res = SWIG_AddNewMask(res);
2357  } else {
2358  res = SWIG_AddCast(res);
2359  }
2360  }
2361  }
2362  Py_DECREF(impconv);
2363  }
2364  }
2365  }
2366  }
2367  }
2368  return res;
2369 }
2370 
2371 /* Convert a function ptr value */
2372 
2373 SWIGRUNTIME int
2374 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2375  if (!PyCFunction_Check(obj)) {
2376  return SWIG_ConvertPtr(obj, ptr, ty, 0);
2377  } else {
2378  void *vptr = 0;
2379 
2380  /* here we get the method pointer for callbacks */
2381  const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2382  const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2383  if (desc)
2384  desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2385  if (!desc)
2386  return SWIG_ERROR;
2387  if (ty) {
2388  swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2389  if (tc) {
2390  int newmemory = 0;
2391  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2392  assert(!newmemory); /* newmemory handling not yet implemented */
2393  } else {
2394  return SWIG_ERROR;
2395  }
2396  } else {
2397  *ptr = vptr;
2398  }
2399  return SWIG_OK;
2400  }
2401 }
2402 
2403 /* Convert a packed value value */
2404 
2405 SWIGRUNTIME int
2406 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2407  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2408  if (!to) return SWIG_ERROR;
2409  if (ty) {
2410  if (to != ty) {
2411  /* check type cast? */
2412  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2413  if (!tc) return SWIG_ERROR;
2414  }
2415  }
2416  return SWIG_OK;
2417 }
2418 
2419 /* -----------------------------------------------------------------------------
2420  * Create a new pointer object
2421  * ----------------------------------------------------------------------------- */
2422 
2423 /*
2424  Create a new instance object, without calling __init__, and set the
2425  'this' attribute.
2426 */
2427 
2428 SWIGRUNTIME PyObject*
2430 {
2431 #if (PY_VERSION_HEX >= 0x02020000)
2432  PyObject *inst = 0;
2433  PyObject *newraw = data->newraw;
2434  if (newraw) {
2435  inst = PyObject_Call(newraw, data->newargs, NULL);
2436  if (inst) {
2437 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2438  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2439  if (dictptr != NULL) {
2440  PyObject *dict = *dictptr;
2441  if (dict == NULL) {
2442  dict = PyDict_New();
2443  *dictptr = dict;
2444  PyDict_SetItem(dict, SWIG_This(), swig_this);
2445  }
2446  }
2447 #else
2448  PyObject *key = SWIG_This();
2449  PyObject_SetAttr(inst, key, swig_this);
2450 #endif
2451  }
2452  } else {
2453 #if PY_VERSION_HEX >= 0x03000000
2454  inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2455  if (inst) {
2456  PyObject_SetAttr(inst, SWIG_This(), swig_this);
2457  Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2458  }
2459 #else
2460  PyObject *dict = PyDict_New();
2461  if (dict) {
2462  PyDict_SetItem(dict, SWIG_This(), swig_this);
2463  inst = PyInstance_NewRaw(data->newargs, dict);
2464  Py_DECREF(dict);
2465  }
2466 #endif
2467  }
2468  return inst;
2469 #else
2470 #if (PY_VERSION_HEX >= 0x02010000)
2471  PyObject *inst = 0;
2472  PyObject *dict = PyDict_New();
2473  if (dict) {
2474  PyDict_SetItem(dict, SWIG_This(), swig_this);
2475  inst = PyInstance_NewRaw(data->newargs, dict);
2476  Py_DECREF(dict);
2477  }
2478  return (PyObject *) inst;
2479 #else
2480  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2481  if (inst == NULL) {
2482  return NULL;
2483  }
2484  inst->in_class = (PyClassObject *)data->newargs;
2485  Py_INCREF(inst->in_class);
2486  inst->in_dict = PyDict_New();
2487  if (inst->in_dict == NULL) {
2488  Py_DECREF(inst);
2489  return NULL;
2490  }
2491 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2492  inst->in_weakreflist = NULL;
2493 #endif
2494 #ifdef Py_TPFLAGS_GC
2495  PyObject_GC_Init(inst);
2496 #endif
2497  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2498  return (PyObject *) inst;
2499 #endif
2500 #endif
2501 }
2502 
2503 SWIGRUNTIME void
2504 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2505 {
2506  PyObject *dict;
2507 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2508  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2509  if (dictptr != NULL) {
2510  dict = *dictptr;
2511  if (dict == NULL) {
2512  dict = PyDict_New();
2513  *dictptr = dict;
2514  }
2515  PyDict_SetItem(dict, SWIG_This(), swig_this);
2516  return;
2517  }
2518 #endif
2519  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2520  PyDict_SetItem(dict, SWIG_This(), swig_this);
2521  Py_DECREF(dict);
2522 }
2523 
2524 
2525 SWIGINTERN PyObject *
2527  PyObject *obj[2];
2528  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2529  return NULL;
2530  } else {
2531  SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2532  if (sthis) {
2533  SwigPyObject_append((PyObject*) sthis, obj[1]);
2534  } else {
2535  SWIG_Python_SetSwigThis(obj[0], obj[1]);
2536  }
2537  return SWIG_Py_Void();
2538  }
2539 }
2540 
2541 /* Create a new pointer object */
2542 
2543 SWIGRUNTIME PyObject *
2544 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2545  SwigPyClientData *clientdata;
2546  PyObject * robj;
2547  int own;
2548 
2549  if (!ptr)
2550  return SWIG_Py_Void();
2551 
2552  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2553  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2554  if (clientdata && clientdata->pytype) {
2555  SwigPyObject *newobj;
2556  if (flags & SWIG_BUILTIN_TP_INIT) {
2557  newobj = (SwigPyObject*) self;
2558  if (newobj->ptr) {
2559  PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2560  while (newobj->next)
2561  newobj = (SwigPyObject *) newobj->next;
2562  newobj->next = next_self;
2563  newobj = (SwigPyObject *)next_self;
2564  }
2565  } else {
2566  newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2567  }
2568  if (newobj) {
2569  newobj->ptr = ptr;
2570  newobj->ty = type;
2571  newobj->own = own;
2572  newobj->next = 0;
2573 #ifdef SWIGPYTHON_BUILTIN
2574  newobj->dict = 0;
2575 #endif
2576  return (PyObject*) newobj;
2577  }
2578  return SWIG_Py_Void();
2579  }
2580 
2581  assert(!(flags & SWIG_BUILTIN_TP_INIT));
2582 
2583  robj = SwigPyObject_New(ptr, type, own);
2584  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2585  PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2586  Py_DECREF(robj);
2587  robj = inst;
2588  }
2589  return robj;
2590 }
2591 
2592 /* Create a new packed object */
2593 
2594 SWIGRUNTIMEINLINE PyObject *
2595 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2596  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2597 }
2598 
2599 /* -----------------------------------------------------------------------------*
2600  * Get type list
2601  * -----------------------------------------------------------------------------*/
2602 
2603 #ifdef SWIG_LINK_RUNTIME
2604 void *SWIG_ReturnGlobalTypeList(void *);
2605 #endif
2606 
2609  static void *type_pointer = (void *)0;
2610  /* first check if module already created */
2611  if (!type_pointer) {
2612 #ifdef SWIG_LINK_RUNTIME
2613  type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2614 #else
2615 # ifdef SWIGPY_USE_CAPSULE
2616  type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2617 # else
2618  type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2619  (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2620 # endif
2621  if (PyErr_Occurred()) {
2622  PyErr_Clear();
2623  type_pointer = (void *)0;
2624  }
2625 #endif
2626  }
2627  return (swig_module_info *) type_pointer;
2628 }
2629 
2630 #if PY_MAJOR_VERSION < 2
2631 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2632  is copied out of Python/modsupport.c in python version 2.3.4 */
2633 SWIGINTERN int
2634 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2635 {
2636  PyObject *dict;
2637  if (!PyModule_Check(m)) {
2638  PyErr_SetString(PyExc_TypeError,
2639  "PyModule_AddObject() needs module as first arg");
2640  return SWIG_ERROR;
2641  }
2642  if (!o) {
2643  PyErr_SetString(PyExc_TypeError,
2644  "PyModule_AddObject() needs non-NULL value");
2645  return SWIG_ERROR;
2646  }
2647 
2648  dict = PyModule_GetDict(m);
2649  if (dict == NULL) {
2650  /* Internal error -- modules must have a dict! */
2651  PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2652  PyModule_GetName(m));
2653  return SWIG_ERROR;
2654  }
2655  if (PyDict_SetItemString(dict, name, o))
2656  return SWIG_ERROR;
2657  Py_DECREF(o);
2658  return SWIG_OK;
2659 }
2660 #endif
2661 
2662 SWIGRUNTIME void
2663 #ifdef SWIGPY_USE_CAPSULE
2664 SWIG_Python_DestroyModule(PyObject *obj)
2665 #else
2667 #endif
2668 {
2669 #ifdef SWIGPY_USE_CAPSULE
2670  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2671 #else
2672  swig_module_info *swig_module = (swig_module_info *) vptr;
2673 #endif
2674  swig_type_info **types = swig_module->types;
2675  size_t i;
2676  for (i =0; i < swig_module->size; ++i) {
2677  swig_type_info *ty = types[i];
2678  if (ty->owndata) {
2680  if (data) SwigPyClientData_Del(data);
2681  }
2682  }
2683  Py_DECREF(SWIG_This());
2684  swig_this = NULL;
2685 }
2686 
2687 SWIGRUNTIME void
2689 #if PY_VERSION_HEX >= 0x03000000
2690  /* Add a dummy module object into sys.modules */
2691  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2692 #else
2693  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2694  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2695 #endif
2696 #ifdef SWIGPY_USE_CAPSULE
2697  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2698  if (pointer && module) {
2699  PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2700  } else {
2701  Py_XDECREF(pointer);
2702  }
2703 #else
2704  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2705  if (pointer && module) {
2706  PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2707  } else {
2708  Py_XDECREF(pointer);
2709  }
2710 #endif
2711 }
2712 
2713 /* The python cached type query */
2714 SWIGRUNTIME PyObject *
2716  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2717  return cache;
2718 }
2719 
2721 SWIG_Python_TypeQuery(const char *type)
2722 {
2723  PyObject *cache = SWIG_Python_TypeCache();
2724  PyObject *key = SWIG_Python_str_FromChar(type);
2725  PyObject *obj = PyDict_GetItem(cache, key);
2726  swig_type_info *descriptor;
2727  if (obj) {
2728 #ifdef SWIGPY_USE_CAPSULE
2729  descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2730 #else
2731  descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2732 #endif
2733  } else {
2735  descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2736  if (descriptor) {
2737 #ifdef SWIGPY_USE_CAPSULE
2738  obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2739 #else
2740  obj = PyCObject_FromVoidPtr(descriptor, NULL);
2741 #endif
2742  PyDict_SetItem(cache, key, obj);
2743  Py_DECREF(obj);
2744  }
2745  }
2746  Py_DECREF(key);
2747  return descriptor;
2748 }
2749 
2750 /*
2751  For backward compatibility only
2752 */
2753 #define SWIG_POINTER_EXCEPTION 0
2754 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2755 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2756 
2757 SWIGRUNTIME int
2758 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2759 {
2760  if (PyErr_Occurred()) {
2761  PyObject *type = 0;
2762  PyObject *value = 0;
2763  PyObject *traceback = 0;
2764  PyErr_Fetch(&type, &value, &traceback);
2765  if (value) {
2766  char *tmp;
2767  PyObject *old_str = PyObject_Str(value);
2768  Py_XINCREF(type);
2769  PyErr_Clear();
2770  if (infront) {
2771  PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2772  } else {
2773  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2774  }
2776  Py_DECREF(old_str);
2777  }
2778  return 1;
2779  } else {
2780  return 0;
2781  }
2782 }
2783 
2784 SWIGRUNTIME int
2786 {
2787  if (PyErr_Occurred()) {
2788  /* add information about failing argument */
2789  char mesg[256];
2790  PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2791  return SWIG_Python_AddErrMesg(mesg, 1);
2792  } else {
2793  return 0;
2794  }
2795 }
2796 
2797 SWIGRUNTIMEINLINE const char *
2798 SwigPyObject_GetDesc(PyObject *self)
2799 {
2800  SwigPyObject *v = (SwigPyObject *)self;
2801  swig_type_info *ty = v ? v->ty : 0;
2802  return ty ? ty->str : "";
2803 }
2804 
2805 SWIGRUNTIME void
2806 SWIG_Python_TypeError(const char *type, PyObject *obj)
2807 {
2808  if (type) {
2809 #if defined(SWIG_COBJECT_TYPES)
2810  if (obj && SwigPyObject_Check(obj)) {
2811  const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2812  if (otype) {
2813  PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2814  type, otype);
2815  return;
2816  }
2817  } else
2818 #endif
2819  {
2820  const char *otype = (obj ? obj->ob_type->tp_name : 0);
2821  if (otype) {
2822  PyObject *str = PyObject_Str(obj);
2823  const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2824  if (cstr) {
2825  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2826  type, otype, cstr);
2828  } else {
2829  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2830  type, otype);
2831  }
2832  Py_XDECREF(str);
2833  return;
2834  }
2835  }
2836  PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2837  } else {
2838  PyErr_Format(PyExc_TypeError, "unexpected type is received");
2839  }
2840 }
2841 
2842 
2843 /* Convert a pointer value, signal an exception on a type mismatch */
2844 SWIGRUNTIME void *
2845 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2846  void *result;
2847  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2848  PyErr_Clear();
2849 #if SWIG_POINTER_EXCEPTION
2850  if (flags) {
2852  SWIG_Python_ArgFail(argnum);
2853  }
2854 #endif
2855  }
2856  return result;
2857 }
2858 
2859 #ifdef SWIGPYTHON_BUILTIN
2860 SWIGRUNTIME int
2861 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2862  PyTypeObject *tp = obj->ob_type;
2863  PyObject *descr;
2864  PyObject *encoded_name;
2865  descrsetfunc f;
2866  int res;
2867 
2868 # ifdef Py_USING_UNICODE
2869  if (PyString_Check(name)) {
2870  name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2871  if (!name)
2872  return -1;
2873  } else if (!PyUnicode_Check(name))
2874 # else
2875  if (!PyString_Check(name))
2876 # endif
2877  {
2878  PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2879  return -1;
2880  } else {
2881  Py_INCREF(name);
2882  }
2883 
2884  if (!tp->tp_dict) {
2885  if (PyType_Ready(tp) < 0)
2886  goto done;
2887  }
2888 
2889  res = -1;
2890  descr = _PyType_Lookup(tp, name);
2891  f = NULL;
2892  if (descr != NULL)
2893  f = descr->ob_type->tp_descr_set;
2894  if (!f) {
2895  if (PyString_Check(name)) {
2896  encoded_name = name;
2897  Py_INCREF(name);
2898  } else {
2899  encoded_name = PyUnicode_AsUTF8String(name);
2900  }
2901  PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2902  Py_DECREF(encoded_name);
2903  } else {
2904  res = f(descr, obj, value);
2905  }
2906 
2907  done:
2908  Py_DECREF(name);
2909  return res;
2910 }
2911 #endif
2912 
2913 
2914 #ifdef __cplusplus
2915 }
2916 #endif
2917 
2918 
2919 
2920 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2921 
2922 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2923 
2924 
2925 
2926 /* -------- TYPES TABLE (BEGIN) -------- */
2927 
2928 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2929 #define SWIGTYPE_p_PLcGrid swig_types[1]
2930 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
2931 #define SWIGTYPE_p_char swig_types[3]
2932 #define SWIGTYPE_p_double swig_types[4]
2933 #define SWIGTYPE_p_f_double_double__int swig_types[5]
2934 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
2935 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
2936 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
2937 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
2938 #define SWIGTYPE_p_int swig_types[10]
2939 #define SWIGTYPE_p_p_char swig_types[11]
2940 #define SWIGTYPE_p_p_double swig_types[12]
2941 #define SWIGTYPE_p_unsigned_int swig_types[13]
2943 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
2944 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2945 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2946 
2947 /* -------- TYPES TABLE (END) -------- */
2948 
2949 #if (PY_VERSION_HEX <= 0x02000000)
2950 # if !defined(SWIG_PYTHON_CLASSIC)
2951 # error "This python version requires swig to be run with the '-classic' option"
2952 # endif
2953 #endif
2954 
2955 /*-----------------------------------------------
2956  @(target):= _plplotc.so
2957  ------------------------------------------------*/
2958 #if PY_VERSION_HEX >= 0x03000000
2959 # define SWIG_init PyInit__plplotc
2960 
2961 #else
2962 # define SWIG_init init_plplotc
2963 
2964 #endif
2965 #define SWIG_name "_plplotc"
2966 
2967 #define SWIGVERSION 0x020010
2968 #define SWIG_VERSION SWIGVERSION
2969 
2970 
2971 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2972 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2973 
2974 
2975 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
2976 #include <arrayobject.h>
2977 #include "plplot.h"
2978 #include "plplotP.h"
2979 
2980 #define NPY_PLINT NPY_INT32
2981 
2982 #ifdef PL_DOUBLE
2983 #define NPY_PLFLT NPY_DOUBLE
2984 #else
2985 #define NPY_PLFLT NPY_FLOAT
2986 #endif
2987 
2988 // python-1.5 compatibility mode?
2989 #if !defined ( PySequence_Fast_GET_ITEM )
2990  #define PySequence_Fast_GET_ITEM PySequence_GetItem
2991 #endif
2992 #define PySequence_Size PySequence_Length
2993 
2994 
2995  static PLINT Alen = 0;
2996  static PLINT Xlen = 0, Ylen = 0;
2997 
2998 
2999 SWIGINTERN int
3000 SWIG_AsVal_double (PyObject *obj, double *val)
3001 {
3002  int res = SWIG_TypeError;
3003  if (PyFloat_Check(obj)) {
3004  if (val) *val = PyFloat_AsDouble(obj);
3005  return SWIG_OK;
3006  } else if (PyInt_Check(obj)) {
3007  if (val) *val = PyInt_AsLong(obj);
3008  return SWIG_OK;
3009  } else if (PyLong_Check(obj)) {
3010  double v = PyLong_AsDouble(obj);
3011  if (!PyErr_Occurred()) {
3012  if (val) *val = v;
3013  return SWIG_OK;
3014  } else {
3015  PyErr_Clear();
3016  }
3017  }
3018 #ifdef SWIG_PYTHON_CAST_MODE
3019  {
3020  int dispatch = 0;
3021  double d = PyFloat_AsDouble(obj);
3022  if (!PyErr_Occurred()) {
3023  if (val) *val = d;
3024  return SWIG_AddCast(SWIG_OK);
3025  } else {
3026  PyErr_Clear();
3027  }
3028  if (!dispatch) {
3029  long v = PyLong_AsLong(obj);
3030  if (!PyErr_Occurred()) {
3031  if (val) *val = v;
3033  } else {
3034  PyErr_Clear();
3035  }
3036  }
3037  }
3038 #endif
3039  return res;
3040 }
3041 
3042 
3043  #define SWIG_From_double PyFloat_FromDouble
3044 
3045 
3046  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3047  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3048  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3049  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3050  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3052  typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
3053 
3054 
3055 SWIGINTERNINLINE PyObject*
3056  SWIG_From_int (int value)
3057 {
3058  return PyInt_FromLong((long) value);
3059 }
3060 
3061 
3062 #include <limits.h>
3063 #if !defined(SWIG_NO_LLONG_MAX)
3064 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3065 # define LLONG_MAX __LONG_LONG_MAX__
3066 # define LLONG_MIN (-LLONG_MAX - 1LL)
3067 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3068 # endif
3069 #endif
3070 
3071 
3072 #include <float.h>
3073 
3074 
3075 #include <math.h>
3076 
3077 
3078 SWIGINTERNINLINE int
3079 SWIG_CanCastAsInteger(double *d, double min, double max) {
3080  double x = *d;
3081  if ((min <= x && x <= max)) {
3082  double fx = floor(x);
3083  double cx = ceil(x);
3084  double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3085  if ((errno == EDOM) || (errno == ERANGE)) {
3086  errno = 0;
3087  } else {
3088  double summ, reps, diff;
3089  if (rd < x) {
3090  diff = x - rd;
3091  } else if (rd > x) {
3092  diff = rd - x;
3093  } else {
3094  return 1;
3095  }
3096  summ = rd + x;
3097  reps = diff/summ;
3098  if (reps < 8*DBL_EPSILON) {
3099  *d = rd;
3100  return 1;
3101  }
3102  }
3103  }
3104  return 0;
3105 }
3106 
3107 
3108 SWIGINTERN int
3109 SWIG_AsVal_long (PyObject *obj, long* val)
3110 {
3111  if (PyInt_Check(obj)) {
3112  if (val) *val = PyInt_AsLong(obj);
3113  return SWIG_OK;
3114  } else if (PyLong_Check(obj)) {
3115  long v = PyLong_AsLong(obj);
3116  if (!PyErr_Occurred()) {
3117  if (val) *val = v;
3118  return SWIG_OK;
3119  } else {
3120  PyErr_Clear();
3121  }
3122  }
3123 #ifdef SWIG_PYTHON_CAST_MODE
3124  {
3125  int dispatch = 0;
3126  long v = PyInt_AsLong(obj);
3127  if (!PyErr_Occurred()) {
3128  if (val) *val = v;
3129  return SWIG_AddCast(SWIG_OK);
3130  } else {
3131  PyErr_Clear();
3132  }
3133  if (!dispatch) {
3134  double d;
3135  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3136  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3137  if (val) *val = (long)(d);
3138  return res;
3139  }
3140  }
3141  }
3142 #endif
3143  return SWIG_TypeError;
3144 }
3145 
3146 
3147 SWIGINTERN int
3148 SWIG_AsVal_int (PyObject * obj, int *val)
3149 {
3150  long v;
3151  int res = SWIG_AsVal_long (obj, &v);
3152  if (SWIG_IsOK(res)) {
3153  if ((v < INT_MIN || v > INT_MAX)) {
3154  return SWIG_OverflowError;
3155  } else {
3156  if (val) *val = (int)(v);
3157  }
3158  }
3159  return res;
3160 }
3161 
3162 
3163 SWIGINTERN int
3164 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3165 {
3166 #if PY_VERSION_HEX < 0x03000000
3167  if (PyInt_Check(obj)) {
3168  long v = PyInt_AsLong(obj);
3169  if (v >= 0) {
3170  if (val) *val = v;
3171  return SWIG_OK;
3172  } else {
3173  return SWIG_OverflowError;
3174  }
3175  } else
3176 #endif
3177  if (PyLong_Check(obj)) {
3178  unsigned long v = PyLong_AsUnsignedLong(obj);
3179  if (!PyErr_Occurred()) {
3180  if (val) *val = v;
3181  return SWIG_OK;
3182  } else {
3183  PyErr_Clear();
3184 #if PY_VERSION_HEX >= 0x03000000
3185  {
3186  long v = PyLong_AsLong(obj);
3187  if (!PyErr_Occurred()) {
3188  if (v < 0) {
3189  return SWIG_OverflowError;
3190  }
3191  } else {
3192  PyErr_Clear();
3193  }
3194  }
3195 #endif
3196  }
3197  }
3198 #ifdef SWIG_PYTHON_CAST_MODE
3199  {
3200  int dispatch = 0;
3201  unsigned long v = PyLong_AsUnsignedLong(obj);
3202  if (!PyErr_Occurred()) {
3203  if (val) *val = v;
3204  return SWIG_AddCast(SWIG_OK);
3205  } else {
3206  PyErr_Clear();
3207  }
3208  if (!dispatch) {
3209  double d;
3210  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3211  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3212  if (val) *val = (unsigned long)(d);
3213  return res;
3214  }
3215  }
3216  }
3217 #endif
3218  return SWIG_TypeError;
3219 }
3220 
3221 
3222 SWIGINTERN int
3223 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3224 {
3225  unsigned long v;
3226  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3227  if (SWIG_IsOK(res)) {
3228  if ((v > UINT_MAX)) {
3229  return SWIG_OverflowError;
3230  } else {
3231  if (val) *val = (unsigned int)(v);
3232  }
3233  }
3234  return res;
3235 }
3236 
3237 
3238 SWIGINTERNINLINE PyObject*
3239  SWIG_From_unsigned_SS_int (unsigned int value)
3240 {
3241  return PyInt_FromSize_t((size_t) value);
3242 }
3243 
3244 
3247 {
3248  static int init = 0;
3249  static swig_type_info* info = 0;
3250  if (!init) {
3251  info = SWIG_TypeQuery("_p_char");
3252  init = 1;
3253  }
3254  return info;
3255 }
3256 
3257 
3258 SWIGINTERN int
3259 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3260 {
3261 #if PY_VERSION_HEX>=0x03000000
3262  if (PyUnicode_Check(obj))
3263 #else
3264  if (PyString_Check(obj))
3265 #endif
3266  {
3267  char *cstr; Py_ssize_t len;
3268 #if PY_VERSION_HEX>=0x03000000
3269  if (!alloc && cptr) {
3270  /* We can't allow converting without allocation, since the internal
3271  representation of string in Python 3 is UCS-2/UCS-4 but we require
3272  a UTF-8 representation.
3273  TODO(bhy) More detailed explanation */
3274  return SWIG_RuntimeError;
3275  }
3276  obj = PyUnicode_AsUTF8String(obj);
3277  PyBytes_AsStringAndSize(obj, &cstr, &len);
3278  if(alloc) *alloc = SWIG_NEWOBJ;
3279 #else
3280  PyString_AsStringAndSize(obj, &cstr, &len);
3281 #endif
3282  if (cptr) {
3283  if (alloc) {
3284  /*
3285  In python the user should not be able to modify the inner
3286  string representation. To warranty that, if you define
3287  SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3288  buffer is always returned.
3289 
3290  The default behavior is just to return the pointer value,
3291  so, be careful.
3292  */
3293 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3294  if (*alloc != SWIG_OLDOBJ)
3295 #else
3296  if (*alloc == SWIG_NEWOBJ)
3297 #endif
3298  {
3299  *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3300  *alloc = SWIG_NEWOBJ;
3301  }
3302  else {
3303  *cptr = cstr;
3304  *alloc = SWIG_OLDOBJ;
3305  }
3306  } else {
3307  #if PY_VERSION_HEX>=0x03000000
3308  assert(0); /* Should never reach here in Python 3 */
3309  #endif
3310  *cptr = SWIG_Python_str_AsChar(obj);
3311  }
3312  }
3313  if (psize) *psize = len + 1;
3314 #if PY_VERSION_HEX>=0x03000000
3315  Py_XDECREF(obj);
3316 #endif
3317  return SWIG_OK;
3318  } else {
3319  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3320  if (pchar_descriptor) {
3321  void* vptr = 0;
3322  if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3323  if (cptr) *cptr = (char *) vptr;
3324  if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3325  if (alloc) *alloc = SWIG_OLDOBJ;
3326  return SWIG_OK;
3327  }
3328  }
3329  }
3330  return SWIG_TypeError;
3331 }
3332 
3333 
3334 SWIGINTERN int
3335 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3336 {
3337  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3338  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3339  if (SWIG_IsOK(res)) {
3340  if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3341  if (csize <= size) {
3342  if (val) {
3343  if (csize) memcpy(val, cptr, csize*sizeof(char));
3344  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3345  }
3346  if (alloc == SWIG_NEWOBJ) {
3347  free((char*)cptr);
3348  res = SWIG_DelNewMask(res);
3349  }
3350  return res;
3351  }
3352  if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3353  }
3354  return SWIG_TypeError;
3355 }
3356 
3357 
3358 SWIGINTERNINLINE PyObject *
3359 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3360 {
3361  if (carray) {
3362  if (size > INT_MAX) {
3363  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3364  return pchar_descriptor ?
3365  SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3366  } else {
3367 #if PY_VERSION_HEX >= 0x03000000
3368  return PyUnicode_FromStringAndSize(carray, (int)(size));
3369 #else
3370  return PyString_FromStringAndSize(carray, (int)(size));
3371 #endif
3372  }
3373  } else {
3374  return SWIG_Py_Void();
3375  }
3376 }
3377 
3378 
3379 
3380 
3381 
3382 #define t_output_helper SWIG_Python_AppendOutput
3383 
3384 
3385 SWIGINTERN int
3386 SWIG_AsVal_char (PyObject * obj, char *val)
3387 {
3388  int res = SWIG_AsCharArray(obj, val, 1);
3389  if (!SWIG_IsOK(res)) {
3390  long v;
3391  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3392  if (SWIG_IsOK(res)) {
3393  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3394  if (val) *val = (char)(v);
3395  } else {
3396  res = SWIG_OverflowError;
3397  }
3398  }
3399  }
3400  return res;
3401 }
3402 
3403 #ifdef __cplusplus
3404 extern "C" {
3405 #endif
3406 
3407 // some really twisted stuff to allow calling a single precision library from python
3408  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims )
3409  {
3410  PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3411  mindims, maxdims );
3412  if ( !tmp )
3413  {
3414  // could be an incoming long array which can't be "safely" converted, do it anyway
3415  if ( PyArray_Check( in ) )
3416  {
3417  PyErr_Clear();
3418  tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3419  }
3420  }
3421  return tmp;
3422  }
3423 
3424 
3425 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3426 
3427 SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3428  PyObject *resultobj = 0;
3429  PLFLT arg1 ;
3430  PLFLT arg2 ;
3431  PLFLT *arg3 = (PLFLT *) 0 ;
3432  PLFLT *arg4 = (PLFLT *) 0 ;
3433  PLPointer arg5 = (PLPointer) 0 ;
3434  double val1 ;
3435  int ecode1 = 0 ;
3436  double val2 ;
3437  int ecode2 = 0 ;
3438  PLFLT temp3 ;
3439  int res3 = SWIG_TMPOBJ ;
3440  PLFLT temp4 ;
3441  int res4 = SWIG_TMPOBJ ;
3442  PyObject * obj0 = 0 ;
3443  PyObject * obj1 = 0 ;
3444 
3445  arg3 = &temp3;
3446  arg4 = &temp4;
3447  {
3448  arg5 = NULL;
3449  }
3450  if (!PyArg_ParseTuple(args,(char *)"OO:pltr0",&obj0,&obj1)) SWIG_fail;
3451  ecode1 = SWIG_AsVal_double(obj0, &val1);
3452  if (!SWIG_IsOK(ecode1)) {
3453  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3454  }
3455  arg1 = (PLFLT)(val1);
3456  ecode2 = SWIG_AsVal_double(obj1, &val2);
3457  if (!SWIG_IsOK(ecode2)) {
3458  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3459  }
3460  arg2 = (PLFLT)(val2);
3461  pltr0(arg1,arg2,arg3,arg4,arg5);
3462  resultobj = SWIG_Py_Void();
3463  if (SWIG_IsTmpObj(res3)) {
3464  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3465  } else {
3466  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3467  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3468  }
3469  if (SWIG_IsTmpObj(res4)) {
3470  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3471  } else {
3472  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3473  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3474  }
3475  return resultobj;
3476 fail:
3477  return NULL;
3478 }
3479 
3480 
3481 
3482  PyArrayObject *pltr_xg, *pltr_yg;
3485 
3486  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3487  {
3488  // fprintf(stderr, "marshal PLcGrid1\n");
3489  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3490  {
3491  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3492  return NULL;
3493  }
3494  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3495  NPY_PLFLT, 1, 1 );
3496  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3497  NPY_PLFLT, 1, 1 );
3498  if ( pltr_xg == 0 || pltr_yg == 0 )
3499  {
3500  PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3501  return NULL;
3502  }
3503  tmpGrid1.nx = PyArray_DIMS( pltr_xg )[0];
3504  tmpGrid1.ny = PyArray_DIMS( pltr_yg )[0];
3505  if ( isimg == 0 )
3506  {
3507  if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3508  {
3509  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3510  return NULL;
3511  }
3512  }
3513  else
3514  {
3515  if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3516  {
3517  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3518  return NULL;
3519  }
3520  }
3521  tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3522  tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3523  return &tmpGrid1;
3524  }
3525 
3526  void cleanup_PLcGrid1( void )
3527  {
3528  // fprintf(stderr, "cleanup PLcGrid1\n");
3529  Py_DECREF( pltr_xg );
3530  Py_DECREF( pltr_yg );
3531  }
3532 
3533  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3534  {
3535  int i, size;
3536  // fprintf(stderr, "marshal PLcGrid2\n");
3537  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3538  {
3539  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3540  return NULL;
3541  }
3542  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3543  NPY_PLFLT, 2, 2 );
3544  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3545  NPY_PLFLT, 2, 2 );
3546  if ( pltr_xg == 0 || pltr_yg == 0 )
3547  {
3548  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3549  return NULL;
3550  }
3551  if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3552  PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3553  {
3554  PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3555  return NULL;
3556  }
3557  tmpGrid2.nx = PyArray_DIMS( pltr_xg )[0];
3558  tmpGrid2.ny = PyArray_DIMS( pltr_xg )[1];
3559  if ( isimg == 0 )
3560  {
3561  if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3562  {
3563  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3564  return NULL;
3565  }
3566  }
3567  else
3568  {
3569  if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3570  {
3571  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3572  return NULL;
3573  }
3574  }
3575  size = sizeof ( PLFLT ) * tmpGrid2.ny;
3576  tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * tmpGrid2.nx );
3577  for ( i = 0; i < tmpGrid2.nx; i++ )
3578  tmpGrid2.xg[i] = (PLFLT *) ( PyArray_DATA( pltr_xg ) + i * size );
3579  tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * tmpGrid2.nx );
3580  for ( i = 0; i < tmpGrid2.nx; i++ )
3581  tmpGrid2.yg[i] = (PLFLT *) ( PyArray_DATA( pltr_yg ) + i * size );
3582  return &tmpGrid2;
3583  }
3584 
3585  void cleanup_PLcGrid2( void )
3586  {
3587  // fprintf(stderr, "cleanup PLcGrid2\n");
3588  free( tmpGrid2.xg );
3589  free( tmpGrid2.yg );
3590  Py_DECREF( pltr_xg );
3591  Py_DECREF( pltr_yg );
3592  }
3593 
3594 SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3595  PyObject *resultobj = 0;
3596  PLFLT arg1 ;
3597  PLFLT arg2 ;
3598  PLFLT *arg3 = (PLFLT *) 0 ;
3599  PLFLT *arg4 = (PLFLT *) 0 ;
3600  PLcGrid *arg5 = (PLcGrid *) 0 ;
3601  double val1 ;
3602  int ecode1 = 0 ;
3603  double val2 ;
3604  int ecode2 = 0 ;
3605  PLFLT temp3 ;
3606  int res3 = SWIG_TMPOBJ ;
3607  PLFLT temp4 ;
3608  int res4 = SWIG_TMPOBJ ;
3609  PyObject * obj0 = 0 ;
3610  PyObject * obj1 = 0 ;
3611  PyObject * obj2 = 0 ;
3612 
3613  arg3 = &temp3;
3614  arg4 = &temp4;
3615  if (!PyArg_ParseTuple(args,(char *)"OOO:pltr1",&obj0,&obj1,&obj2)) SWIG_fail;
3616  ecode1 = SWIG_AsVal_double(obj0, &val1);
3617  if (!SWIG_IsOK(ecode1)) {
3618  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3619  }
3620  arg1 = (PLFLT)(val1);
3621  ecode2 = SWIG_AsVal_double(obj1, &val2);
3622  if (!SWIG_IsOK(ecode2)) {
3623  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3624  }
3625  arg2 = (PLFLT)(val2);
3626  {
3627  arg5 = marshal_PLcGrid1( obj2, 0 );
3628  if ( !arg5 )
3629  return NULL;
3630  }
3631  pltr1(arg1,arg2,arg3,arg4,arg5);
3632  resultobj = SWIG_Py_Void();
3633  if (SWIG_IsTmpObj(res3)) {
3634  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3635  } else {
3636  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3637  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3638  }
3639  if (SWIG_IsTmpObj(res4)) {
3640  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3641  } else {
3642  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3643  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3644  }
3645  {
3646  cleanup_PLcGrid1();
3647  }
3648  return resultobj;
3649 fail:
3650  {
3651  cleanup_PLcGrid1();
3652  }
3653  return NULL;
3654 }
3655 
3656 
3657 SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3658  PyObject *resultobj = 0;
3659  PLFLT arg1 ;
3660  PLFLT arg2 ;
3661  PLFLT *arg3 = (PLFLT *) 0 ;
3662  PLFLT *arg4 = (PLFLT *) 0 ;
3663  PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3664  double val1 ;
3665  int ecode1 = 0 ;
3666  double val2 ;
3667  int ecode2 = 0 ;
3668  PLFLT temp3 ;
3669  int res3 = SWIG_TMPOBJ ;
3670  PLFLT temp4 ;
3671  int res4 = SWIG_TMPOBJ ;
3672  PyObject * obj0 = 0 ;
3673  PyObject * obj1 = 0 ;
3674  PyObject * obj2 = 0 ;
3675 
3676  arg3 = &temp3;
3677  arg4 = &temp4;
3678  if (!PyArg_ParseTuple(args,(char *)"OOO:pltr2",&obj0,&obj1,&obj2)) SWIG_fail;
3679  ecode1 = SWIG_AsVal_double(obj0, &val1);
3680  if (!SWIG_IsOK(ecode1)) {
3681  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3682  }
3683  arg1 = (PLFLT)(val1);
3684  ecode2 = SWIG_AsVal_double(obj1, &val2);
3685  if (!SWIG_IsOK(ecode2)) {
3686  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3687  }
3688  arg2 = (PLFLT)(val2);
3689  {
3690  arg5 = marshal_PLcGrid2( obj2, 0 );
3691  if ( !arg5 )
3692  return NULL;
3693  }
3694  pltr2(arg1,arg2,arg3,arg4,arg5);
3695  resultobj = SWIG_Py_Void();
3696  if (SWIG_IsTmpObj(res3)) {
3697  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3698  } else {
3699  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3700  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3701  }
3702  if (SWIG_IsTmpObj(res4)) {
3703  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3704  } else {
3705  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3706  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3707  }
3708  {
3709  cleanup_PLcGrid2();
3710  }
3711  return resultobj;
3712 fail:
3713  {
3714  cleanup_PLcGrid2();
3715  }
3716  return NULL;
3717 }
3718 
3719 
3720 
3721  // helper code for handling the callback
3722 #if 0
3723  static PyInterpreterState *save_interp = NULL;
3724 #endif
3726  PyObject* python_pltr = NULL;
3727  PyObject* python_f2eval = NULL;
3728  PyObject* python_ct = NULL;
3729  PyObject* python_mapform = NULL;
3730  PyObject* python_label = NULL;
3731 
3732 #if 0
3733 #define MY_BLOCK_THREADS { \
3734  PyThreadState *prev_state, *new_state; \
3735  /* need to have started a thread at some stage */ \
3736  /* for the following to work */ \
3737  PyEval_AcquireLock(); \
3738  new_state = PyThreadState_New( save_interp ); \
3739  prev_state = PyThreadState_Swap( new_state );
3740 #define MY_UNBLOCK_THREADS \
3741  new_state = PyThreadState_Swap( prev_state ); \
3742  PyThreadState_Clear( new_state ); \
3743  PyEval_ReleaseLock(); \
3744  PyThreadState_Delete( new_state ); \
3745  }
3746 #else
3747 #define MY_BLOCK_THREADS
3748 #define MY_UNBLOCK_THREADS
3749 #endif
3750 
3751 // This is the callback that gets handed to the C code. It, in turn, calls the Python callback
3752 
3753  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
3754  {
3755  PyObject *pdata, *arglist, *result;
3756  PyArrayObject *tmp;
3757 
3758  // the data argument is acutally a pointer to a python object
3759  pdata = (PyObject *) data;
3760  if ( data == NULL )
3761  {
3762  pdata = Py_None;
3763  }
3764  if ( python_pltr ) // if not something is terribly wrong
3765  { // hold a reference to the data object
3766  Py_XINCREF( pdata );
3767  // grab the Global Interpreter Lock to be sure threads don't mess us up
3769  // build the argument list
3770 #ifdef PL_DOUBLE
3771  arglist = Py_BuildValue( "(ddO)", x, y, pdata );
3772 #else
3773  arglist = Py_BuildValue( "(ffO)", x, y, pdata );
3774 #endif
3775  if ( arglist == NULL )
3776  {
3777  fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
3778  *tx = *ty = 0;
3779  return;
3780  }
3781  // call the python function
3782  result = PyEval_CallObject( python_pltr, arglist );
3783  // release the argument list
3784  Py_XDECREF( arglist );
3785  // check and unpack the result
3786  if ( result == NULL )
3787  {
3788  fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
3789  PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 argments." );
3790  *tx = *ty = 0;
3791  }
3792  else
3793  {
3794  tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
3795  if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3796  {
3797  fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
3798  PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
3799  *tx = *ty = 0;
3800  }
3801  else
3802  {
3803  PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3804  *tx = t[0];
3805  *ty = t[1];
3806  Py_XDECREF( tmp );
3807  }
3808  }
3809  // release the result
3810  Py_XDECREF( result );
3811  // release the global interpreter lock
3813  }
3814  }
3815 
3816  PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data )
3817  {
3818  PyObject *pdata, *arglist, *result;
3819  PLFLT fresult = 0.0;
3820 
3821  // the data argument is acutally a pointer to a python object
3822  pdata = (PyObject *) data;
3823  if ( python_f2eval ) // if not something is terribly wrong
3824  { // hold a reference to the data object
3825  Py_XINCREF( pdata );
3826  // grab the Global Interpreter Lock to be sure threads don't mess us up
3828  // build the argument list
3829  arglist = Py_BuildValue( "(iiO)", x, y, pdata );
3830  // call the python function
3831  result = PyEval_CallObject( python_f2eval, arglist );
3832  // release the argument list
3833  Py_DECREF( arglist );
3834  // check and unpack the result
3835  if ( !PyFloat_Check( result ) )
3836  {
3837  fprintf( stderr, "f2eval callback must return a float\n" );
3838  PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
3839  }
3840  else
3841  {
3842  // should I test the type here?
3843  fresult = (PLFLT) PyFloat_AsDouble( result );
3844  }
3845  // release the result
3846  Py_XDECREF( result );
3847  // release the global interpreter lock
3849  }
3850  return fresult;
3851  }
3852 
3853  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
3854  {
3855  PyObject *pdata, *arglist, *result;
3856  char *pystring;
3857  PLFLT fresult = 0.0;
3858 
3859  // the data argument is acutally a pointer to a python object
3860  if ( data )
3861  pdata = (PyObject *) data;
3862  else
3863  pdata = Py_None;
3864  if ( python_label ) // if not something is terribly wrong
3865  { // hold a reference to the data object
3866  Py_XINCREF( pdata );
3867  // grab the Global Interpreter Lock to be sure threads don't mess us up
3869  // build the argument list
3870 #ifdef PL_DOUBLE
3871  arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
3872 #else
3873  arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
3874 #endif
3875  // call the python function
3876  result = PyEval_CallObject( python_label, arglist );
3877  // release the argument list
3878  //Py_DECREF(arglist);
3879  // check and unpack the result
3880  if ( result == NULL )
3881  {
3882  fprintf( stderr, "label callback failed with 3 arguments\n" );
3883  PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
3884  }
3885  else if ( !PyString_Check( result ) )
3886  {
3887  fprintf( stderr, "label callback must return a string\n" );
3888  PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
3889  }
3890  else
3891  {
3892  // should I test the type here?
3893  pystring = PyString_AsString( result );
3894  strncpy( string, pystring, len );
3895  }
3896  // release the result
3897  Py_XDECREF( result );
3898  // release the global interpreter lock
3900  }
3901  }
3902 
3903  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
3904  {
3905  PyObject *px, *py, *pdata, *arglist, *result;
3906  npy_intp n;
3907  n = 1;
3908 
3909  // the data argument is acutally a pointer to a python object
3910  pdata = (PyObject *) data;
3911  if ( data == NULL )
3912  {
3913  pdata = Py_None;
3914  }
3915  if ( python_ct ) // if not something is terribly wrong
3916  { // hold a reference to the data object
3917  Py_XINCREF( pdata );
3918  // grab the Global Interpreter Lock to be sure threads don't mess us up
3920  // build the argument list
3921  px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
3922  py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
3923  arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
3924  // call the python function
3925  result = PyEval_CallObject( python_ct, arglist );
3926  // release the argument list
3927  Py_DECREF( arglist );
3928  Py_DECREF( px );
3929  Py_DECREF( py );
3930  Py_DECREF( pdata );
3931  // check and unpack the result
3932  if ( result == NULL )
3933  {
3934  fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
3935  PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
3936  }
3937  // release the result
3938  Py_XDECREF( result );
3939  // release the global interpreter lock
3941  }
3942  }
3943 
3944  void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y )
3945  {
3946  PyObject *px, *py, *arglist, *result;
3947  // PyArrayObject *tmpx, *tmpy;
3948 // PLFLT *xx, *yy;
3949 // PLINT i;
3950  npy_intp nn;
3951  nn = n;
3952 
3953  if ( python_mapform ) // if not something is terribly wrong
3954  { // grab the Global Interpreter Lock to be sure threads don't mess us up
3956  // build the argument list
3957 #ifdef PL_HAVE_PTHREAD
3958  px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
3959  py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
3960 #else
3961  px = PyArray_FromDimsAndData( 1, &n, PyArray_FLOAT, (char *) x );
3962  py = PyArray_FromDimsAndData( 1, &n, PyArray_FLOAT, (char *) y );
3963 #endif
3964  arglist = Py_BuildValue( "(iOO)", n, px, py );
3965  // call the python function
3966  result = PyEval_CallObject( python_mapform, arglist );
3967  // release the argument list
3968  Py_DECREF( arglist );
3969  Py_DECREF( px );
3970  Py_DECREF( py );
3971  // check and unpack the result
3972  if ( result == NULL )
3973  {
3974  fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
3975  PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
3976  }
3977  // release the result
3978  Py_XDECREF( result );
3979  // release the global interpreter lock
3981  }
3982  }
3983 
3984 // marshal the pltr function pointer argument
3985  pltr_func marshal_pltr( PyObject* input )
3986  {
3987  pltr_func result = do_pltr_callback;
3988  PyObject * rep = PyObject_Repr( input );
3989  if ( rep )
3990  {
3991  char* str = PyString_AsString( rep );
3992  if ( strcmp( str, "<built-in function pltr0>" ) == 0 )
3993  {
3994  result = pltr0;
3995  pltr_type = CB_0;
3996  python_pltr = NULL;
3997  }
3998  else if ( strcmp( str, "<built-in function pltr1>" ) == 0 )
3999  {
4000  result = pltr1;
4001  pltr_type = CB_1;
4002  python_pltr = NULL;
4003  }
4004  else if ( strcmp( str, "<built-in function pltr2>" ) == 0 )
4005  {
4006  result = pltr2;
4007  pltr_type = CB_2;
4008  python_pltr = NULL;
4009  }
4010  else
4011  {
4012  python_pltr = input;
4013  pltr_type = CB_Python;
4014  Py_XINCREF( input );
4015  }
4016  Py_DECREF( rep );
4017  }
4018  else
4019  {
4020  python_pltr = input;
4021  pltr_type = CB_Python;
4022  Py_XINCREF( input );
4023  }
4024  return result;
4025  }
4026 
4027  void cleanup_pltr( void )
4028  {
4029  Py_XDECREF( python_pltr );
4030  python_pltr = 0;
4031  }
4032 
4033 // marshal the ct function pointer argument
4034  ct_func marshal_ct( PyObject* input )
4035  {
4036  ct_func result = do_ct_callback;
4037  python_ct = input;
4038  Py_XINCREF( input );
4039  return result;
4040  }
4041 
4042  void cleanup_ct( void )
4043  {
4044  Py_XDECREF( python_ct );
4045  python_ct = 0;
4046  }
4047 
4048 // marshal the mapform function pointer argument
4049  mapform_func marshal_mapform( PyObject* input )
4050  {
4052  python_mapform = input;
4053  Py_XINCREF( input );
4054  return result;
4055  }
4056 
4057  void cleanup_mapform( void )
4058  {
4059  Py_XDECREF( python_mapform );
4060  python_mapform = 0;
4061  }
4062 
4063  PLPointer marshal_PLPointer( PyObject* input, int isimg )
4064  {
4065  PLPointer result = NULL;
4066  switch ( pltr_type )
4067  {
4068  case CB_0:
4069  break;
4070  case CB_1:
4071  if ( input != Py_None )
4072  result = marshal_PLcGrid1( input, isimg );
4073  break;
4074  case CB_2:
4075  if ( input != Py_None )
4076  result = marshal_PLcGrid2( input, isimg );
4077  break;
4078  case CB_Python:
4079  Py_XINCREF( input );
4080  result = (PLPointer *) input;
4081  break;
4082  default:
4083  fprintf( stderr, "pltr_type is invalid\n" );
4084  }
4085  return result;
4086  }
4087 
4088  void cleanup_PLPointer( void )
4089  {
4090  switch ( pltr_type )
4091  {
4092  case CB_0:
4093  break;
4094  case CB_1:
4095  cleanup_PLcGrid1();
4096  break;
4097  case CB_2:
4098  cleanup_PLcGrid2();
4099  break;
4100  case CB_Python:
4101  Py_XDECREF( python_pltr );
4102  break;
4103  default:
4104  fprintf( stderr, "pltr_type is invalid\n" );
4105  }
4106  python_pltr = 0;
4107  pltr_type = CB_0;
4108  }
4109 
4110 
4111 
4112 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4113  PyObject *resultobj = 0;
4114  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4115  int arg2 ;
4116  void *argp1 = 0 ;
4117  int res1 = 0 ;
4118  int val2 ;
4119  int ecode2 = 0 ;
4120  PyObject * obj0 = 0 ;
4121  PyObject * obj1 = 0 ;
4122 
4123  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_type_set",&obj0,&obj1)) SWIG_fail;
4124  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4125  if (!SWIG_IsOK(res1)) {
4126  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4127  }
4128  arg1 = (PLGraphicsIn *)(argp1);
4129  ecode2 = SWIG_AsVal_int(obj1, &val2);
4130  if (!SWIG_IsOK(ecode2)) {
4131  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4132  }
4133  arg2 = (int)(val2);
4134  if (arg1) (arg1)->type = arg2;
4135  resultobj = SWIG_Py_Void();
4136  return resultobj;
4137 fail:
4138  return NULL;
4139 }
4140 
4141 
4142 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4143  PyObject *resultobj = 0;
4144  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4145  void *argp1 = 0 ;
4146  int res1 = 0 ;
4147  PyObject * obj0 = 0 ;
4148  int result;
4149 
4150  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_type_get",&obj0)) SWIG_fail;
4151  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4152  if (!SWIG_IsOK(res1)) {
4153  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4154  }
4155  arg1 = (PLGraphicsIn *)(argp1);
4156  result = (int) ((arg1)->type);
4157  resultobj = SWIG_From_int((int)(result));
4158  return resultobj;
4159 fail:
4160  return NULL;
4161 }
4162 
4163 
4164 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4165  PyObject *resultobj = 0;
4166  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4167  unsigned int arg2 ;
4168  void *argp1 = 0 ;
4169  int res1 = 0 ;
4170  unsigned int val2 ;
4171  int ecode2 = 0 ;
4172  PyObject * obj0 = 0 ;
4173  PyObject * obj1 = 0 ;
4174 
4175  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_state_set",&obj0,&obj1)) SWIG_fail;
4176  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4177  if (!SWIG_IsOK(res1)) {
4178  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4179  }
4180  arg1 = (PLGraphicsIn *)(argp1);
4181  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4182  if (!SWIG_IsOK(ecode2)) {
4183  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4184  }
4185  arg2 = (unsigned int)(val2);
4186  if (arg1) (arg1)->state = arg2;
4187  resultobj = SWIG_Py_Void();
4188  return resultobj;
4189 fail:
4190  return NULL;
4191 }
4192 
4193 
4194 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4195  PyObject *resultobj = 0;
4196  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4197  void *argp1 = 0 ;
4198  int res1 = 0 ;
4199  PyObject * obj0 = 0 ;
4200  unsigned int result;
4201 
4202  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_state_get",&obj0)) SWIG_fail;
4203  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4204  if (!SWIG_IsOK(res1)) {
4205  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4206  }
4207  arg1 = (PLGraphicsIn *)(argp1);
4208  result = (unsigned int) ((arg1)->state);
4209  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4210  return resultobj;
4211 fail:
4212  return NULL;
4213 }
4214 
4215 
4216 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4217  PyObject *resultobj = 0;
4218  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4219  unsigned int arg2 ;
4220  void *argp1 = 0 ;
4221  int res1 = 0 ;
4222  unsigned int val2 ;
4223  int ecode2 = 0 ;
4224  PyObject * obj0 = 0 ;
4225  PyObject * obj1 = 0 ;
4226 
4227  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_keysym_set",&obj0,&obj1)) SWIG_fail;
4228  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4229  if (!SWIG_IsOK(res1)) {
4230  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4231  }
4232  arg1 = (PLGraphicsIn *)(argp1);
4233  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4234  if (!SWIG_IsOK(ecode2)) {
4235  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4236  }
4237  arg2 = (unsigned int)(val2);
4238  if (arg1) (arg1)->keysym = arg2;
4239  resultobj = SWIG_Py_Void();
4240  return resultobj;
4241 fail:
4242  return NULL;
4243 }
4244 
4245 
4246 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4247  PyObject *resultobj = 0;
4248  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4249  void *argp1 = 0 ;
4250  int res1 = 0 ;
4251  PyObject * obj0 = 0 ;
4252  unsigned int result;
4253 
4254  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_keysym_get",&obj0)) SWIG_fail;
4255  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4256  if (!SWIG_IsOK(res1)) {
4257  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4258  }
4259  arg1 = (PLGraphicsIn *)(argp1);
4260  result = (unsigned int) ((arg1)->keysym);
4261  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4262  return resultobj;
4263 fail:
4264  return NULL;
4265 }
4266 
4267 
4268 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4269  PyObject *resultobj = 0;
4270  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4271  unsigned int arg2 ;
4272  void *argp1 = 0 ;
4273  int res1 = 0 ;
4274  unsigned int val2 ;
4275  int ecode2 = 0 ;
4276  PyObject * obj0 = 0 ;
4277  PyObject * obj1 = 0 ;
4278 
4279  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_button_set",&obj0,&obj1)) SWIG_fail;
4280  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4281  if (!SWIG_IsOK(res1)) {
4282  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4283  }
4284  arg1 = (PLGraphicsIn *)(argp1);
4285  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4286  if (!SWIG_IsOK(ecode2)) {
4287  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4288  }
4289  arg2 = (unsigned int)(val2);
4290  if (arg1) (arg1)->button = arg2;
4291  resultobj = SWIG_Py_Void();
4292  return resultobj;
4293 fail:
4294  return NULL;
4295 }
4296 
4297 
4298 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4299  PyObject *resultobj = 0;
4300  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4301  void *argp1 = 0 ;
4302  int res1 = 0 ;
4303  PyObject * obj0 = 0 ;
4304  unsigned int result;
4305 
4306  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_button_get",&obj0)) SWIG_fail;
4307  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4308  if (!SWIG_IsOK(res1)) {
4309  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4310  }
4311  arg1 = (PLGraphicsIn *)(argp1);
4312  result = (unsigned int) ((arg1)->button);
4313  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4314  return resultobj;
4315 fail:
4316  return NULL;
4317 }
4318 
4319 
4320 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4321  PyObject *resultobj = 0;
4322  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4323  PLINT arg2 ;
4324  void *argp1 = 0 ;
4325  int res1 = 0 ;
4326  int val2 ;
4327  int ecode2 = 0 ;
4328  PyObject * obj0 = 0 ;
4329  PyObject * obj1 = 0 ;
4330 
4331  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1)) SWIG_fail;
4332  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4333  if (!SWIG_IsOK(res1)) {
4334  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4335  }
4336  arg1 = (PLGraphicsIn *)(argp1);
4337  ecode2 = SWIG_AsVal_int(obj1, &val2);
4338  if (!SWIG_IsOK(ecode2)) {
4339  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4340  }
4341  arg2 = (PLINT)(val2);
4342  if (arg1) (arg1)->subwindow = arg2;
4343  resultobj = SWIG_Py_Void();
4344  return resultobj;
4345 fail:
4346  return NULL;
4347 }
4348 
4349 
4350 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4351  PyObject *resultobj = 0;
4352  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4353  void *argp1 = 0 ;
4354  int res1 = 0 ;
4355  PyObject * obj0 = 0 ;
4356  PLINT result;
4357 
4358  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_subwindow_get",&obj0)) SWIG_fail;
4359  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4360  if (!SWIG_IsOK(res1)) {
4361  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4362  }
4363  arg1 = (PLGraphicsIn *)(argp1);
4364  result = (PLINT) ((arg1)->subwindow);
4365  resultobj = SWIG_From_int((int)(result));
4366  return resultobj;
4367 fail:
4368  return NULL;
4369 }
4370 
4371 
4372 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4373  PyObject *resultobj = 0;
4374  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4375  char *arg2 ;
4376  void *argp1 = 0 ;
4377  int res1 = 0 ;
4378  char temp2[16] ;
4379  int res2 ;
4380  PyObject * obj0 = 0 ;
4381  PyObject * obj1 = 0 ;
4382 
4383  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_string_set",&obj0,&obj1)) SWIG_fail;
4384  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4385  if (!SWIG_IsOK(res1)) {
4386  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4387  }
4388  arg1 = (PLGraphicsIn *)(argp1);
4389  res2 = SWIG_AsCharArray(obj1, temp2, 16);
4390  if (!SWIG_IsOK(res2)) {
4391  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4392  }
4393  arg2 = (char *)(temp2);
4394  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4395  else memset(arg1->string,0,16*sizeof(char));
4396  resultobj = SWIG_Py_Void();
4397  return resultobj;
4398 fail:
4399  return NULL;
4400 }
4401 
4402 
4403 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4404  PyObject *resultobj = 0;
4405  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4406  void *argp1 = 0 ;
4407  int res1 = 0 ;
4408  PyObject * obj0 = 0 ;
4409  char *result = 0 ;
4410 
4411  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_string_get",&obj0)) SWIG_fail;
4412  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4413  if (!SWIG_IsOK(res1)) {
4414  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4415  }
4416  arg1 = (PLGraphicsIn *)(argp1);
4417  result = (char *)(char *) ((arg1)->string);
4418  {
4419  size_t size = 16;
4420 
4421  while (size && (result[size - 1] == '\0')) --size;
4422 
4423  resultobj = SWIG_FromCharPtrAndSize(result, size);
4424  }
4425  return resultobj;
4426 fail:
4427  return NULL;
4428 }
4429 
4430 
4431 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4432  PyObject *resultobj = 0;
4433  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4434  int arg2 ;
4435  void *argp1 = 0 ;
4436  int res1 = 0 ;
4437  int val2 ;
4438  int ecode2 = 0 ;
4439  PyObject * obj0 = 0 ;
4440  PyObject * obj1 = 0 ;
4441 
4442  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pX_set",&obj0,&obj1)) SWIG_fail;
4443  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4444  if (!SWIG_IsOK(res1)) {
4445  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4446  }
4447  arg1 = (PLGraphicsIn *)(argp1);
4448  ecode2 = SWIG_AsVal_int(obj1, &val2);
4449  if (!SWIG_IsOK(ecode2)) {
4450  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4451  }
4452  arg2 = (int)(val2);
4453  if (arg1) (arg1)->pX = arg2;
4454  resultobj = SWIG_Py_Void();
4455  return resultobj;
4456 fail:
4457  return NULL;
4458 }
4459 
4460 
4461 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4462  PyObject *resultobj = 0;
4463  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4464  void *argp1 = 0 ;
4465  int res1 = 0 ;
4466  PyObject * obj0 = 0 ;
4467  int result;
4468 
4469  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pX_get",&obj0)) SWIG_fail;
4470  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4471  if (!SWIG_IsOK(res1)) {
4472  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4473  }
4474  arg1 = (PLGraphicsIn *)(argp1);
4475  result = (int) ((arg1)->pX);
4476  resultobj = SWIG_From_int((int)(result));
4477  return resultobj;
4478 fail:
4479  return NULL;
4480 }
4481 
4482 
4483 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4484  PyObject *resultobj = 0;
4485  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4486  int arg2 ;
4487  void *argp1 = 0 ;
4488  int res1 = 0 ;
4489  int val2 ;
4490  int ecode2 = 0 ;
4491  PyObject * obj0 = 0 ;
4492  PyObject * obj1 = 0 ;
4493 
4494  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pY_set",&obj0,&obj1)) SWIG_fail;
4495  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4496  if (!SWIG_IsOK(res1)) {
4497  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4498  }
4499  arg1 = (PLGraphicsIn *)(argp1);
4500  ecode2 = SWIG_AsVal_int(obj1, &val2);
4501  if (!SWIG_IsOK(ecode2)) {
4502  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4503  }
4504  arg2 = (int)(val2);
4505  if (arg1) (arg1)->pY = arg2;
4506  resultobj = SWIG_Py_Void();
4507  return resultobj;
4508 fail:
4509  return NULL;
4510 }
4511 
4512 
4513 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4514  PyObject *resultobj = 0;
4515  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4516  void *argp1 = 0 ;
4517  int res1 = 0 ;
4518  PyObject * obj0 = 0 ;
4519  int result;
4520 
4521  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pY_get",&obj0)) SWIG_fail;
4522  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4523  if (!SWIG_IsOK(res1)) {
4524  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4525  }
4526  arg1 = (PLGraphicsIn *)(argp1);
4527  result = (int) ((arg1)->pY);
4528  resultobj = SWIG_From_int((int)(result));
4529  return resultobj;
4530 fail:
4531  return NULL;
4532 }
4533 
4534 
4535 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4536  PyObject *resultobj = 0;
4537  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4538  PLFLT arg2 ;
4539  void *argp1 = 0 ;
4540  int res1 = 0 ;
4541  double val2 ;
4542  int ecode2 = 0 ;
4543  PyObject * obj0 = 0 ;
4544  PyObject * obj1 = 0 ;
4545 
4546  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dX_set",&obj0,&obj1)) SWIG_fail;
4547  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4548  if (!SWIG_IsOK(res1)) {
4549  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4550  }
4551  arg1 = (PLGraphicsIn *)(argp1);
4552  ecode2 = SWIG_AsVal_double(obj1, &val2);
4553  if (!SWIG_IsOK(ecode2)) {
4554  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4555  }
4556  arg2 = (PLFLT)(val2);
4557  if (arg1) (arg1)->dX = arg2;
4558  resultobj = SWIG_Py_Void();
4559  return resultobj;
4560 fail:
4561  return NULL;
4562 }
4563 
4564 
4565 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4566  PyObject *resultobj = 0;
4567  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4568  void *argp1 = 0 ;
4569  int res1 = 0 ;
4570  PyObject * obj0 = 0 ;
4571  PLFLT result;
4572 
4573  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dX_get",&obj0)) SWIG_fail;
4574  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4575  if (!SWIG_IsOK(res1)) {
4576  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4577  }
4578  arg1 = (PLGraphicsIn *)(argp1);
4579  result = (PLFLT) ((arg1)->dX);
4580  resultobj = SWIG_From_double((double)(result));
4581  return resultobj;
4582 fail:
4583  return NULL;
4584 }
4585 
4586 
4587 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4588  PyObject *resultobj = 0;
4589  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4590  PLFLT arg2 ;
4591  void *argp1 = 0 ;
4592  int res1 = 0 ;
4593  double val2 ;
4594  int ecode2 = 0 ;
4595  PyObject * obj0 = 0 ;
4596  PyObject * obj1 = 0 ;
4597 
4598  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dY_set",&obj0,&obj1)) SWIG_fail;
4599  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4600  if (!SWIG_IsOK(res1)) {
4601  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4602  }
4603  arg1 = (PLGraphicsIn *)(argp1);
4604  ecode2 = SWIG_AsVal_double(obj1, &val2);
4605  if (!SWIG_IsOK(ecode2)) {
4606  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4607  }
4608  arg2 = (PLFLT)(val2);
4609  if (arg1) (arg1)->dY = arg2;
4610  resultobj = SWIG_Py_Void();
4611  return resultobj;
4612 fail:
4613  return NULL;
4614 }
4615 
4616 
4617 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4618  PyObject *resultobj = 0;
4619  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4620  void *argp1 = 0 ;
4621  int res1 = 0 ;
4622  PyObject * obj0 = 0 ;
4623  PLFLT result;
4624 
4625  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dY_get",&obj0)) SWIG_fail;
4626  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4627  if (!SWIG_IsOK(res1)) {
4628  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4629  }
4630  arg1 = (PLGraphicsIn *)(argp1);
4631  result = (PLFLT) ((arg1)->dY);
4632  resultobj = SWIG_From_double((double)(result));
4633  return resultobj;
4634 fail:
4635  return NULL;
4636 }
4637 
4638 
4639 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4640  PyObject *resultobj = 0;
4641  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4642  PLFLT arg2 ;
4643  void *argp1 = 0 ;
4644  int res1 = 0 ;
4645  double val2 ;
4646  int ecode2 = 0 ;
4647  PyObject * obj0 = 0 ;
4648  PyObject * obj1 = 0 ;
4649 
4650  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wX_set",&obj0,&obj1)) SWIG_fail;
4651  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4652  if (!SWIG_IsOK(res1)) {
4653  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4654  }
4655  arg1 = (PLGraphicsIn *)(argp1);
4656  ecode2 = SWIG_AsVal_double(obj1, &val2);
4657  if (!SWIG_IsOK(ecode2)) {
4658  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4659  }
4660  arg2 = (PLFLT)(val2);
4661  if (arg1) (arg1)->wX = arg2;
4662  resultobj = SWIG_Py_Void();
4663  return resultobj;
4664 fail:
4665  return NULL;
4666 }
4667 
4668 
4669 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4670  PyObject *resultobj = 0;
4671  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4672  void *argp1 = 0 ;
4673  int res1 = 0 ;
4674  PyObject * obj0 = 0 ;
4675  PLFLT result;
4676 
4677  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wX_get",&obj0)) SWIG_fail;
4678  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4679  if (!SWIG_IsOK(res1)) {
4680  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4681  }
4682  arg1 = (PLGraphicsIn *)(argp1);
4683  result = (PLFLT) ((arg1)->wX);
4684  resultobj = SWIG_From_double((double)(result));
4685  return resultobj;
4686 fail:
4687  return NULL;
4688 }
4689 
4690 
4691 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4692  PyObject *resultobj = 0;
4693  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4694  PLFLT arg2 ;
4695  void *argp1 = 0 ;
4696  int res1 = 0 ;
4697  double val2 ;
4698  int ecode2 = 0 ;
4699  PyObject * obj0 = 0 ;
4700  PyObject * obj1 = 0 ;
4701 
4702  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wY_set",&obj0,&obj1)) SWIG_fail;
4703  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4704  if (!SWIG_IsOK(res1)) {
4705  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4706  }
4707  arg1 = (PLGraphicsIn *)(argp1);
4708  ecode2 = SWIG_AsVal_double(obj1, &val2);
4709  if (!SWIG_IsOK(ecode2)) {
4710  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
4711  }
4712  arg2 = (PLFLT)(val2);
4713  if (arg1) (arg1)->wY = arg2;
4714  resultobj = SWIG_Py_Void();
4715  return resultobj;
4716 fail:
4717  return NULL;
4718 }
4719 
4720 
4721 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4722  PyObject *resultobj = 0;
4723  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4724  void *argp1 = 0 ;
4725  int res1 = 0 ;
4726  PyObject * obj0 = 0 ;
4727  PLFLT result;
4728 
4729  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wY_get",&obj0)) SWIG_fail;
4730  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4731  if (!SWIG_IsOK(res1)) {
4732  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4733  }
4734  arg1 = (PLGraphicsIn *)(argp1);
4735  result = (PLFLT) ((arg1)->wY);
4736  resultobj = SWIG_From_double((double)(result));
4737  return resultobj;
4738 fail:
4739  return NULL;
4740 }
4741 
4742 
4743 SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4744  PyObject *resultobj = 0;
4745  PLGraphicsIn *result = 0 ;
4746 
4747  if (!PyArg_ParseTuple(args,(char *)":new_PLGraphicsIn")) SWIG_fail;
4748  result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
4750  return resultobj;
4751 fail:
4752  return NULL;
4753 }
4754 
4755 
4756 SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4757  PyObject *resultobj = 0;
4758  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4759  void *argp1 = 0 ;
4760  int res1 = 0 ;
4761  PyObject * obj0 = 0 ;
4762 
4763  if (!PyArg_ParseTuple(args,(char *)"O:delete_PLGraphicsIn",&obj0)) SWIG_fail;
4764  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
4765  if (!SWIG_IsOK(res1)) {
4766  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4767  }
4768  arg1 = (PLGraphicsIn *)(argp1);
4769  free((char *) arg1);
4770  resultobj = SWIG_Py_Void();
4771  return resultobj;
4772 fail:
4773  return NULL;
4774 }
4775 
4776 
4777 SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4778  PyObject *obj;
4779  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4781  return SWIG_Py_Void();
4782 }
4783 
4784 SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4785  PyObject *resultobj = 0;
4786  PLINT arg1 ;
4787  int val1 ;
4788  int ecode1 = 0 ;
4789  PyObject * obj0 = 0 ;
4790 
4791  if (!PyArg_ParseTuple(args,(char *)"O:plsxwin",&obj0)) SWIG_fail;
4792  ecode1 = SWIG_AsVal_int(obj0, &val1);
4793  if (!SWIG_IsOK(ecode1)) {
4794  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
4795  }
4796  arg1 = (PLINT)(val1);
4797  plsxwin(arg1);
4798  resultobj = SWIG_Py_Void();
4799  return resultobj;
4800 fail:
4801  return NULL;
4802 }
4803 
4804 
4805 SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4806  PyObject *resultobj = 0;
4807  PLINT arg1 ;
4808  PLINT arg2 ;
4809  int val1 ;
4810  int ecode1 = 0 ;
4811  int val2 ;
4812  int ecode2 = 0 ;
4813  PyObject * obj0 = 0 ;
4814  PyObject * obj1 = 0 ;
4815 
4816  if (!PyArg_ParseTuple(args,(char *)"OO:pl_setcontlabelformat",&obj0,&obj1)) SWIG_fail;
4817  ecode1 = SWIG_AsVal_int(obj0, &val1);
4818  if (!SWIG_IsOK(ecode1)) {
4819  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
4820  }
4821  arg1 = (PLINT)(val1);
4822  ecode2 = SWIG_AsVal_int(obj1, &val2);
4823  if (!SWIG_IsOK(ecode2)) {
4824  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
4825  }
4826  arg2 = (PLINT)(val2);
4827  pl_setcontlabelformat(arg1,arg2);
4828  resultobj = SWIG_Py_Void();
4829  return resultobj;
4830 fail:
4831  return NULL;
4832 }
4833 
4834 
4835 SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4836  PyObject *resultobj = 0;
4837  PLFLT arg1 ;
4838  PLFLT arg2 ;
4839  PLFLT arg3 ;
4840  PLINT arg4 ;
4841  double val1 ;
4842  int ecode1 = 0 ;
4843  double val2 ;
4844  int ecode2 = 0 ;
4845  double val3 ;
4846  int ecode3 = 0 ;
4847  int val4 ;
4848  int ecode4 = 0 ;
4849  PyObject * obj0 = 0 ;
4850  PyObject * obj1 = 0 ;
4851  PyObject * obj2 = 0 ;
4852  PyObject * obj3 = 0 ;
4853 
4854  if (!PyArg_ParseTuple(args,(char *)"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4855  ecode1 = SWIG_AsVal_double(obj0, &val1);
4856  if (!SWIG_IsOK(ecode1)) {
4857  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
4858  }
4859  arg1 = (PLFLT)(val1);
4860  ecode2 = SWIG_AsVal_double(obj1, &val2);
4861  if (!SWIG_IsOK(ecode2)) {
4862  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
4863  }
4864  arg2 = (PLFLT)(val2);
4865  ecode3 = SWIG_AsVal_double(obj2, &val3);
4866  if (!SWIG_IsOK(ecode3)) {
4867  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
4868  }
4869  arg3 = (PLFLT)(val3);
4870  ecode4 = SWIG_AsVal_int(obj3, &val4);
4871  if (!SWIG_IsOK(ecode4)) {
4872  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
4873  }
4874  arg4 = (PLINT)(val4);
4875  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
4876  resultobj = SWIG_Py_Void();
4877  return resultobj;
4878 fail:
4879  return NULL;
4880 }
4881 
4882 
4883 SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4884  PyObject *resultobj = 0;
4885  PLINT arg1 ;
4886  int val1 ;
4887  int ecode1 = 0 ;
4888  PyObject * obj0 = 0 ;
4889 
4890  if (!PyArg_ParseTuple(args,(char *)"O:pladv",&obj0)) SWIG_fail;
4891  ecode1 = SWIG_AsVal_int(obj0, &val1);
4892  if (!SWIG_IsOK(ecode1)) {
4893  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
4894  }
4895  arg1 = (PLINT)(val1);
4896  pladv(arg1);
4897  resultobj = SWIG_Py_Void();
4898  return resultobj;
4899 fail:
4900  return NULL;
4901 }
4902 
4903 
4904 SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4905  PyObject *resultobj = 0;
4906  PLFLT arg1 ;
4907  PLFLT arg2 ;
4908  PLFLT arg3 ;
4909  PLFLT arg4 ;
4910  PLFLT arg5 ;
4911  PLFLT arg6 ;
4912  PLFLT arg7 ;
4913  PLBOOL arg8 ;
4914  double val1 ;
4915  int ecode1 = 0 ;
4916  double val2 ;
4917  int ecode2 = 0 ;
4918  double val3 ;
4919  int ecode3 = 0 ;
4920  double val4 ;
4921  int ecode4 = 0 ;
4922  double val5 ;
4923  int ecode5 = 0 ;
4924  double val6 ;
4925  int ecode6 = 0 ;
4926  double val7 ;
4927  int ecode7 = 0 ;
4928  int val8 ;
4929  int ecode8 = 0 ;
4930  PyObject * obj0 = 0 ;
4931  PyObject * obj1 = 0 ;
4932  PyObject * obj2 = 0 ;
4933  PyObject * obj3 = 0 ;
4934  PyObject * obj4 = 0 ;
4935  PyObject * obj5 = 0 ;
4936  PyObject * obj6 = 0 ;
4937  PyObject * obj7 = 0 ;
4938 
4939  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
4940  ecode1 = SWIG_AsVal_double(obj0, &val1);
4941  if (!SWIG_IsOK(ecode1)) {
4942  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
4943  }
4944  arg1 = (PLFLT)(val1);
4945  ecode2 = SWIG_AsVal_double(obj1, &val2);
4946  if (!SWIG_IsOK(ecode2)) {
4947  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
4948  }
4949  arg2 = (PLFLT)(val2);
4950  ecode3 = SWIG_AsVal_double(obj2, &val3);
4951  if (!SWIG_IsOK(ecode3)) {
4952  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
4953  }
4954  arg3 = (PLFLT)(val3);
4955  ecode4 = SWIG_AsVal_double(obj3, &val4);
4956  if (!SWIG_IsOK(ecode4)) {
4957  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
4958  }
4959  arg4 = (PLFLT)(val4);
4960  ecode5 = SWIG_AsVal_double(obj4, &val5);
4961  if (!SWIG_IsOK(ecode5)) {
4962  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
4963  }
4964  arg5 = (PLFLT)(val5);
4965  ecode6 = SWIG_AsVal_double(obj5, &val6);
4966  if (!SWIG_IsOK(ecode6)) {
4967  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
4968  }
4969  arg6 = (PLFLT)(val6);
4970  ecode7 = SWIG_AsVal_double(obj6, &val7);
4971  if (!SWIG_IsOK(ecode7)) {
4972  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
4973  }
4974  arg7 = (PLFLT)(val7);
4975  ecode8 = SWIG_AsVal_int(obj7, &val8);
4976  if (!SWIG_IsOK(ecode8)) {
4977  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
4978  }
4979  arg8 = (PLBOOL)(val8);
4980  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4981  resultobj = SWIG_Py_Void();
4982  return resultobj;
4983 fail:
4984  return NULL;
4985 }
4986 
4987 
4988 SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4989  PyObject *resultobj = 0;
4990  PLFLT arg1 ;
4991  PLFLT arg2 ;
4992  char *arg3 = (char *) 0 ;
4993  PLFLT arg4 ;
4994  PLINT arg5 ;
4995  char *arg6 = (char *) 0 ;
4996  PLFLT arg7 ;
4997  PLINT arg8 ;
4998  double val1 ;
4999  int ecode1 = 0 ;
5000  double val2 ;
5001  int ecode2 = 0 ;
5002  int res3 ;
5003  char *buf3 = 0 ;
5004  int alloc3 = 0 ;
5005  double val4 ;
5006  int ecode4 = 0 ;
5007  int val5 ;
5008  int ecode5 = 0 ;
5009  int res6 ;
5010  char *buf6 = 0 ;
5011  int alloc6 = 0 ;
5012  double val7 ;
5013  int ecode7 = 0 ;
5014  int val8 ;
5015  int ecode8 = 0 ;
5016  PyObject * obj0 = 0 ;
5017  PyObject * obj1 = 0 ;
5018  PyObject * obj2 = 0 ;
5019  PyObject * obj3 = 0 ;
5020  PyObject * obj4 = 0 ;
5021  PyObject * obj5 = 0 ;
5022  PyObject * obj6 = 0 ;
5023  PyObject * obj7 = 0 ;
5024 
5025  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5026  ecode1 = SWIG_AsVal_double(obj0, &val1);
5027  if (!SWIG_IsOK(ecode1)) {
5028  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5029  }
5030  arg1 = (PLFLT)(val1);
5031  ecode2 = SWIG_AsVal_double(obj1, &val2);
5032  if (!SWIG_IsOK(ecode2)) {
5033  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5034  }
5035  arg2 = (PLFLT)(val2);
5036  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
5037  if (!SWIG_IsOK(res3)) {
5038  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5039  }
5040  arg3 = (char *)(buf3);
5041  ecode4 = SWIG_AsVal_double(obj3, &val4);
5042  if (!SWIG_IsOK(ecode4)) {
5043  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5044  }
5045  arg4 = (PLFLT)(val4);
5046  ecode5 = SWIG_AsVal_int(obj4, &val5);
5047  if (!SWIG_IsOK(ecode5)) {
5048  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5049  }
5050  arg5 = (PLINT)(val5);
5051  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5052  if (!SWIG_IsOK(res6)) {
5053  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5054  }
5055  arg6 = (char *)(buf6);
5056  ecode7 = SWIG_AsVal_double(obj6, &val7);
5057  if (!SWIG_IsOK(ecode7)) {
5058  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5059  }
5060  arg7 = (PLFLT)(val7);
5061  ecode8 = SWIG_AsVal_int(obj7, &val8);
5062  if (!SWIG_IsOK(ecode8)) {
5063  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5064  }
5065  arg8 = (PLINT)(val8);
5066  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5067  resultobj = SWIG_Py_Void();
5068  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5069  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5070  return resultobj;
5071 fail:
5072  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5073  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5074  return NULL;
5075 }
5076 
5077 
5078 SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5079  PyObject *resultobj = 0;
5080  PLINT arg1 ;
5081  PLFLT *arg2 = (PLFLT *) 0 ;
5082  PLFLT *arg3 = (PLFLT *) 0 ;
5083  PLINT arg4 ;
5084  PyArrayObject *tmp1 ;
5085  PyArrayObject *tmp3 ;
5086  int val4 ;
5087  int ecode4 = 0 ;
5088  PyObject * obj0 = 0 ;
5089  PyObject * obj1 = 0 ;
5090  PyObject * obj2 = 0 ;
5091 
5092  if (!PyArg_ParseTuple(args,(char *)"OOO:plbin",&obj0,&obj1,&obj2)) SWIG_fail;
5093  {
5094  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
5095  if ( tmp1 == NULL )
5096  return NULL;
5097  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5098  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5099  }
5100  {
5101  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
5102  if ( tmp3 == NULL )
5103  return NULL;
5104  if ( PyArray_DIMS( tmp3 )[0] != Alen )
5105  {
5106  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5107  return NULL;
5108  }
5109  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5110  }
5111  ecode4 = SWIG_AsVal_int(obj2, &val4);
5112  if (!SWIG_IsOK(ecode4)) {
5113  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5114  }
5115  arg4 = (PLINT)(val4);
5116  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5117  resultobj = SWIG_Py_Void();
5118  {
5119  Py_DECREF( tmp1 );
5120  }
5121  {
5122  Py_DECREF( tmp3 );
5123  }
5124  return resultobj;
5125 fail:
5126  {
5127  Py_DECREF( tmp1 );
5128  }
5129  {
5130  Py_DECREF( tmp3 );
5131  }
5132  return NULL;
5133 }
5134 
5135 
5136 SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5137  PyObject *resultobj = 0;
5138  PLINT *arg1 = (PLINT *) 0 ;
5139  PLINT *arg2 = (PLINT *) 0 ;
5140  PLINT *arg3 = (PLINT *) 0 ;
5141  PLINT *arg4 = (PLINT *) 0 ;
5142  PLINT *arg5 = (PLINT *) 0 ;
5143  PLFLT *arg6 = (PLFLT *) 0 ;
5144  PLFLT arg7 ;
5145  PLINT temp1 ;
5146  int res1 = SWIG_TMPOBJ ;
5147  PLINT temp2 ;
5148  int res2 = SWIG_TMPOBJ ;
5149  PLINT temp3 ;
5150  int res3 = SWIG_TMPOBJ ;
5151  PLINT temp4 ;
5152  int res4 = SWIG_TMPOBJ ;
5153  PLINT temp5 ;
5154  int res5 = SWIG_TMPOBJ ;
5155  PLFLT temp6 ;
5156  int res6 = SWIG_TMPOBJ ;
5157  double val7 ;
5158  int ecode7 = 0 ;
5159  PyObject * obj0 = 0 ;
5160 
5161  arg1 = &temp1;
5162  arg2 = &temp2;
5163  arg3 = &temp3;
5164  arg4 = &temp4;
5165  arg5 = &temp5;
5166  arg6 = &temp6;
5167  if (!PyArg_ParseTuple(args,(char *)"O:plbtime",&obj0)) SWIG_fail;
5168  ecode7 = SWIG_AsVal_double(obj0, &val7);
5169  if (!SWIG_IsOK(ecode7)) {
5170  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5171  }
5172  arg7 = (PLFLT)(val7);
5173  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5174  resultobj = SWIG_Py_Void();
5175  if (SWIG_IsTmpObj(res1)) {
5176  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5177  } else {
5178  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5179  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5180  }
5181  if (SWIG_IsTmpObj(res2)) {
5182  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5183  } else {
5184  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5185  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5186  }
5187  if (SWIG_IsTmpObj(res3)) {
5188  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
5189  } else {
5190  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5191  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
5192  }
5193  if (SWIG_IsTmpObj(res4)) {
5194  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
5195  } else {
5196  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5197  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
5198  }
5199  if (SWIG_IsTmpObj(res5)) {
5200  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5201  } else {
5202  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5203  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5204  }
5205  if (SWIG_IsTmpObj(res6)) {
5206  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
5207  } else {
5208  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5209  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
5210  }
5211  return resultobj;
5212 fail:
5213  return NULL;
5214 }
5215 
5216 
5217 SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5218  PyObject *resultobj = 0;
5219 
5220  if (!PyArg_ParseTuple(args,(char *)":plbop")) SWIG_fail;
5221  plbop();
5222  resultobj = SWIG_Py_Void();
5223  return resultobj;
5224 fail:
5225  return NULL;
5226 }
5227 
5228 
5229 SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5230  PyObject *resultobj = 0;
5231  char *arg1 = (char *) 0 ;
5232  PLFLT arg2 ;
5233  PLINT arg3 ;
5234  char *arg4 = (char *) 0 ;
5235  PLFLT arg5 ;
5236  PLINT arg6 ;
5237  int res1 ;
5238  char *buf1 = 0 ;
5239  int alloc1 = 0 ;
5240  double val2 ;
5241  int ecode2 = 0 ;
5242  int val3 ;
5243  int ecode3 = 0 ;
5244  int res4 ;
5245  char *buf4 = 0 ;
5246  int alloc4 = 0 ;
5247  double val5 ;
5248  int ecode5 = 0 ;
5249  int val6 ;
5250  int ecode6 = 0 ;
5251  PyObject * obj0 = 0 ;
5252  PyObject * obj1 = 0 ;
5253  PyObject * obj2 = 0 ;
5254  PyObject * obj3 = 0 ;
5255  PyObject * obj4 = 0 ;
5256  PyObject * obj5 = 0 ;
5257 
5258  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5259  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5260  if (!SWIG_IsOK(res1)) {
5261  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5262  }
5263  arg1 = (char *)(buf1);
5264  ecode2 = SWIG_AsVal_double(obj1, &val2);
5265  if (!SWIG_IsOK(ecode2)) {
5266  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5267  }
5268  arg2 = (PLFLT)(val2);
5269  ecode3 = SWIG_AsVal_int(obj2, &val3);
5270  if (!SWIG_IsOK(ecode3)) {
5271  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5272  }
5273  arg3 = (PLINT)(val3);
5274  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5275  if (!SWIG_IsOK(res4)) {
5276  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5277  }
5278  arg4 = (char *)(buf4);
5279  ecode5 = SWIG_AsVal_double(obj4, &val5);
5280  if (!SWIG_IsOK(ecode5)) {
5281  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5282  }
5283  arg5 = (PLFLT)(val5);
5284  ecode6 = SWIG_AsVal_int(obj5, &val6);
5285  if (!SWIG_IsOK(ecode6)) {
5286  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5287  }
5288  arg6 = (PLINT)(val6);
5289  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5290  resultobj = SWIG_Py_Void();
5291  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5292  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5293  return resultobj;
5294 fail:
5295  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5296  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5297  return NULL;
5298 }
5299 
5300 
5301 SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5302  PyObject *resultobj = 0;
5303  char *arg1 = (char *) 0 ;
5304  char *arg2 = (char *) 0 ;
5305  PLFLT arg3 ;
5306  PLINT arg4 ;
5307  char *arg5 = (char *) 0 ;
5308  char *arg6 = (char *) 0 ;
5309  PLFLT arg7 ;
5310  PLINT arg8 ;
5311  char *arg9 = (char *) 0 ;
5312  char *arg10 = (char *) 0 ;
5313  PLFLT arg11 ;
5314  PLINT arg12 ;
5315  int res1 ;
5316  char *buf1 = 0 ;
5317  int alloc1 = 0 ;
5318  int res2 ;
5319  char *buf2 = 0 ;
5320  int alloc2 = 0 ;
5321  double val3 ;
5322  int ecode3 = 0 ;
5323  int val4 ;
5324  int ecode4 = 0 ;
5325  int res5 ;
5326  char *buf5 = 0 ;
5327  int alloc5 = 0 ;
5328  int res6 ;
5329  char *buf6 = 0 ;
5330  int alloc6 = 0 ;
5331  double val7 ;
5332  int ecode7 = 0 ;
5333  int val8 ;
5334  int ecode8 = 0 ;
5335  int res9 ;
5336  char *buf9 = 0 ;
5337  int alloc9 = 0 ;
5338  int res10 ;
5339  char *buf10 = 0 ;
5340  int alloc10 = 0 ;
5341  double val11 ;
5342  int ecode11 = 0 ;
5343  int val12 ;
5344  int ecode12 = 0 ;
5345  PyObject * obj0 = 0 ;
5346  PyObject * obj1 = 0 ;
5347  PyObject * obj2 = 0 ;
5348  PyObject * obj3 = 0 ;
5349  PyObject * obj4 = 0 ;
5350  PyObject * obj5 = 0 ;
5351  PyObject * obj6 = 0 ;
5352  PyObject * obj7 = 0 ;
5353  PyObject * obj8 = 0 ;
5354  PyObject * obj9 = 0 ;
5355  PyObject * obj10 = 0 ;
5356  PyObject * obj11 = 0 ;
5357 
5358  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
5359  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5360  if (!SWIG_IsOK(res1)) {
5361  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5362  }
5363  arg1 = (char *)(buf1);
5364  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5365  if (!SWIG_IsOK(res2)) {
5366  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5367  }
5368  arg2 = (char *)(buf2);
5369  ecode3 = SWIG_AsVal_double(obj2, &val3);
5370  if (!SWIG_IsOK(ecode3)) {
5371  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5372  }
5373  arg3 = (PLFLT)(val3);
5374  ecode4 = SWIG_AsVal_int(obj3, &val4);
5375  if (!SWIG_IsOK(ecode4)) {
5376  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5377  }
5378  arg4 = (PLINT)(val4);
5379  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
5380  if (!SWIG_IsOK(res5)) {
5381  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5382  }
5383  arg5 = (char *)(buf5);
5384  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5385  if (!SWIG_IsOK(res6)) {
5386  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5387  }
5388  arg6 = (char *)(buf6);
5389  ecode7 = SWIG_AsVal_double(obj6, &val7);
5390  if (!SWIG_IsOK(ecode7)) {
5391  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5392  }
5393  arg7 = (PLFLT)(val7);
5394  ecode8 = SWIG_AsVal_int(obj7, &val8);
5395  if (!SWIG_IsOK(ecode8)) {
5396  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5397  }
5398  arg8 = (PLINT)(val8);
5399  res9 = SWIG_AsCharPtrAndSize(obj8, &buf9, NULL, &alloc9);
5400  if (!SWIG_IsOK(res9)) {
5401  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5402  }
5403  arg9 = (char *)(buf9);
5404  res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
5405  if (!SWIG_IsOK(res10)) {
5406  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5407  }
5408  arg10 = (char *)(buf10);
5409  ecode11 = SWIG_AsVal_double(obj10, &val11);
5410  if (!SWIG_IsOK(ecode11)) {
5411  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5412  }
5413  arg11 = (PLFLT)(val11);
5414  ecode12 = SWIG_AsVal_int(obj11, &val12);
5415  if (!SWIG_IsOK(ecode12)) {
5416  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5417  }
5418  arg12 = (PLINT)(val12);
5419  plbox3((char const *)arg1,(char const *)arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,arg7,arg8,(char const *)arg9,(char const *)arg10,arg11,arg12);
5420  resultobj = SWIG_Py_Void();
5421  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5422  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5423  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5424  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5425  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5426  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5427  return resultobj;
5428 fail:
5429  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5430  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5431  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5432  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5433  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5434  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5435  return NULL;
5436 }
5437 
5438 
5439 SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5440  PyObject *resultobj = 0;
5441  PLFLT arg1 ;
5442  PLFLT arg2 ;
5443  PLFLT *arg3 = (PLFLT *) 0 ;
5444  PLFLT *arg4 = (PLFLT *) 0 ;
5445  PLINT *arg5 = (PLINT *) 0 ;
5446  double val1 ;
5447  int ecode1 = 0 ;
5448  double val2 ;
5449  int ecode2 = 0 ;
5450  PLFLT temp3 ;
5451  int res3 = SWIG_TMPOBJ ;
5452  PLFLT temp4 ;
5453  int res4 = SWIG_TMPOBJ ;
5454  PLINT temp5 ;
5455  int res5 = SWIG_TMPOBJ ;
5456  PyObject * obj0 = 0 ;
5457  PyObject * obj1 = 0 ;
5458 
5459  arg3 = &temp3;
5460  arg4 = &temp4;
5461  arg5 = &temp5;
5462  if (!PyArg_ParseTuple(args,(char *)"OO:plcalc_world",&obj0,&obj1)) SWIG_fail;
5463  ecode1 = SWIG_AsVal_double(obj0, &val1);
5464  if (!SWIG_IsOK(ecode1)) {
5465  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5466  }
5467  arg1 = (PLFLT)(val1);
5468  ecode2 = SWIG_AsVal_double(obj1, &val2);
5469  if (!SWIG_IsOK(ecode2)) {
5470  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5471  }
5472  arg2 = (PLFLT)(val2);
5473  plcalc_world(arg1,arg2,arg3,arg4,arg5);
5474  resultobj = SWIG_Py_Void();
5475  if (SWIG_IsTmpObj(res3)) {
5476  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5477  } else {
5478  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5479  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5480  }
5481  if (SWIG_IsTmpObj(res4)) {
5482  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5483  } else {
5484  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5485  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5486  }
5487  if (SWIG_IsTmpObj(res5)) {
5488  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5489  } else {
5490  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5491  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5492  }
5493  return resultobj;
5494 fail:
5495  return NULL;
5496 }
5497 
5498 
5499 SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5500  PyObject *resultobj = 0;
5501 
5502  if (!PyArg_ParseTuple(args,(char *)":plclear")) SWIG_fail;
5503  plclear();
5504  resultobj = SWIG_Py_Void();
5505  return resultobj;
5506 fail:
5507  return NULL;
5508 }
5509 
5510 
5511 SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5512  PyObject *resultobj = 0;
5513  PLINT arg1 ;
5514  int val1 ;
5515  int ecode1 = 0 ;
5516  PyObject * obj0 = 0 ;
5517 
5518  if (!PyArg_ParseTuple(args,(char *)"O:plcol0",&obj0)) SWIG_fail;
5519  ecode1 = SWIG_AsVal_int(obj0, &val1);
5520  if (!SWIG_IsOK(ecode1)) {
5521  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5522  }
5523  arg1 = (PLINT)(val1);
5524  plcol0(arg1);
5525  resultobj = SWIG_Py_Void();
5526  return resultobj;
5527 fail:
5528  return NULL;
5529 }
5530 
5531 
5532 SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5533  PyObject *resultobj = 0;
5534  PLFLT arg1 ;
5535  double val1 ;
5536  int ecode1 = 0 ;
5537  PyObject * obj0 = 0 ;
5538 
5539  if (!PyArg_ParseTuple(args,(char *)"O:plcol1",&obj0)) SWIG_fail;
5540  ecode1 = SWIG_AsVal_double(obj0, &val1);
5541  if (!SWIG_IsOK(ecode1)) {
5542  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5543  }
5544  arg1 = (PLFLT)(val1);
5545  plcol1(arg1);
5546  resultobj = SWIG_Py_Void();
5547  return resultobj;
5548 fail:
5549  return NULL;
5550 }
5551 
5552 
5553 SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5554  PyObject *resultobj = 0;
5555  PLFLT arg1 ;
5556  PLFLT arg2 ;
5557  PLFLT arg3 ;
5558  PLINT arg4 ;
5559  PLBOOL arg5 ;
5560  PLINT arg6 ;
5561  PLINT arg7 ;
5562  PLINT arg8 ;
5563  PLINT arg9 ;
5564  PLINT arg10 ;
5565  PLFLT arg11 ;
5566  double val1 ;
5567  int ecode1 = 0 ;
5568  double val2 ;
5569  int ecode2 = 0 ;
5570  double val3 ;
5571  int ecode3 = 0 ;
5572  int val4 ;
5573  int ecode4 = 0 ;
5574  int val5 ;
5575  int ecode5 = 0 ;
5576  int val6 ;
5577  int ecode6 = 0 ;
5578  int val7 ;
5579  int ecode7 = 0 ;
5580  int val8 ;
5581  int ecode8 = 0 ;
5582  int val9 ;
5583  int ecode9 = 0 ;
5584  int val10 ;
5585  int ecode10 = 0 ;
5586  double val11 ;
5587  int ecode11 = 0 ;
5588  PyObject * obj0 = 0 ;
5589  PyObject * obj1 = 0 ;
5590  PyObject * obj2 = 0 ;
5591  PyObject * obj3 = 0 ;
5592  PyObject * obj4 = 0 ;
5593  PyObject * obj5 = 0 ;
5594  PyObject * obj6 = 0 ;
5595  PyObject * obj7 = 0 ;
5596  PyObject * obj8 = 0 ;
5597  PyObject * obj9 = 0 ;
5598  PyObject * obj10 = 0 ;
5599 
5600  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
5601  ecode1 = SWIG_AsVal_double(obj0, &val1);
5602  if (!SWIG_IsOK(ecode1)) {
5603  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5604  }
5605  arg1 = (PLFLT)(val1);
5606  ecode2 = SWIG_AsVal_double(obj1, &val2);
5607  if (!SWIG_IsOK(ecode2)) {
5608  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5609  }
5610  arg2 = (PLFLT)(val2);
5611  ecode3 = SWIG_AsVal_double(obj2, &val3);
5612  if (!SWIG_IsOK(ecode3)) {
5613  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5614  }
5615  arg3 = (PLFLT)(val3);
5616  ecode4 = SWIG_AsVal_int(obj3, &val4);
5617  if (!SWIG_IsOK(ecode4)) {
5618  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5619  }
5620  arg4 = (PLINT)(val4);
5621  ecode5 = SWIG_AsVal_int(obj4, &val5);
5622  if (!SWIG_IsOK(ecode5)) {
5623  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5624  }
5625  arg5 = (PLBOOL)(val5);
5626  ecode6 = SWIG_AsVal_int(obj5, &val6);
5627  if (!SWIG_IsOK(ecode6)) {
5628  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5629  }
5630  arg6 = (PLINT)(val6);
5631  ecode7 = SWIG_AsVal_int(obj6, &val7);
5632  if (!SWIG_IsOK(ecode7)) {
5633  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5634  }
5635  arg7 = (PLINT)(val7);
5636  ecode8 = SWIG_AsVal_int(obj7, &val8);
5637  if (!SWIG_IsOK(ecode8)) {
5638  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5639  }
5640  arg8 = (PLINT)(val8);
5641  ecode9 = SWIG_AsVal_int(obj8, &val9);
5642  if (!SWIG_IsOK(ecode9)) {
5643  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5644  }
5645  arg9 = (PLINT)(val9);
5646  ecode10 = SWIG_AsVal_int(obj9, &val10);
5647  if (!SWIG_IsOK(ecode10)) {
5648  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5649  }
5650  arg10 = (PLINT)(val10);
5651  ecode11 = SWIG_AsVal_double(obj10, &val11);
5652  if (!SWIG_IsOK(ecode11)) {
5653  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5654  }
5655  arg11 = (PLFLT)(val11);
5656  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5657  resultobj = SWIG_Py_Void();
5658  return resultobj;
5659 fail:
5660  return NULL;
5661 }
5662 
5663 
5664 SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5665  PyObject *resultobj = 0;
5666  PLFLT **arg1 = (PLFLT **) 0 ;
5667  PLINT arg2 ;
5668  PLINT arg3 ;
5669  PLINT arg4 ;
5670  PLINT arg5 ;
5671  PLINT arg6 ;
5672  PLINT arg7 ;
5673  PLFLT *arg8 = (PLFLT *) 0 ;
5674  PLINT arg9 ;
5675  pltr_func arg10 = (pltr_func) 0 ;
5676  PLPointer arg11 = (PLPointer) 0 ;
5677  PyArrayObject *tmp1 ;
5678  int val4 ;
5679  int ecode4 = 0 ;
5680  int val5 ;
5681  int ecode5 = 0 ;
5682  int val6 ;
5683  int ecode6 = 0 ;
5684  int val7 ;
5685  int ecode7 = 0 ;
5686  PyArrayObject *tmp8 ;
5687  PyObject * obj0 = 0 ;
5688  PyObject * obj1 = 0 ;
5689  PyObject * obj2 = 0 ;
5690  PyObject * obj3 = 0 ;
5691  PyObject * obj4 = 0 ;
5692  PyObject * obj5 = 0 ;
5693  PyObject * obj6 = 0 ;
5694  PyObject * obj7 = 0 ;
5695 
5696  {
5697  python_pltr = 0;
5698  arg10 = NULL;
5699  }
5700  {
5701  arg11 = NULL;
5702  }
5703  if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5704  {
5705  int i, size;
5706  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
5707  if ( tmp1 == NULL )
5708  return NULL;
5709  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5710  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5711  size = sizeof ( PLFLT ) * arg3;
5712  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
5713  for ( i = 0; i < arg2; i++ )
5714  arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
5715  }
5716  ecode4 = SWIG_AsVal_int(obj1, &val4);
5717  if (!SWIG_IsOK(ecode4)) {
5718  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
5719  }
5720  arg4 = (PLINT)(val4);
5721  ecode5 = SWIG_AsVal_int(obj2, &val5);
5722  if (!SWIG_IsOK(ecode5)) {
5723  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
5724  }
5725  arg5 = (PLINT)(val5);
5726  ecode6 = SWIG_AsVal_int(obj3, &val6);
5727  if (!SWIG_IsOK(ecode6)) {
5728  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
5729  }
5730  arg6 = (PLINT)(val6);
5731  ecode7 = SWIG_AsVal_int(obj4, &val7);
5732  if (!SWIG_IsOK(ecode7)) {
5733  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
5734  }
5735  arg7 = (PLINT)(val7);
5736  {
5737  tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
5738  if ( tmp8 == NULL )
5739  return NULL;
5740  arg9 = PyArray_DIMS( tmp8 )[0];
5741  arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5742  }
5743  if (obj6) {
5744  {
5745  // it must be a callable or None
5746  if ( obj6 == Py_None )
5747  {
5748  arg10 = NULL;
5749  }
5750  else
5751  {
5752  if ( !PyCallable_Check( (PyObject *) obj6 ) )
5753  {
5754  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
5755  return NULL;
5756  }
5757  arg10 = marshal_pltr( obj6 );
5758  }
5759  }
5760  }
5761  if (obj7) {
5762  {
5763  if ( obj7 == Py_None )
5764  arg11 = NULL;
5765  else
5766  {
5767  arg11 = marshal_PLPointer( obj7, 0 );
5768  }
5769  }
5770  }
5771  plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
5772  resultobj = SWIG_Py_Void();
5773  {
5774  Py_DECREF( tmp1 );
5775  free( arg1 );
5776  }
5777  {
5778  Py_DECREF( tmp8 );
5779  }
5780  {
5781  cleanup_pltr();
5782  }
5783  {
5785  }
5786  return resultobj;
5787 fail:
5788  {
5789  Py_DECREF( tmp1 );
5790  free( arg1 );
5791  }
5792  {
5793  Py_DECREF( tmp8 );
5794  }
5795  {
5796  cleanup_pltr();
5797  }
5798  {
5800  }
5801  return NULL;
5802 }
5803 
5804 
5805 SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5806  PyObject *resultobj = 0;
5807  PLINT arg1 ;
5808  PLINT arg2 ;
5809  PLINT arg3 ;
5810  PLINT arg4 ;
5811  PLINT arg5 ;
5812  PLFLT arg6 ;
5813  PLFLT *arg7 = (PLFLT *) 0 ;
5814  int val1 ;
5815  int ecode1 = 0 ;
5816  int val2 ;
5817  int ecode2 = 0 ;
5818  int val3 ;
5819  int ecode3 = 0 ;
5820  int val4 ;
5821  int ecode4 = 0 ;
5822  int val5 ;
5823  int ecode5 = 0 ;
5824  double val6 ;
5825  int ecode6 = 0 ;
5826  PLFLT temp7 ;
5827  int res7 = SWIG_TMPOBJ ;
5828  PyObject * obj0 = 0 ;
5829  PyObject * obj1 = 0 ;
5830  PyObject * obj2 = 0 ;
5831  PyObject * obj3 = 0 ;
5832  PyObject * obj4 = 0 ;
5833  PyObject * obj5 = 0 ;
5834 
5835  arg7 = &temp7;
5836  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5837  ecode1 = SWIG_AsVal_int(obj0, &val1);
5838  if (!SWIG_IsOK(ecode1)) {
5839  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
5840  }
5841  arg1 = (PLINT)(val1);
5842  ecode2 = SWIG_AsVal_int(obj1, &val2);
5843  if (!SWIG_IsOK(ecode2)) {
5844  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
5845  }
5846  arg2 = (PLINT)(val2);
5847  ecode3 = SWIG_AsVal_int(obj2, &val3);
5848  if (!SWIG_IsOK(ecode3)) {
5849  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
5850  }
5851  arg3 = (PLINT)(val3);
5852  ecode4 = SWIG_AsVal_int(obj3, &val4);
5853  if (!SWIG_IsOK(ecode4)) {
5854  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
5855  }
5856  arg4 = (PLINT)(val4);
5857  ecode5 = SWIG_AsVal_int(obj4, &val5);
5858  if (!SWIG_IsOK(ecode5)) {
5859  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
5860  }
5861  arg5 = (PLINT)(val5);
5862  ecode6 = SWIG_AsVal_double(obj5, &val6);
5863  if (!SWIG_IsOK(ecode6)) {
5864  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
5865  }
5866  arg6 = (PLFLT)(val6);
5867  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5868  resultobj = SWIG_Py_Void();
5869  if (SWIG_IsTmpObj(res7)) {
5870  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
5871  } else {
5872  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5873  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
5874  }
5875  return resultobj;
5876 fail:
5877  return NULL;
5878 }
5879 
5880 
5881 SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5882  PyObject *resultobj = 0;
5883  PLINT arg1 ;
5884  PLBOOL arg2 ;
5885  int val1 ;
5886  int ecode1 = 0 ;
5887  int val2 ;
5888  int ecode2 = 0 ;
5889  PyObject * obj0 = 0 ;
5890  PyObject * obj1 = 0 ;
5891 
5892  if (!PyArg_ParseTuple(args,(char *)"OO:plcpstrm",&obj0,&obj1)) SWIG_fail;
5893  ecode1 = SWIG_AsVal_int(obj0, &val1);
5894  if (!SWIG_IsOK(ecode1)) {
5895  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
5896  }
5897  arg1 = (PLINT)(val1);
5898  ecode2 = SWIG_AsVal_int(obj1, &val2);
5899  if (!SWIG_IsOK(ecode2)) {
5900  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
5901  }
5902  arg2 = (PLBOOL)(val2);
5903  plcpstrm(arg1,arg2);
5904  resultobj = SWIG_Py_Void();
5905  return resultobj;
5906 fail:
5907  return NULL;
5908 }
5909 
5910 
5911 SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5912  PyObject *resultobj = 0;
5913 
5914  if (!PyArg_ParseTuple(args,(char *)":plend")) SWIG_fail;
5915  plend();
5916  resultobj = SWIG_Py_Void();
5917  return resultobj;
5918 fail:
5919  return NULL;
5920 }
5921 
5922 
5923 SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5924  PyObject *resultobj = 0;
5925 
5926  if (!PyArg_ParseTuple(args,(char *)":plend1")) SWIG_fail;
5927  plend1();
5928  resultobj = SWIG_Py_Void();
5929  return resultobj;
5930 fail:
5931  return NULL;
5932 }
5933 
5934 
5935 SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5936  PyObject *resultobj = 0;
5937  PLFLT arg1 ;
5938  PLFLT arg2 ;
5939  PLFLT arg3 ;
5940  PLFLT arg4 ;
5941  PLINT arg5 ;
5942  PLINT arg6 ;
5943  double val1 ;
5944  int ecode1 = 0 ;
5945  double val2 ;
5946  int ecode2 = 0 ;
5947  double val3 ;
5948  int ecode3 = 0 ;
5949  double val4 ;
5950  int ecode4 = 0 ;
5951  int val5 ;
5952  int ecode5 = 0 ;
5953  int val6 ;
5954  int ecode6 = 0 ;
5955  PyObject * obj0 = 0 ;
5956  PyObject * obj1 = 0 ;
5957  PyObject * obj2 = 0 ;
5958  PyObject * obj3 = 0 ;
5959  PyObject * obj4 = 0 ;
5960  PyObject * obj5 = 0 ;
5961 
5962  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5963  ecode1 = SWIG_AsVal_double(obj0, &val1);
5964  if (!SWIG_IsOK(ecode1)) {
5965  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
5966  }
5967  arg1 = (PLFLT)(val1);
5968  ecode2 = SWIG_AsVal_double(obj1, &val2);
5969  if (!SWIG_IsOK(ecode2)) {
5970  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
5971  }
5972  arg2 = (PLFLT)(val2);
5973  ecode3 = SWIG_AsVal_double(obj2, &val3);
5974  if (!SWIG_IsOK(ecode3)) {
5975  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
5976  }
5977  arg3 = (PLFLT)(val3);
5978  ecode4 = SWIG_AsVal_double(obj3, &val4);
5979  if (!SWIG_IsOK(ecode4)) {
5980  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
5981  }
5982  arg4 = (PLFLT)(val4);
5983  ecode5 = SWIG_AsVal_int(obj4, &val5);
5984  if (!SWIG_IsOK(ecode5)) {
5985  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
5986  }
5987  arg5 = (PLINT)(val5);
5988  ecode6 = SWIG_AsVal_int(obj5, &val6);
5989  if (!SWIG_IsOK(ecode6)) {
5990  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
5991  }
5992  arg6 = (PLINT)(val6);
5993  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
5994  resultobj = SWIG_Py_Void();
5995  return resultobj;
5996 fail:
5997  return NULL;
5998 }
5999 
6000 
6001 SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6002  PyObject *resultobj = 0;
6003  PLFLT arg1 ;
6004  PLFLT arg2 ;
6005  PLFLT arg3 ;
6006  PLFLT arg4 ;
6007  PLINT arg5 ;
6008  PLINT arg6 ;
6009  double val1 ;
6010  int ecode1 = 0 ;
6011  double val2 ;
6012  int ecode2 = 0 ;
6013  double val3 ;
6014  int ecode3 = 0 ;
6015  double val4 ;
6016  int ecode4 = 0 ;
6017  int val5 ;
6018  int ecode5 = 0 ;
6019  int val6 ;
6020  int ecode6 = 0 ;
6021  PyObject * obj0 = 0 ;
6022  PyObject * obj1 = 0 ;
6023  PyObject * obj2 = 0 ;
6024  PyObject * obj3 = 0 ;
6025  PyObject * obj4 = 0 ;
6026  PyObject * obj5 = 0 ;
6027 
6028  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6029  ecode1 = SWIG_AsVal_double(obj0, &val1);
6030  if (!SWIG_IsOK(ecode1)) {
6031  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6032  }
6033  arg1 = (PLFLT)(val1);
6034  ecode2 = SWIG_AsVal_double(obj1, &val2);
6035  if (!SWIG_IsOK(ecode2)) {
6036  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6037  }
6038  arg2 = (PLFLT)(val2);
6039  ecode3 = SWIG_AsVal_double(obj2, &val3);
6040  if (!SWIG_IsOK(ecode3)) {
6041  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6042  }
6043  arg3 = (PLFLT)(val3);
6044  ecode4 = SWIG_AsVal_double(obj3, &val4);
6045  if (!SWIG_IsOK(ecode4)) {
6046  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6047  }
6048  arg4 = (PLFLT)(val4);
6049  ecode5 = SWIG_AsVal_int(obj4, &val5);
6050  if (!SWIG_IsOK(ecode5)) {
6051  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6052  }
6053  arg5 = (PLINT)(val5);
6054  ecode6 = SWIG_AsVal_int(obj5, &val6);
6055  if (!SWIG_IsOK(ecode6)) {
6056  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6057  }
6058  arg6 = (PLINT)(val6);
6059  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6060  resultobj = SWIG_Py_Void();
6061  return resultobj;
6062 fail:
6063  return NULL;
6064 }
6065 
6066 
6067 SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6068  PyObject *resultobj = 0;
6069 
6070  if (!PyArg_ParseTuple(args,(char *)":pleop")) SWIG_fail;
6071  pleop();
6072  resultobj = SWIG_Py_Void();
6073  return resultobj;
6074 fail:
6075  return NULL;
6076 }
6077 
6078 
6079 SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6080  PyObject *resultobj = 0;
6081  PLINT arg1 ;
6082  PLFLT *arg2 = (PLFLT *) 0 ;
6083  PLFLT *arg3 = (PLFLT *) 0 ;
6084  PLFLT *arg4 = (PLFLT *) 0 ;
6085  PyArrayObject *tmp1 ;
6086  PyArrayObject *tmp3 ;
6087  PyArrayObject *tmp4 ;
6088  PyObject * obj0 = 0 ;
6089  PyObject * obj1 = 0 ;
6090  PyObject * obj2 = 0 ;
6091 
6092  if (!PyArg_ParseTuple(args,(char *)"OOO:plerrx",&obj0,&obj1,&obj2)) SWIG_fail;
6093  {
6094  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6095  if ( tmp1 == NULL )
6096  return NULL;
6097  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6098  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6099  }
6100  {
6101  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6102  if ( tmp3 == NULL )
6103  return NULL;
6104  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6105  {
6106  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6107  return NULL;
6108  }
6109  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6110  }
6111  {
6112  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6113  if ( tmp4 == NULL )
6114  return NULL;
6115  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6116  {
6117  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6118  return NULL;
6119  }
6120  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6121  }
6122  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6123  resultobj = SWIG_Py_Void();
6124  {
6125  Py_DECREF( tmp1 );
6126  }
6127  {
6128  Py_DECREF( tmp3 );
6129  }
6130  {
6131  Py_DECREF( tmp4 );
6132  }
6133  return resultobj;
6134 fail:
6135  {
6136  Py_DECREF( tmp1 );
6137  }
6138  {
6139  Py_DECREF( tmp3 );
6140  }
6141  {
6142  Py_DECREF( tmp4 );
6143  }
6144  return NULL;
6145 }
6146 
6147 
6148 SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6149  PyObject *resultobj = 0;
6150  PLINT arg1 ;
6151  PLFLT *arg2 = (PLFLT *) 0 ;
6152  PLFLT *arg3 = (PLFLT *) 0 ;
6153  PLFLT *arg4 = (PLFLT *) 0 ;
6154  PyArrayObject *tmp1 ;
6155  PyArrayObject *tmp3 ;
6156  PyArrayObject *tmp4 ;
6157  PyObject * obj0 = 0 ;
6158  PyObject * obj1 = 0 ;
6159  PyObject * obj2 = 0 ;
6160 
6161  if (!PyArg_ParseTuple(args,(char *)"OOO:plerry",&obj0,&obj1,&obj2)) SWIG_fail;
6162  {
6163  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6164  if ( tmp1 == NULL )
6165  return NULL;
6166  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6167  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6168  }
6169  {
6170  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6171  if ( tmp3 == NULL )
6172  return NULL;
6173  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6174  {
6175  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6176  return NULL;
6177  }
6178  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6179  }
6180  {
6181  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6182  if ( tmp4 == NULL )
6183  return NULL;
6184  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6185  {
6186  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6187  return NULL;
6188  }
6189  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6190  }
6191  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6192  resultobj = SWIG_Py_Void();
6193  {
6194  Py_DECREF( tmp1 );
6195  }
6196  {
6197  Py_DECREF( tmp3 );
6198  }
6199  {
6200  Py_DECREF( tmp4 );
6201  }
6202  return resultobj;
6203 fail:
6204  {
6205  Py_DECREF( tmp1 );
6206  }
6207  {
6208  Py_DECREF( tmp3 );
6209  }
6210  {
6211  Py_DECREF( tmp4 );
6212  }
6213  return NULL;
6214 }
6215 
6216 
6217 SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6218  PyObject *resultobj = 0;
6219 
6220  if (!PyArg_ParseTuple(args,(char *)":plfamadv")) SWIG_fail;
6221  plfamadv();
6222  resultobj = SWIG_Py_Void();
6223  return resultobj;
6224 fail:
6225  return NULL;
6226 }
6227 
6228 
6229 SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6230  PyObject *resultobj = 0;
6231  PLINT arg1 ;
6232  PLFLT *arg2 = (PLFLT *) 0 ;
6233  PLFLT *arg3 = (PLFLT *) 0 ;
6234  PyArrayObject *tmp1 ;
6235  PyArrayObject *tmp3 ;
6236  PyObject * obj0 = 0 ;
6237  PyObject * obj1 = 0 ;
6238 
6239  if (!PyArg_ParseTuple(args,(char *)"OO:plfill",&obj0,&obj1)) SWIG_fail;
6240  {
6241  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6242  if ( tmp1 == NULL )
6243  return NULL;
6244  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6245  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6246  }
6247  {
6248  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6249  if ( tmp3 == NULL )
6250  return NULL;
6251  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6252  {
6253  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6254  return NULL;
6255  }
6256  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6257  }
6258  plfill(arg1,(double const *)arg2,(double const *)arg3);
6259  resultobj = SWIG_Py_Void();
6260  {
6261  Py_DECREF( tmp1 );
6262  }
6263  {
6264  Py_DECREF( tmp3 );
6265  }
6266  return resultobj;
6267 fail:
6268  {
6269  Py_DECREF( tmp1 );
6270  }
6271  {
6272  Py_DECREF( tmp3 );
6273  }
6274  return NULL;
6275 }
6276 
6277 
6278 SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6279  PyObject *resultobj = 0;
6280  PLINT arg1 ;
6281  PLFLT *arg2 = (PLFLT *) 0 ;
6282  PLFLT *arg3 = (PLFLT *) 0 ;
6283  PLFLT *arg4 = (PLFLT *) 0 ;
6284  PyArrayObject *tmp1 ;
6285  PyArrayObject *tmp3 ;
6286  PyArrayObject *tmp4 ;
6287  PyObject * obj0 = 0 ;
6288  PyObject * obj1 = 0 ;
6289  PyObject * obj2 = 0 ;
6290 
6291  if (!PyArg_ParseTuple(args,(char *)"OOO:plfill3",&obj0,&obj1,&obj2)) SWIG_fail;
6292  {
6293  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6294  if ( tmp1 == NULL )
6295  return NULL;
6296  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6297  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6298  }
6299  {
6300  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6301  if ( tmp3 == NULL )
6302  return NULL;
6303  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6304  {
6305  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6306  return NULL;
6307  }
6308  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6309  }
6310  {
6311  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6312  if ( tmp4 == NULL )
6313  return NULL;
6314  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6315  {
6316  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6317  return NULL;
6318  }
6319  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6320  }
6321  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6322  resultobj = SWIG_Py_Void();
6323  {
6324  Py_DECREF( tmp1 );
6325  }
6326  {
6327  Py_DECREF( tmp3 );
6328  }
6329  {
6330  Py_DECREF( tmp4 );
6331  }
6332  return resultobj;
6333 fail:
6334  {
6335  Py_DECREF( tmp1 );
6336  }
6337  {
6338  Py_DECREF( tmp3 );
6339  }
6340  {
6341  Py_DECREF( tmp4 );
6342  }
6343  return NULL;
6344 }
6345 
6346 
6347 SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6348  PyObject *resultobj = 0;
6349  PLINT arg1 ;
6350  PLFLT *arg2 = (PLFLT *) 0 ;
6351  PLFLT *arg3 = (PLFLT *) 0 ;
6352  PLFLT arg4 ;
6353  PyArrayObject *tmp1 ;
6354  PyArrayObject *tmp3 ;
6355  double val4 ;
6356  int ecode4 = 0 ;
6357  PyObject * obj0 = 0 ;
6358  PyObject * obj1 = 0 ;
6359  PyObject * obj2 = 0 ;
6360 
6361  if (!PyArg_ParseTuple(args,(char *)"OOO:plgradient",&obj0,&obj1,&obj2)) SWIG_fail;
6362  {
6363  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6364  if ( tmp1 == NULL )
6365  return NULL;
6366  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6367  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6368  }
6369  {
6370  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6371  if ( tmp3 == NULL )
6372  return NULL;
6373  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6374  {
6375  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6376  return NULL;
6377  }
6378  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6379  }
6380  ecode4 = SWIG_AsVal_double(obj2, &val4);
6381  if (!SWIG_IsOK(ecode4)) {
6382  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6383  }
6384  arg4 = (PLFLT)(val4);
6385  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6386  resultobj = SWIG_Py_Void();
6387  {
6388  Py_DECREF( tmp1 );
6389  }
6390  {
6391  Py_DECREF( tmp3 );
6392  }
6393  return resultobj;
6394 fail:
6395  {
6396  Py_DECREF( tmp1 );
6397  }
6398  {
6399  Py_DECREF( tmp3 );
6400  }
6401  return NULL;
6402 }
6403 
6404 
6405 SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6406  PyObject *resultobj = 0;
6407 
6408  if (!PyArg_ParseTuple(args,(char *)":plflush")) SWIG_fail;
6409  plflush();
6410  resultobj = SWIG_Py_Void();
6411  return resultobj;
6412 fail:
6413  return NULL;
6414 }
6415 
6416 
6417 SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6418  PyObject *resultobj = 0;
6419  PLINT arg1 ;
6420  int val1 ;
6421  int ecode1 = 0 ;
6422  PyObject * obj0 = 0 ;
6423 
6424  if (!PyArg_ParseTuple(args,(char *)"O:plfont",&obj0)) SWIG_fail;
6425  ecode1 = SWIG_AsVal_int(obj0, &val1);
6426  if (!SWIG_IsOK(ecode1)) {
6427  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6428  }
6429  arg1 = (PLINT)(val1);
6430  plfont(arg1);
6431  resultobj = SWIG_Py_Void();
6432  return resultobj;
6433 fail:
6434  return NULL;
6435 }
6436 
6437 
6438 SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6439  PyObject *resultobj = 0;
6440  PLINT arg1 ;
6441  int val1 ;
6442  int ecode1 = 0 ;
6443  PyObject * obj0 = 0 ;
6444 
6445  if (!PyArg_ParseTuple(args,(char *)"O:plfontld",&obj0)) SWIG_fail;
6446  ecode1 = SWIG_AsVal_int(obj0, &val1);
6447  if (!SWIG_IsOK(ecode1)) {
6448  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6449  }
6450  arg1 = (PLINT)(val1);
6451  plfontld(arg1);
6452  resultobj = SWIG_Py_Void();
6453  return resultobj;
6454 fail:
6455  return NULL;
6456 }
6457 
6458 
6459 SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6460  PyObject *resultobj = 0;
6461  PLFLT *arg1 = (PLFLT *) 0 ;
6462  PLFLT *arg2 = (PLFLT *) 0 ;
6463  PLFLT temp1 ;
6464  int res1 = SWIG_TMPOBJ ;
6465  PLFLT temp2 ;
6466  int res2 = SWIG_TMPOBJ ;
6467 
6468  arg1 = &temp1;
6469  arg2 = &temp2;
6470  if (!PyArg_ParseTuple(args,(char *)":plgchr")) SWIG_fail;
6471  plgchr(arg1,arg2);
6472  resultobj = SWIG_Py_Void();
6473  if (SWIG_IsTmpObj(res1)) {
6474  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6475  } else {
6476  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6477  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6478  }
6479  if (SWIG_IsTmpObj(res2)) {
6480  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6481  } else {
6482  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6483  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6484  }
6485  return resultobj;
6486 fail:
6487  return NULL;
6488 }
6489 
6490 
6491 SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6492  PyObject *resultobj = 0;
6493  PLINT arg1 ;
6494  PLINT *arg2 = (PLINT *) 0 ;
6495  PLINT *arg3 = (PLINT *) 0 ;
6496  PLINT *arg4 = (PLINT *) 0 ;
6497  int val1 ;
6498  int ecode1 = 0 ;
6499  PLINT temp2 ;
6500  int res2 = SWIG_TMPOBJ ;
6501  PLINT temp3 ;
6502  int res3 = SWIG_TMPOBJ ;
6503  PLINT temp4 ;
6504  int res4 = SWIG_TMPOBJ ;
6505  PyObject * obj0 = 0 ;
6506 
6507  arg2 = &temp2;
6508  arg3 = &temp3;
6509  arg4 = &temp4;
6510  if (!PyArg_ParseTuple(args,(char *)"O:plgcol0",&obj0)) SWIG_fail;
6511  ecode1 = SWIG_AsVal_int(obj0, &val1);
6512  if (!SWIG_IsOK(ecode1)) {
6513  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6514  }
6515  arg1 = (PLINT)(val1);
6516  plgcol0(arg1,arg2,arg3,arg4);
6517  resultobj = SWIG_Py_Void();
6518  if (SWIG_IsTmpObj(res2)) {
6519  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6520  } else {
6521  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6522  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6523  }
6524  if (SWIG_IsTmpObj(res3)) {
6525  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6526  } else {
6527  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6528  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6529  }
6530  if (SWIG_IsTmpObj(res4)) {
6531  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6532  } else {
6533  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6534  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6535  }
6536  return resultobj;
6537 fail:
6538  return NULL;
6539 }
6540 
6541 
6542 SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6543  PyObject *resultobj = 0;
6544  PLINT arg1 ;
6545  PLINT *arg2 = (PLINT *) 0 ;
6546  PLINT *arg3 = (PLINT *) 0 ;
6547  PLINT *arg4 = (PLINT *) 0 ;
6548  PLFLT *arg5 = (PLFLT *) 0 ;
6549  int val1 ;
6550  int ecode1 = 0 ;
6551  PLINT temp2 ;
6552  int res2 = SWIG_TMPOBJ ;
6553  PLINT temp3 ;
6554  int res3 = SWIG_TMPOBJ ;
6555  PLINT temp4 ;
6556  int res4 = SWIG_TMPOBJ ;
6557  PLFLT temp5 ;
6558  int res5 = SWIG_TMPOBJ ;
6559  PyObject * obj0 = 0 ;
6560 
6561  arg2 = &temp2;
6562  arg3 = &temp3;
6563  arg4 = &temp4;
6564  arg5 = &temp5;
6565  if (!PyArg_ParseTuple(args,(char *)"O:plgcol0a",&obj0)) SWIG_fail;
6566  ecode1 = SWIG_AsVal_int(obj0, &val1);
6567  if (!SWIG_IsOK(ecode1)) {
6568  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6569  }
6570  arg1 = (PLINT)(val1);
6571  plgcol0a(arg1,arg2,arg3,arg4,arg5);
6572  resultobj = SWIG_Py_Void();
6573  if (SWIG_IsTmpObj(res2)) {
6574  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6575  } else {
6576  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6577  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6578  }
6579  if (SWIG_IsTmpObj(res3)) {
6580  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6581  } else {
6582  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6583  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6584  }
6585  if (SWIG_IsTmpObj(res4)) {
6586  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6587  } else {
6588  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6589  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6590  }
6591  if (SWIG_IsTmpObj(res5)) {
6592  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6593  } else {
6594  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6595  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6596  }
6597  return resultobj;
6598 fail:
6599  return NULL;
6600 }
6601 
6602 
6603 SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6604  PyObject *resultobj = 0;
6605  PLINT *arg1 = (PLINT *) 0 ;
6606  PLINT *arg2 = (PLINT *) 0 ;
6607  PLINT *arg3 = (PLINT *) 0 ;
6608  PLINT temp1 ;
6609  int res1 = SWIG_TMPOBJ ;
6610  PLINT temp2 ;
6611  int res2 = SWIG_TMPOBJ ;
6612  PLINT temp3 ;
6613  int res3 = SWIG_TMPOBJ ;
6614 
6615  arg1 = &temp1;
6616  arg2 = &temp2;
6617  arg3 = &temp3;
6618  if (!PyArg_ParseTuple(args,(char *)":plgcolbg")) SWIG_fail;
6619  plgcolbg(arg1,arg2,arg3);
6620  resultobj = SWIG_Py_Void();
6621  if (SWIG_IsTmpObj(res1)) {
6622  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6623  } else {
6624  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6625  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6626  }
6627  if (SWIG_IsTmpObj(res2)) {
6628  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6629  } else {
6630  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6631  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6632  }
6633  if (SWIG_IsTmpObj(res3)) {
6634  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6635  } else {
6636  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6637  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6638  }
6639  return resultobj;
6640 fail:
6641  return NULL;
6642 }
6643 
6644 
6645 SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6646  PyObject *resultobj = 0;
6647  PLINT *arg1 = (PLINT *) 0 ;
6648  PLINT *arg2 = (PLINT *) 0 ;
6649  PLINT *arg3 = (PLINT *) 0 ;
6650  PLFLT *arg4 = (PLFLT *) 0 ;
6651  PLINT temp1 ;
6652  int res1 = SWIG_TMPOBJ ;
6653  PLINT temp2 ;
6654  int res2 = SWIG_TMPOBJ ;
6655  PLINT temp3 ;
6656  int res3 = SWIG_TMPOBJ ;
6657  PLFLT temp4 ;
6658  int res4 = SWIG_TMPOBJ ;
6659 
6660  arg1 = &temp1;
6661  arg2 = &temp2;
6662  arg3 = &temp3;
6663  arg4 = &temp4;
6664  if (!PyArg_ParseTuple(args,(char *)":plgcolbga")) SWIG_fail;
6665  plgcolbga(arg1,arg2,arg3,arg4);
6666  resultobj = SWIG_Py_Void();
6667  if (SWIG_IsTmpObj(res1)) {
6668  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6669  } else {
6670  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6671  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6672  }
6673  if (SWIG_IsTmpObj(res2)) {
6674  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6675  } else {
6676  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6677  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6678  }
6679  if (SWIG_IsTmpObj(res3)) {
6680  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6681  } else {
6682  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6683  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6684  }
6685  if (SWIG_IsTmpObj(res4)) {
6686  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6687  } else {
6688  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6689  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6690  }
6691  return resultobj;
6692 fail:
6693  return NULL;
6694 }
6695 
6696 
6697 SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6698  PyObject *resultobj = 0;
6699  PLINT *arg1 = (PLINT *) 0 ;
6700  PLINT temp1 ;
6701  int res1 = SWIG_TMPOBJ ;
6702 
6703  arg1 = &temp1;
6704  if (!PyArg_ParseTuple(args,(char *)":plgcompression")) SWIG_fail;
6705  plgcompression(arg1);
6706  resultobj = SWIG_Py_Void();
6707  if (SWIG_IsTmpObj(res1)) {
6708  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6709  } else {
6710  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6711  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6712  }
6713  return resultobj;
6714 fail:
6715  return NULL;
6716 }
6717 
6718 
6719 SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6720  PyObject *resultobj = 0;
6721  char *arg1 = (char *) 0 ;
6722  char buff1[1000] ;
6723 
6724  {
6725  arg1 = buff1;
6726  }
6727  if (!PyArg_ParseTuple(args,(char *)":plgdev")) SWIG_fail;
6728  plgdev(arg1);
6729  resultobj = SWIG_Py_Void();
6730  {
6731  PyObject *o = PyString_FromString( arg1 );
6732  resultobj = t_output_helper( resultobj, o );
6733  }
6734  return resultobj;
6735 fail:
6736  return NULL;
6737 }
6738 
6739 
6740 SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6741  PyObject *resultobj = 0;
6742  PLFLT *arg1 = (PLFLT *) 0 ;
6743  PLFLT *arg2 = (PLFLT *) 0 ;
6744  PLFLT *arg3 = (PLFLT *) 0 ;
6745  PLFLT *arg4 = (PLFLT *) 0 ;
6746  PLFLT temp1 ;
6747  int res1 = SWIG_TMPOBJ ;
6748  PLFLT temp2 ;
6749  int res2 = SWIG_TMPOBJ ;
6750  PLFLT temp3 ;
6751  int res3 = SWIG_TMPOBJ ;
6752  PLFLT temp4 ;
6753  int res4 = SWIG_TMPOBJ ;
6754 
6755  arg1 = &temp1;
6756  arg2 = &temp2;
6757  arg3 = &temp3;
6758  arg4 = &temp4;
6759  if (!PyArg_ParseTuple(args,(char *)":plgdidev")) SWIG_fail;
6760  plgdidev(arg1,arg2,arg3,arg4);
6761  resultobj = SWIG_Py_Void();
6762  if (SWIG_IsTmpObj(res1)) {
6763  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6764  } else {
6765  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6766  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6767  }
6768  if (SWIG_IsTmpObj(res2)) {
6769  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6770  } else {
6771  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6772  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6773  }
6774  if (SWIG_IsTmpObj(res3)) {
6775  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6776  } else {
6777  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6778  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6779  }
6780  if (SWIG_IsTmpObj(res4)) {
6781  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6782  } else {
6783  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6784  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6785  }
6786  return resultobj;
6787 fail:
6788  return NULL;
6789 }
6790 
6791 
6792 SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6793  PyObject *resultobj = 0;
6794  PLFLT *arg1 = (PLFLT *) 0 ;
6795  PLFLT temp1 ;
6796  int res1 = SWIG_TMPOBJ ;
6797 
6798  arg1 = &temp1;
6799  if (!PyArg_ParseTuple(args,(char *)":plgdiori")) SWIG_fail;
6800  plgdiori(arg1);
6801  resultobj = SWIG_Py_Void();
6802  if (SWIG_IsTmpObj(res1)) {
6803  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6804  } else {
6805  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6806  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6807  }
6808  return resultobj;
6809 fail:
6810  return NULL;
6811 }
6812 
6813 
6814 SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6815  PyObject *resultobj = 0;
6816  PLFLT *arg1 = (PLFLT *) 0 ;
6817  PLFLT *arg2 = (PLFLT *) 0 ;
6818  PLFLT *arg3 = (PLFLT *) 0 ;
6819  PLFLT *arg4 = (PLFLT *) 0 ;
6820  PLFLT temp1 ;
6821  int res1 = SWIG_TMPOBJ ;
6822  PLFLT temp2 ;
6823  int res2 = SWIG_TMPOBJ ;
6824  PLFLT temp3 ;
6825  int res3 = SWIG_TMPOBJ ;
6826  PLFLT temp4 ;
6827  int res4 = SWIG_TMPOBJ ;
6828 
6829  arg1 = &temp1;
6830  arg2 = &temp2;
6831  arg3 = &temp3;
6832  arg4 = &temp4;
6833  if (!PyArg_ParseTuple(args,(char *)":plgdiplt")) SWIG_fail;
6834  plgdiplt(arg1,arg2,arg3,arg4);
6835  resultobj = SWIG_Py_Void();
6836  if (SWIG_IsTmpObj(res1)) {
6837  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6838  } else {
6839  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6840  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6841  }
6842  if (SWIG_IsTmpObj(res2)) {
6843  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6844  } else {
6845  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6846  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6847  }
6848  if (SWIG_IsTmpObj(res3)) {
6849  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6850  } else {
6851  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6852  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6853  }
6854  if (SWIG_IsTmpObj(res4)) {
6855  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6856  } else {
6857  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6858  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6859  }
6860  return resultobj;
6861 fail:
6862  return NULL;
6863 }
6864 
6865 
6866 SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6867  PyObject *resultobj = 0;
6868  PLINT *arg1 = (PLINT *) 0 ;
6869  PLINT *arg2 = (PLINT *) 0 ;
6870  PLINT *arg3 = (PLINT *) 0 ;
6871  PLINT temp1 ;
6872  int res1 = SWIG_TMPOBJ ;
6873  PLINT temp2 ;
6874  int res2 = SWIG_TMPOBJ ;
6875  PLINT temp3 ;
6876  int res3 = SWIG_TMPOBJ ;
6877 
6878  arg1 = &temp1;
6879  arg2 = &temp2;
6880  arg3 = &temp3;
6881  if (!PyArg_ParseTuple(args,(char *)":plgfam")) SWIG_fail;
6882  plgfam(arg1,arg2,arg3);
6883  resultobj = SWIG_Py_Void();
6884  if (SWIG_IsTmpObj(res1)) {
6885  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6886  } else {
6887  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6888  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6889  }
6890  if (SWIG_IsTmpObj(res2)) {
6891  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6892  } else {
6893  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6894  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6895  }
6896  if (SWIG_IsTmpObj(res3)) {
6897  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6898  } else {
6899  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6900  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6901  }
6902  return resultobj;
6903 fail:
6904  return NULL;
6905 }
6906 
6907 
6908 SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6909  PyObject *resultobj = 0;
6910  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
6911  PLUNICODE temp1 ;
6912  int res1 = SWIG_TMPOBJ ;
6913 
6914  arg1 = &temp1;
6915  if (!PyArg_ParseTuple(args,(char *)":plgfci")) SWIG_fail;
6916  plgfci(arg1);
6917  resultobj = SWIG_Py_Void();
6918  if (SWIG_IsTmpObj(res1)) {
6919  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
6920  } else {
6921  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6922  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
6923  }
6924  return resultobj;
6925 fail:
6926  return NULL;
6927 }
6928 
6929 
6930 SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6931  PyObject *resultobj = 0;
6932  char *arg1 = (char *) 0 ;
6933  char buff1[1000] ;
6934 
6935  {
6936  arg1 = buff1;
6937  }
6938  if (!PyArg_ParseTuple(args,(char *)":plgfnam")) SWIG_fail;
6939  plgfnam(arg1);
6940  resultobj = SWIG_Py_Void();
6941  {
6942  PyObject *o = PyString_FromString( arg1 );
6943  resultobj = t_output_helper( resultobj, o );
6944  }
6945  return resultobj;
6946 fail:
6947  return NULL;
6948 }
6949 
6950 
6951 SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6952  PyObject *resultobj = 0;
6953  PLINT *arg1 = (PLINT *) 0 ;
6954  PLINT *arg2 = (PLINT *) 0 ;
6955  PLINT *arg3 = (PLINT *) 0 ;
6956  PLINT temp1 ;
6957  int res1 = SWIG_TMPOBJ ;
6958  PLINT temp2 ;
6959  int res2 = SWIG_TMPOBJ ;
6960  PLINT temp3 ;
6961  int res3 = SWIG_TMPOBJ ;
6962 
6963  arg1 = &temp1;
6964  arg2 = &temp2;
6965  arg3 = &temp3;
6966  if (!PyArg_ParseTuple(args,(char *)":plgfont")) SWIG_fail;
6967  plgfont(arg1,arg2,arg3);
6968  resultobj = SWIG_Py_Void();
6969  if (SWIG_IsTmpObj(res1)) {
6970  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6971  } else {
6972  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6973  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6974  }
6975  if (SWIG_IsTmpObj(res2)) {
6976  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6977  } else {
6978  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6979  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6980  }
6981  if (SWIG_IsTmpObj(res3)) {
6982  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6983  } else {
6984  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6985  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6986  }
6987  return resultobj;
6988 fail:
6989  return NULL;
6990 }
6991 
6992 
6993 SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6994  PyObject *resultobj = 0;
6995  PLINT *arg1 = (PLINT *) 0 ;
6996  PLINT temp1 ;
6997  int res1 = SWIG_TMPOBJ ;
6998 
6999  arg1 = &temp1;
7000  if (!PyArg_ParseTuple(args,(char *)":plglevel")) SWIG_fail;
7001  plglevel(arg1);
7002  resultobj = SWIG_Py_Void();
7003  if (SWIG_IsTmpObj(res1)) {
7004  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7005  } else {
7006  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7007  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7008  }
7009  return resultobj;
7010 fail:
7011  return NULL;
7012 }
7013 
7014 
7015 SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7016  PyObject *resultobj = 0;
7017  PLFLT *arg1 = (PLFLT *) 0 ;
7018  PLFLT *arg2 = (PLFLT *) 0 ;
7019  PLINT *arg3 = (PLINT *) 0 ;
7020  PLINT *arg4 = (PLINT *) 0 ;
7021  PLINT *arg5 = (PLINT *) 0 ;
7022  PLINT *arg6 = (PLINT *) 0 ;
7023  PLFLT temp1 ;
7024  int res1 = SWIG_TMPOBJ ;
7025  PLFLT temp2 ;
7026  int res2 = SWIG_TMPOBJ ;
7027  PLINT temp3 ;
7028  int res3 = SWIG_TMPOBJ ;
7029  PLINT temp4 ;
7030  int res4 = SWIG_TMPOBJ ;
7031  PLINT temp5 ;
7032  int res5 = SWIG_TMPOBJ ;
7033  PLINT temp6 ;
7034  int res6 = SWIG_TMPOBJ ;
7035 
7036  arg1 = &temp1;
7037  arg2 = &temp2;
7038  arg3 = &temp3;
7039  arg4 = &temp4;
7040  arg5 = &temp5;
7041  arg6 = &temp6;
7042  if (!PyArg_ParseTuple(args,(char *)":plgpage")) SWIG_fail;
7043  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7044  resultobj = SWIG_Py_Void();
7045  if (SWIG_IsTmpObj(res1)) {
7046  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7047  } else {
7048  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7049  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7050  }
7051  if (SWIG_IsTmpObj(res2)) {
7052  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7053  } else {
7054  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7055  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7056  }
7057  if (SWIG_IsTmpObj(res3)) {
7058  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7059  } else {
7060  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7061  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7062  }
7063  if (SWIG_IsTmpObj(res4)) {
7064  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
7065  } else {
7066  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7067  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
7068  }
7069  if (SWIG_IsTmpObj(res5)) {
7070  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
7071  } else {
7072  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7073  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
7074  }
7075  if (SWIG_IsTmpObj(res6)) {
7076  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
7077  } else {
7078  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7079  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
7080  }
7081  return resultobj;
7082 fail:
7083  return NULL;
7084 }
7085 
7086 
7087 SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7088  PyObject *resultobj = 0;
7089 
7090  if (!PyArg_ParseTuple(args,(char *)":plgra")) SWIG_fail;
7091  plgra();
7092  resultobj = SWIG_Py_Void();
7093  return resultobj;
7094 fail:
7095  return NULL;
7096 }
7097 
7098 
7099 SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7100  PyObject *resultobj = 0;
7101  PLFLT *arg1 = (PLFLT *) 0 ;
7102  PLFLT *arg2 = (PLFLT *) 0 ;
7103  PLFLT *arg3 = (PLFLT *) 0 ;
7104  PLINT arg4 ;
7105  PLFLT *arg5 = (PLFLT *) 0 ;
7106  PLINT arg6 ;
7107  PLFLT *arg7 = (PLFLT *) 0 ;
7108  PLINT arg8 ;
7109  PLFLT **arg9 = (PLFLT **) 0 ;
7110  PLINT arg10 ;
7111  PLFLT arg11 ;
7112  PyArrayObject *tmp1 ;
7113  PyArrayObject *tmp2 ;
7114  PyArrayObject *tmp3 ;
7115  PyArrayObject *tmp5 ;
7116  PyArrayObject *tmp7 ;
7117  PyObject *array7 = NULL ;
7118  int val10 ;
7119  int ecode10 = 0 ;
7120  double val11 ;
7121  int ecode11 = 0 ;
7122  PyObject * obj0 = 0 ;
7123  PyObject * obj1 = 0 ;
7124  PyObject * obj2 = 0 ;
7125  PyObject * obj3 = 0 ;
7126  PyObject * obj4 = 0 ;
7127  PyObject * obj5 = 0 ;
7128  PyObject * obj6 = 0 ;
7129 
7130  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
7131  {
7132  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7133  if ( tmp1 == NULL )
7134  return NULL;
7135  Alen = PyArray_DIMS( tmp1 )[0];
7136  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7137  }
7138  {
7139  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
7140  if ( tmp2 == NULL )
7141  return NULL;
7142  if ( PyArray_DIMS( tmp2 )[0] != Alen )
7143  {
7144  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7145  return NULL;
7146  }
7147  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7148  }
7149  {
7150  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
7151  if ( tmp3 == NULL )
7152  return NULL;
7153  if ( PyArray_DIMS( tmp3 )[0] != Alen )
7154  {
7155  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7156  return NULL;
7157  }
7158  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7159  arg4 = PyArray_DIMS( tmp3 )[0];
7160  }
7161  {
7162  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
7163  if ( tmp5 == NULL )
7164  return NULL;
7165  Xlen = PyArray_DIMS( tmp5 )[0];
7166  arg6 = Xlen;
7167  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7168  }
7169  {
7170  int i, size;
7171  npy_intp dims[2];
7172  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
7173  if ( tmp7 == NULL )
7174  return NULL;
7175  Ylen = PyArray_DIMS( tmp7 )[0];
7176  arg8 = Ylen;
7177  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7178  // Make created 2D array7 have dimensions from prior ArrayX in the argument
7179  // list and this ArrayY.
7180  dims[0] = Xlen;
7181  dims[1] = Ylen;
7182  array7 = PyArray_SimpleNew( 2, dims, NPY_DOUBLE );
7183  if ( !array7 )
7184  return NULL;
7185  size = (int) ( sizeof ( double ) * Ylen );
7186  arg9 = (double **) malloc( sizeof ( double * ) * Xlen );
7187  for ( i = 0; i < Xlen; i++ )
7188  arg9[i] = (double *) ( PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7189  }
7190  ecode10 = SWIG_AsVal_int(obj5, &val10);
7191  if (!SWIG_IsOK(ecode10)) {
7192  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7193  }
7194  arg10 = (PLINT)(val10);
7195  ecode11 = SWIG_AsVal_double(obj6, &val11);
7196  if (!SWIG_IsOK(ecode11)) {
7197  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7198  }
7199  arg11 = (PLFLT)(val11);
7200  plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7201  resultobj = SWIG_Py_Void();
7202  {
7203  resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
7204  }
7205  {
7206  Py_DECREF( tmp1 );
7207  }
7208  {
7209  Py_DECREF( tmp2 );
7210  }
7211  {
7212  Py_DECREF( tmp3 );
7213  }
7214  {
7215  Py_DECREF( tmp5 );
7216  }
7217  {
7218  Py_DECREF( tmp7 );
7219  free( arg9 );
7220  }
7221  return resultobj;
7222 fail:
7223  {
7224  Py_DECREF( tmp1 );
7225  }
7226  {
7227  Py_DECREF( tmp2 );
7228  }
7229  {
7230  Py_DECREF( tmp3 );
7231  }
7232  {
7233  Py_DECREF( tmp5 );
7234  }
7235  {
7236  Py_DECREF( tmp7 );
7237  free( arg9 );
7238  }
7239  return NULL;
7240 }
7241 
7242 
7243 SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7244  PyObject *resultobj = 0;
7245  PLFLT *arg1 = (PLFLT *) 0 ;
7246  PLFLT *arg2 = (PLFLT *) 0 ;
7247  PLFLT *arg3 = (PLFLT *) 0 ;
7248  PLFLT *arg4 = (PLFLT *) 0 ;
7249  PLFLT temp1 ;
7250  int res1 = SWIG_TMPOBJ ;
7251  PLFLT temp2 ;
7252  int res2 = SWIG_TMPOBJ ;
7253  PLFLT temp3 ;
7254  int res3 = SWIG_TMPOBJ ;
7255  PLFLT temp4 ;
7256  int res4 = SWIG_TMPOBJ ;
7257 
7258  arg1 = &temp1;
7259  arg2 = &temp2;
7260  arg3 = &temp3;
7261  arg4 = &temp4;
7262  if (!PyArg_ParseTuple(args,(char *)":plgspa")) SWIG_fail;
7263  plgspa(arg1,arg2,arg3,arg4);
7264  resultobj = SWIG_Py_Void();
7265  if (SWIG_IsTmpObj(res1)) {
7266  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7267  } else {
7268  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7269  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7270  }
7271  if (SWIG_IsTmpObj(res2)) {
7272  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7273  } else {
7274  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7275  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7276  }
7277  if (SWIG_IsTmpObj(res3)) {
7278  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7279  } else {
7280  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7281  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7282  }
7283  if (SWIG_IsTmpObj(res4)) {
7284  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7285  } else {
7286  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7287  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7288  }
7289  return resultobj;
7290 fail:
7291  return NULL;
7292 }
7293 
7294 
7295 SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7296  PyObject *resultobj = 0;
7297  PLINT *arg1 = (PLINT *) 0 ;
7298  PLINT temp1 ;
7299  int res1 = SWIG_TMPOBJ ;
7300 
7301  arg1 = &temp1;
7302  if (!PyArg_ParseTuple(args,(char *)":plgstrm")) SWIG_fail;
7303  plgstrm(arg1);
7304  resultobj = SWIG_Py_Void();
7305  if (SWIG_IsTmpObj(res1)) {
7306  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7307  } else {
7308  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7309  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7310  }
7311  return resultobj;
7312 fail:
7313  return NULL;
7314 }
7315 
7316 
7317 SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7318  PyObject *resultobj = 0;
7319  char *arg1 = (char *) 0 ;
7320  char buff1[1000] ;
7321 
7322  {
7323  arg1 = buff1;
7324  }
7325  if (!PyArg_ParseTuple(args,(char *)":plgver")) SWIG_fail;
7326  plgver(arg1);
7327  resultobj = SWIG_Py_Void();
7328  {
7329  PyObject *o = PyString_FromString( arg1 );
7330  resultobj = t_output_helper( resultobj, o );
7331  }
7332  return resultobj;
7333 fail:
7334  return NULL;
7335 }
7336 
7337 
7338 SWIGINTERN PyObject *_wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7339  PyObject *resultobj = 0;
7340  PLFLT *arg1 = (PLFLT *) 0 ;
7341  PLFLT *arg2 = (PLFLT *) 0 ;
7342  PLFLT *arg3 = (PLFLT *) 0 ;
7343  PLFLT *arg4 = (PLFLT *) 0 ;
7344  PLFLT temp1 ;
7345  int res1 = SWIG_TMPOBJ ;
7346  PLFLT temp2 ;
7347  int res2 = SWIG_TMPOBJ ;
7348  PLFLT temp3 ;
7349  int res3 = SWIG_TMPOBJ ;
7350  PLFLT temp4 ;
7351  int res4 = SWIG_TMPOBJ ;
7352 
7353  arg1 = &temp1;
7354  arg2 = &temp2;
7355  arg3 = &temp3;
7356  arg4 = &temp4;
7357  if (!PyArg_ParseTuple(args,(char *)":plgvpd")) SWIG_fail;
7358  plgvpd(arg1,arg2,arg3,arg4);
7359  resultobj = SWIG_Py_Void();
7360  if (SWIG_IsTmpObj(res1)) {
7361  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7362  } else {
7363  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7364  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7365  }
7366  if (SWIG_IsTmpObj(res2)) {
7367  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7368  } else {
7369  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7370  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7371  }
7372  if (SWIG_IsTmpObj(res3)) {
7373  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7374  } else {
7375  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7376  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7377  }
7378  if (SWIG_IsTmpObj(res4)) {
7379  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7380  } else {
7381  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7382  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7383  }
7384  return resultobj;
7385 fail:
7386  return NULL;
7387 }
7388 
7389 
7390 SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7391  PyObject *resultobj = 0;
7392  PLFLT *arg1 = (PLFLT *) 0 ;
7393  PLFLT *arg2 = (PLFLT *) 0 ;
7394  PLFLT *arg3 = (PLFLT *) 0 ;
7395  PLFLT *arg4 = (PLFLT *) 0 ;
7396  PLFLT temp1 ;
7397  int res1 = SWIG_TMPOBJ ;
7398  PLFLT temp2 ;
7399  int res2 = SWIG_TMPOBJ ;
7400  PLFLT temp3 ;
7401  int res3 = SWIG_TMPOBJ ;
7402  PLFLT temp4 ;
7403  int res4 = SWIG_TMPOBJ ;
7404 
7405  arg1 = &temp1;
7406  arg2 = &temp2;
7407  arg3 = &temp3;
7408  arg4 = &temp4;
7409  if (!PyArg_ParseTuple(args,(char *)":plgvpw")) SWIG_fail;
7410  plgvpw(arg1,arg2,arg3,arg4);
7411  resultobj = SWIG_Py_Void();
7412  if (SWIG_IsTmpObj(res1)) {
7413  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7414  } else {
7415  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7416  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7417  }
7418  if (SWIG_IsTmpObj(res2)) {
7419  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7420  } else {
7421  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7422  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7423  }
7424  if (SWIG_IsTmpObj(res3)) {
7425  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7426  } else {
7427  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7428  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7429  }
7430  if (SWIG_IsTmpObj(res4)) {
7431  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7432  } else {
7433  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7434  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7435  }
7436  return resultobj;
7437 fail:
7438  return NULL;
7439 }
7440 
7441 
7442 SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7443  PyObject *resultobj = 0;
7444  PLINT *arg1 = (PLINT *) 0 ;
7445  PLINT *arg2 = (PLINT *) 0 ;
7446  PLINT temp1 ;
7447  int res1 = SWIG_TMPOBJ ;
7448  PLINT temp2 ;
7449  int res2 = SWIG_TMPOBJ ;
7450 
7451  arg1 = &temp1;
7452  arg2 = &temp2;
7453  if (!PyArg_ParseTuple(args,(char *)":plgxax")) SWIG_fail;
7454  plgxax(arg1,arg2);
7455  resultobj = SWIG_Py_Void();
7456  if (SWIG_IsTmpObj(res1)) {
7457  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7458  } else {
7459  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7460  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7461  }
7462  if (SWIG_IsTmpObj(res2)) {
7463  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7464  } else {
7465  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7466  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7467  }
7468  return resultobj;
7469 fail:
7470  return NULL;
7471 }
7472 
7473 
7474 SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7475  PyObject *resultobj = 0;
7476  PLINT *arg1 = (PLINT *) 0 ;
7477  PLINT *arg2 = (PLINT *) 0 ;
7478  PLINT temp1 ;
7479  int res1 = SWIG_TMPOBJ ;
7480  PLINT temp2 ;
7481  int res2 = SWIG_TMPOBJ ;
7482 
7483  arg1 = &temp1;
7484  arg2 = &temp2;
7485  if (!PyArg_ParseTuple(args,(char *)":plgyax")) SWIG_fail;
7486  plgyax(arg1,arg2);
7487  resultobj = SWIG_Py_Void();
7488  if (SWIG_IsTmpObj(res1)) {
7489  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7490  } else {
7491  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7492  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7493  }
7494  if (SWIG_IsTmpObj(res2)) {
7495  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7496  } else {
7497  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7498  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7499  }
7500  return resultobj;
7501 fail:
7502  return NULL;
7503 }
7504 
7505 
7506 SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7507  PyObject *resultobj = 0;
7508  PLINT *arg1 = (PLINT *) 0 ;
7509  PLINT *arg2 = (PLINT *) 0 ;
7510  PLINT temp1 ;
7511  int res1 = SWIG_TMPOBJ ;
7512  PLINT temp2 ;
7513  int res2 = SWIG_TMPOBJ ;
7514 
7515  arg1 = &temp1;
7516  arg2 = &temp2;
7517  if (!PyArg_ParseTuple(args,(char *)":plgzax")) SWIG_fail;
7518  plgzax(arg1,arg2);
7519  resultobj = SWIG_Py_Void();
7520  if (SWIG_IsTmpObj(res1)) {
7521  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7522  } else {
7523  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7524  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7525  }
7526  if (SWIG_IsTmpObj(res2)) {
7527  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7528  } else {
7529  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7530  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7531  }
7532  return resultobj;
7533 fail:
7534  return NULL;
7535 }
7536 
7537 
7538 SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7539  PyObject *resultobj = 0;
7540  PLINT arg1 ;
7541  PLFLT *arg2 = (PLFLT *) 0 ;
7542  PLFLT arg3 ;
7543  PLFLT arg4 ;
7544  PLINT arg5 ;
7545  PLINT arg6 ;
7546  PyArrayObject *tmp1 ;
7547  double val3 ;
7548  int ecode3 = 0 ;
7549  double val4 ;
7550  int ecode4 = 0 ;
7551  int val5 ;
7552  int ecode5 = 0 ;
7553  int val6 ;
7554  int ecode6 = 0 ;
7555  PyObject * obj0 = 0 ;
7556  PyObject * obj1 = 0 ;
7557  PyObject * obj2 = 0 ;
7558  PyObject * obj3 = 0 ;
7559  PyObject * obj4 = 0 ;
7560 
7561  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7562  {
7563  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7564  if ( tmp1 == NULL )
7565  return NULL;
7566  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7567  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7568  }
7569  ecode3 = SWIG_AsVal_double(obj1, &val3);
7570  if (!SWIG_IsOK(ecode3)) {
7571  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7572  }
7573  arg3 = (PLFLT)(val3);
7574  ecode4 = SWIG_AsVal_double(obj2, &val4);
7575  if (!SWIG_IsOK(ecode4)) {
7576  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7577  }
7578  arg4 = (PLFLT)(val4);
7579  ecode5 = SWIG_AsVal_int(obj3, &val5);
7580  if (!SWIG_IsOK(ecode5)) {
7581  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7582  }
7583  arg5 = (PLINT)(val5);
7584  ecode6 = SWIG_AsVal_int(obj4, &val6);
7585  if (!SWIG_IsOK(ecode6)) {
7586  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7587  }
7588  arg6 = (PLINT)(val6);
7589  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7590  resultobj = SWIG_Py_Void();
7591  {
7592  Py_DECREF( tmp1 );
7593  }
7594  return resultobj;
7595 fail:
7596  {
7597  Py_DECREF( tmp1 );
7598  }
7599  return NULL;
7600 }
7601 
7602 
7603 SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7604  PyObject *resultobj = 0;
7605  PLFLT arg1 ;
7606  PLFLT arg2 ;
7607  PLFLT arg3 ;
7608  PLFLT *arg4 = (PLFLT *) 0 ;
7609  PLFLT *arg5 = (PLFLT *) 0 ;
7610  PLFLT *arg6 = (PLFLT *) 0 ;
7611  double val1 ;
7612  int ecode1 = 0 ;
7613  double val2 ;
7614  int ecode2 = 0 ;
7615  double val3 ;
7616  int ecode3 = 0 ;
7617  PLFLT temp4 ;
7618  int res4 = SWIG_TMPOBJ ;
7619  PLFLT temp5 ;
7620  int res5 = SWIG_TMPOBJ ;
7621  PLFLT temp6 ;
7622  int res6 = SWIG_TMPOBJ ;
7623  PyObject * obj0 = 0 ;
7624  PyObject * obj1 = 0 ;
7625  PyObject * obj2 = 0 ;
7626 
7627  arg4 = &temp4;
7628  arg5 = &temp5;
7629  arg6 = &temp6;
7630  if (!PyArg_ParseTuple(args,(char *)"OOO:plhlsrgb",&obj0,&obj1,&obj2)) SWIG_fail;
7631  ecode1 = SWIG_AsVal_double(obj0, &val1);
7632  if (!SWIG_IsOK(ecode1)) {
7633  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7634  }
7635  arg1 = (PLFLT)(val1);
7636  ecode2 = SWIG_AsVal_double(obj1, &val2);
7637  if (!SWIG_IsOK(ecode2)) {
7638  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7639  }
7640  arg2 = (PLFLT)(val2);
7641  ecode3 = SWIG_AsVal_double(obj2, &val3);
7642  if (!SWIG_IsOK(ecode3)) {
7643  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7644  }
7645  arg3 = (PLFLT)(val3);
7646  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7647  resultobj = SWIG_Py_Void();
7648  if (SWIG_IsTmpObj(res4)) {
7649  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7650  } else {
7651  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7652  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7653  }
7654  if (SWIG_IsTmpObj(res5)) {
7655  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7656  } else {
7657  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7658  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7659  }
7660  if (SWIG_IsTmpObj(res6)) {
7661  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7662  } else {
7663  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7664  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7665  }
7666  return resultobj;
7667 fail:
7668  return NULL;
7669 }
7670 
7671 
7672 SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7673  PyObject *resultobj = 0;
7674 
7675  if (!PyArg_ParseTuple(args,(char *)":plinit")) SWIG_fail;
7676  plinit();
7677  resultobj = SWIG_Py_Void();
7678  return resultobj;
7679 fail:
7680  return NULL;
7681 }
7682 
7683 
7684 SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7685  PyObject *resultobj = 0;
7686  PLFLT arg1 ;
7687  PLFLT arg2 ;
7688  PLFLT arg3 ;
7689  PLFLT arg4 ;
7690  double val1 ;
7691  int ecode1 = 0 ;
7692  double val2 ;
7693  int ecode2 = 0 ;
7694  double val3 ;
7695  int ecode3 = 0 ;
7696  double val4 ;
7697  int ecode4 = 0 ;
7698  PyObject * obj0 = 0 ;
7699  PyObject * obj1 = 0 ;
7700  PyObject * obj2 = 0 ;
7701  PyObject * obj3 = 0 ;
7702 
7703  if (!PyArg_ParseTuple(args,(char *)"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7704  ecode1 = SWIG_AsVal_double(obj0, &val1);
7705  if (!SWIG_IsOK(ecode1)) {
7706  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
7707  }
7708  arg1 = (PLFLT)(val1);
7709  ecode2 = SWIG_AsVal_double(obj1, &val2);
7710  if (!SWIG_IsOK(ecode2)) {
7711  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
7712  }
7713  arg2 = (PLFLT)(val2);
7714  ecode3 = SWIG_AsVal_double(obj2, &val3);
7715  if (!SWIG_IsOK(ecode3)) {
7716  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
7717  }
7718  arg3 = (PLFLT)(val3);
7719  ecode4 = SWIG_AsVal_double(obj3, &val4);
7720  if (!SWIG_IsOK(ecode4)) {
7721  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
7722  }
7723  arg4 = (PLFLT)(val4);
7724  pljoin(arg1,arg2,arg3,arg4);
7725  resultobj = SWIG_Py_Void();
7726  return resultobj;
7727 fail:
7728  return NULL;
7729 }
7730 
7731 
7732 SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7733  PyObject *resultobj = 0;
7734  char *arg1 = (char *) 0 ;
7735  char *arg2 = (char *) 0 ;
7736  char *arg3 = (char *) 0 ;
7737  int res1 ;
7738  char *buf1 = 0 ;
7739  int alloc1 = 0 ;
7740  int res2 ;
7741  char *buf2 = 0 ;
7742  int alloc2 = 0 ;
7743  int res3 ;
7744  char *buf3 = 0 ;
7745  int alloc3 = 0 ;
7746  PyObject * obj0 = 0 ;
7747  PyObject * obj1 = 0 ;
7748  PyObject * obj2 = 0 ;
7749 
7750  if (!PyArg_ParseTuple(args,(char *)"OOO:pllab",&obj0,&obj1,&obj2)) SWIG_fail;
7751  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
7752  if (!SWIG_IsOK(res1)) {
7753  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
7754  }
7755  arg1 = (char *)(buf1);
7756  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7757  if (!SWIG_IsOK(res2)) {
7758  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
7759  }
7760  arg2 = (char *)(buf2);
7761  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
7762  if (!SWIG_IsOK(res3)) {
7763  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
7764  }
7765  arg3 = (char *)(buf3);
7766  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
7767  resultobj = SWIG_Py_Void();
7768  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7769  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7770  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7771  return resultobj;
7772 fail:
7773  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7774  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7775  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7776  return NULL;
7777 }
7778 
7779 
7780 SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7781  PyObject *resultobj = 0;
7782  PLFLT *arg1 = (PLFLT *) 0 ;
7783  PLFLT *arg2 = (PLFLT *) 0 ;
7784  PLINT arg3 ;
7785  PLINT arg4 ;
7786  PLFLT arg5 ;
7787  PLFLT arg6 ;
7788  PLFLT arg7 ;
7789  PLINT arg8 ;
7790  PLINT arg9 ;
7791  PLINT arg10 ;
7792  PLINT arg11 ;
7793  PLINT arg12 ;
7794  PLINT arg13 ;
7795  PLINT *arg14 = (PLINT *) 0 ;
7796  PLFLT arg15 ;
7797  PLFLT arg16 ;
7798  PLFLT arg17 ;
7799  PLFLT arg18 ;
7800  PLINT *arg19 = (PLINT *) 0 ;
7801  char **arg20 = (char **) 0 ;
7802  PLINT *arg21 = (PLINT *) 0 ;
7803  PLINT *arg22 = (PLINT *) 0 ;
7804  PLFLT *arg23 = (PLFLT *) 0 ;
7805  PLFLT *arg24 = (PLFLT *) 0 ;
7806  PLINT *arg25 = (PLINT *) 0 ;
7807  PLINT *arg26 = (PLINT *) 0 ;
7808  PLFLT *arg27 = (PLFLT *) 0 ;
7809  PLINT *arg28 = (PLINT *) 0 ;
7810  PLFLT *arg29 = (PLFLT *) 0 ;
7811  PLINT *arg30 = (PLINT *) 0 ;
7812  char **arg31 = (char **) 0 ;
7813  PLFLT temp1 ;
7814  int res1 = SWIG_TMPOBJ ;
7815  PLFLT temp2 ;
7816  int res2 = SWIG_TMPOBJ ;
7817  int val3 ;
7818  int ecode3 = 0 ;
7819  int val4 ;
7820  int ecode4 = 0 ;
7821  double val5 ;
7822  int ecode5 = 0 ;
7823  double val6 ;
7824  int ecode6 = 0 ;
7825  double val7 ;
7826  int ecode7 = 0 ;
7827  int val8 ;
7828  int ecode8 = 0 ;
7829  int val9 ;
7830  int ecode9 = 0 ;
7831  int val10 ;
7832  int ecode10 = 0 ;
7833  int val11 ;
7834  int ecode11 = 0 ;
7835  int val12 ;
7836  int ecode12 = 0 ;
7837  PyArrayObject *tmp13 ;
7838  double val15 ;
7839  int ecode15 = 0 ;
7840  double val16 ;
7841  int ecode16 = 0 ;
7842  double val17 ;
7843  int ecode17 = 0 ;
7844  double val18 ;
7845  int ecode18 = 0 ;
7846  PyArrayObject *tmp19 ;
7847  PyArrayObject *tmp20 ;
7848  PyArrayObject *tmp21 ;
7849  PyArrayObject *tmp22 ;
7850  PyArrayObject *tmp23 ;
7851  PyArrayObject *tmp24 ;
7852  PyArrayObject *tmp25 ;
7853  PyArrayObject *tmp26 ;
7854  PyArrayObject *tmp27 ;
7855  PyArrayObject *tmp28 ;
7856  PyArrayObject *tmp29 ;
7857  PyArrayObject *tmp30 ;
7858  PyArrayObject *tmp31 ;
7859  PyObject * obj0 = 0 ;
7860  PyObject * obj1 = 0 ;
7861  PyObject * obj2 = 0 ;
7862  PyObject * obj3 = 0 ;
7863  PyObject * obj4 = 0 ;
7864  PyObject * obj5 = 0 ;
7865  PyObject * obj6 = 0 ;
7866  PyObject * obj7 = 0 ;
7867  PyObject * obj8 = 0 ;
7868  PyObject * obj9 = 0 ;
7869  PyObject * obj10 = 0 ;
7870  PyObject * obj11 = 0 ;
7871  PyObject * obj12 = 0 ;
7872  PyObject * obj13 = 0 ;
7873  PyObject * obj14 = 0 ;
7874  PyObject * obj15 = 0 ;
7875  PyObject * obj16 = 0 ;
7876  PyObject * obj17 = 0 ;
7877  PyObject * obj18 = 0 ;
7878  PyObject * obj19 = 0 ;
7879  PyObject * obj20 = 0 ;
7880  PyObject * obj21 = 0 ;
7881  PyObject * obj22 = 0 ;
7882  PyObject * obj23 = 0 ;
7883  PyObject * obj24 = 0 ;
7884  PyObject * obj25 = 0 ;
7885  PyObject * obj26 = 0 ;
7886  PyObject * obj27 = 0 ;
7887 
7888  arg1 = &temp1;
7889  arg2 = &temp2;
7890  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOO:pllegend",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27)) SWIG_fail;
7891  ecode3 = SWIG_AsVal_int(obj0, &val3);
7892  if (!SWIG_IsOK(ecode3)) {
7893  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
7894  }
7895  arg3 = (PLINT)(val3);
7896  ecode4 = SWIG_AsVal_int(obj1, &val4);
7897  if (!SWIG_IsOK(ecode4)) {
7898  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
7899  }
7900  arg4 = (PLINT)(val4);
7901  ecode5 = SWIG_AsVal_double(obj2, &val5);
7902  if (!SWIG_IsOK(ecode5)) {
7903  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
7904  }
7905  arg5 = (PLFLT)(val5);
7906  ecode6 = SWIG_AsVal_double(obj3, &val6);
7907  if (!SWIG_IsOK(ecode6)) {
7908  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
7909  }
7910  arg6 = (PLFLT)(val6);
7911  ecode7 = SWIG_AsVal_double(obj4, &val7);
7912  if (!SWIG_IsOK(ecode7)) {
7913  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
7914  }
7915  arg7 = (PLFLT)(val7);
7916  ecode8 = SWIG_AsVal_int(obj5, &val8);
7917  if (!SWIG_IsOK(ecode8)) {
7918  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
7919  }
7920  arg8 = (PLINT)(val8);
7921  ecode9 = SWIG_AsVal_int(obj6, &val9);
7922  if (!SWIG_IsOK(ecode9)) {
7923  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
7924  }
7925  arg9 = (PLINT)(val9);
7926  ecode10 = SWIG_AsVal_int(obj7, &val10);
7927  if (!SWIG_IsOK(ecode10)) {
7928  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
7929  }
7930  arg10 = (PLINT)(val10);
7931  ecode11 = SWIG_AsVal_int(obj8, &val11);
7932  if (!SWIG_IsOK(ecode11)) {
7933  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
7934  }
7935  arg11 = (PLINT)(val11);
7936  ecode12 = SWIG_AsVal_int(obj9, &val12);
7937  if (!SWIG_IsOK(ecode12)) {
7938  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
7939  }
7940  arg12 = (PLINT)(val12);
7941  {
7942  tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj10, NPY_PLINT, 1, 1 );
7943  if ( tmp13 == NULL )
7944  return NULL;
7945  arg13 = Alen = PyArray_DIMS( tmp13 )[0];
7946  arg14 = (PLINT *) PyArray_DATA( tmp13 );
7947  }
7948  ecode15 = SWIG_AsVal_double(obj11, &val15);
7949  if (!SWIG_IsOK(ecode15)) {
7950  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
7951  }
7952  arg15 = (PLFLT)(val15);
7953  ecode16 = SWIG_AsVal_double(obj12, &val16);
7954  if (!SWIG_IsOK(ecode16)) {
7955  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
7956  }
7957  arg16 = (PLFLT)(val16);
7958  ecode17 = SWIG_AsVal_double(obj13, &val17);
7959  if (!SWIG_IsOK(ecode17)) {
7960  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
7961  }
7962  arg17 = (PLFLT)(val17);
7963  ecode18 = SWIG_AsVal_double(obj14, &val18);
7964  if (!SWIG_IsOK(ecode18)) {
7965  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
7966  }
7967  arg18 = (PLFLT)(val18);
7968  {
7969  tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj15, NPY_PLINT, 1, 1 );
7970  if ( tmp19 == NULL )
7971  return NULL;
7972  if ( PyArray_DIMS( tmp19 )[0] != Alen )
7973  {
7974  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7975  return NULL;
7976  }
7977  arg19 = (PLINT *) PyArray_DATA( tmp19 );
7978  }
7979  {
7980  int i;
7981  tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 );
7982  if ( tmp20 == NULL )
7983  return NULL;
7984  if ( PyArray_DIMS( tmp20 )[0] != Alen )
7985  {
7986  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7987  return NULL;
7988  }
7989  arg20 = (char **) malloc( sizeof ( char* ) * Alen );
7990  for ( i = 0; i < Alen; i++ )
7991  {
7992  arg20[i] = PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
7993  if ( arg20[i] == NULL )
7994  {
7995  free( arg20 );
7996  return NULL;
7997  }
7998  }
7999  }
8000  {
8001  tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
8002  if ( tmp21 == NULL )
8003  return NULL;
8004  if ( PyArray_DIMS( tmp21 )[0] != Alen )
8005  {
8006  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8007  return NULL;
8008  }
8009  arg21 = (PLINT *) PyArray_DATA( tmp21 );
8010  }
8011  {
8012  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
8013  if ( tmp22 == NULL )
8014  return NULL;
8015  if ( PyArray_DIMS( tmp22 )[0] != Alen )
8016  {
8017  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8018  return NULL;
8019  }
8020  arg22 = (PLINT *) PyArray_DATA( tmp22 );
8021  }
8022  {
8023  tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 1, 1 );
8024  if ( tmp23 == NULL )
8025  return NULL;
8026  if ( PyArray_DIMS( tmp23 )[0] != Alen )
8027  {
8028  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8029  return NULL;
8030  }
8031  arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8032  }
8033  {
8034  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj20, NPY_PLFLT, 1, 1 );
8035  if ( tmp24 == NULL )
8036  return NULL;
8037  if ( PyArray_DIMS( tmp24 )[0] != Alen )
8038  {
8039  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8040  return NULL;
8041  }
8042  arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8043  }
8044  {
8045  tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj21, NPY_PLINT, 1, 1 );
8046  if ( tmp25 == NULL )
8047  return NULL;
8048  if ( PyArray_DIMS( tmp25 )[0] != Alen )
8049  {
8050  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8051  return NULL;
8052  }
8053  arg25 = (PLINT *) PyArray_DATA( tmp25 );
8054  }
8055  {
8056  tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj22, NPY_PLINT, 1, 1 );
8057  if ( tmp26 == NULL )
8058  return NULL;
8059  if ( PyArray_DIMS( tmp26 )[0] != Alen )
8060  {
8061  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8062  return NULL;
8063  }
8064  arg26 = (PLINT *) PyArray_DATA( tmp26 );
8065  }
8066  {
8067  tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( obj23, NPY_PLFLT, 1, 1 );
8068  if ( tmp27 == NULL )
8069  return NULL;
8070  if ( PyArray_DIMS( tmp27 )[0] != Alen )
8071  {
8072  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8073  return NULL;
8074  }
8075  arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8076  }
8077  {
8078  tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj24, NPY_PLINT, 1, 1 );
8079  if ( tmp28 == NULL )
8080  return NULL;
8081  if ( PyArray_DIMS( tmp28 )[0] != Alen )
8082  {
8083  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8084  return NULL;
8085  }
8086  arg28 = (PLINT *) PyArray_DATA( tmp28 );
8087  }
8088  {
8089  tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( obj25, NPY_PLFLT, 1, 1 );
8090  if ( tmp29 == NULL )
8091  return NULL;
8092  if ( PyArray_DIMS( tmp29 )[0] != Alen )
8093  {
8094  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8095  return NULL;
8096  }
8097  arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8098  }
8099  {
8100  tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj26, NPY_PLINT, 1, 1 );
8101  if ( tmp30 == NULL )
8102  return NULL;
8103  if ( PyArray_DIMS( tmp30 )[0] != Alen )
8104  {
8105  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8106  return NULL;
8107  }
8108  arg30 = (PLINT *) PyArray_DATA( tmp30 );
8109  }
8110  {
8111  int i;
8112  tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 );
8113  if ( tmp31 == NULL )
8114  return NULL;
8115  if ( PyArray_DIMS( tmp31 )[0] != Alen )
8116  {
8117  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8118  return NULL;
8119  }
8120  arg31 = (char **) malloc( sizeof ( char* ) * Alen );
8121  for ( i = 0; i < Alen; i++ )
8122  {
8123  arg31[i] = PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8124  if ( arg31[i] == NULL )
8125  {
8126  free( arg31 );
8127  return NULL;
8128  }
8129  }
8130  }
8131  pllegend(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(int const *)arg14,arg15,arg16,arg17,arg18,(int const *)arg19,(char const **)arg20,(int const *)arg21,(int const *)arg22,(double const *)arg23,(double const *)arg24,(int const *)arg25,(int const *)arg26,(double const *)arg27,(int const *)arg28,(double const *)arg29,(int const *)arg30,(char const **)arg31);
8132  resultobj = SWIG_Py_Void();
8133  if (SWIG_IsTmpObj(res1)) {
8134  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8135  } else {
8136  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8137  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8138  }
8139  if (SWIG_IsTmpObj(res2)) {
8140  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8141  } else {
8142  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8143  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8144  }
8145  {
8146  Py_DECREF( tmp13 );
8147  }
8148  {
8149  Py_DECREF( tmp19 );
8150  }
8151  {
8152  Py_DECREF( tmp20 ); free( arg20 );
8153  }
8154  {
8155  Py_DECREF( tmp21 );
8156  }
8157  {
8158  Py_DECREF( tmp22 );
8159  }
8160  {
8161  Py_DECREF( tmp23 );
8162  }
8163  {
8164  Py_DECREF( tmp24 );
8165  }
8166  {
8167  Py_DECREF( tmp25 );
8168  }
8169  {
8170  Py_DECREF( tmp26 );
8171  }
8172  {
8173  Py_DECREF( tmp27 );
8174  }
8175  {
8176  Py_DECREF( tmp28 );
8177  }
8178  {
8179  Py_DECREF( tmp29 );
8180  }
8181  {
8182  Py_DECREF( tmp30 );
8183  }
8184  {
8185  Py_DECREF( tmp31 ); free( arg31 );
8186  }
8187  return resultobj;
8188 fail:
8189  {
8190  Py_DECREF( tmp13 );
8191  }
8192  {
8193  Py_DECREF( tmp19 );
8194  }
8195  {
8196  Py_DECREF( tmp20 ); free( arg20 );
8197  }
8198  {
8199  Py_DECREF( tmp21 );
8200  }
8201  {
8202  Py_DECREF( tmp22 );
8203  }
8204  {
8205  Py_DECREF( tmp23 );
8206  }
8207  {
8208  Py_DECREF( tmp24 );
8209  }
8210  {
8211  Py_DECREF( tmp25 );
8212  }
8213  {
8214  Py_DECREF( tmp26 );
8215  }
8216  {
8217  Py_DECREF( tmp27 );
8218  }
8219  {
8220  Py_DECREF( tmp28 );
8221  }
8222  {
8223  Py_DECREF( tmp29 );
8224  }
8225  {
8226  Py_DECREF( tmp30 );
8227  }
8228  {
8229  Py_DECREF( tmp31 ); free( arg31 );
8230  }
8231  return NULL;
8232 }
8233 
8234 
8235 SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8236  PyObject *resultobj = 0;
8237  PLFLT *arg1 = (PLFLT *) 0 ;
8238  PLFLT *arg2 = (PLFLT *) 0 ;
8239  PLINT arg3 ;
8240  PLINT arg4 ;
8241  PLFLT arg5 ;
8242  PLFLT arg6 ;
8243  PLFLT arg7 ;
8244  PLFLT arg8 ;
8245  PLINT arg9 ;
8246  PLINT arg10 ;
8247  PLINT arg11 ;
8248  PLFLT arg12 ;
8249  PLFLT arg13 ;
8250  PLINT arg14 ;
8251  PLFLT arg15 ;
8252  PLINT arg16 ;
8253  PLINT *arg17 = (PLINT *) 0 ;
8254  char **arg18 = (char **) 0 ;
8255  PLINT arg19 ;
8256  char **arg20 = (char **) 0 ;
8257  PLFLT *arg21 = (PLFLT *) 0 ;
8258  PLINT *arg22 = (PLINT *) 0 ;
8259  PLINT *arg23 = (PLINT *) 0 ;
8260  PLFLT **arg24 = (PLFLT **) 0 ;
8261  PLFLT temp1 ;
8262  int res1 = SWIG_TMPOBJ ;
8263  PLFLT temp2 ;
8264  int res2 = SWIG_TMPOBJ ;
8265  int val3 ;
8266  int ecode3 = 0 ;
8267  int val4 ;
8268  int ecode4 = 0 ;
8269  double val5 ;
8270  int ecode5 = 0 ;
8271  double val6 ;
8272  int ecode6 = 0 ;
8273  double val7 ;
8274  int ecode7 = 0 ;
8275  double val8 ;
8276  int ecode8 = 0 ;
8277  int val9 ;
8278  int ecode9 = 0 ;
8279  int val10 ;
8280  int ecode10 = 0 ;
8281  int val11 ;
8282  int ecode11 = 0 ;
8283  double val12 ;
8284  int ecode12 = 0 ;
8285  double val13 ;
8286  int ecode13 = 0 ;
8287  int val14 ;
8288  int ecode14 = 0 ;
8289  double val15 ;
8290  int ecode15 = 0 ;
8291  PyArrayObject *tmp16 ;
8292  PyArrayObject *tmp18 ;
8293  PyArrayObject *tmp19 ;
8294  PyArrayObject *tmp21 ;
8295  PyArrayObject *tmp22 ;
8296  PyArrayObject *tmp23 ;
8297  PyArrayObject *tmp24 ;
8298  PyObject * obj0 = 0 ;
8299  PyObject * obj1 = 0 ;
8300  PyObject * obj2 = 0 ;
8301  PyObject * obj3 = 0 ;
8302  PyObject * obj4 = 0 ;
8303  PyObject * obj5 = 0 ;
8304  PyObject * obj6 = 0 ;
8305  PyObject * obj7 = 0 ;
8306  PyObject * obj8 = 0 ;
8307  PyObject * obj9 = 0 ;
8308  PyObject * obj10 = 0 ;
8309  PyObject * obj11 = 0 ;
8310  PyObject * obj12 = 0 ;
8311  PyObject * obj13 = 0 ;
8312  PyObject * obj14 = 0 ;
8313  PyObject * obj15 = 0 ;
8314  PyObject * obj16 = 0 ;
8315  PyObject * obj17 = 0 ;
8316  PyObject * obj18 = 0 ;
8317  PyObject * obj19 = 0 ;
8318 
8319  arg1 = &temp1;
8320  arg2 = &temp2;
8321  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:plcolorbar",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
8322  ecode3 = SWIG_AsVal_int(obj0, &val3);
8323  if (!SWIG_IsOK(ecode3)) {
8324  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8325  }
8326  arg3 = (PLINT)(val3);
8327  ecode4 = SWIG_AsVal_int(obj1, &val4);
8328  if (!SWIG_IsOK(ecode4)) {
8329  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8330  }
8331  arg4 = (PLINT)(val4);
8332  ecode5 = SWIG_AsVal_double(obj2, &val5);
8333  if (!SWIG_IsOK(ecode5)) {
8334  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8335  }
8336  arg5 = (PLFLT)(val5);
8337  ecode6 = SWIG_AsVal_double(obj3, &val6);
8338  if (!SWIG_IsOK(ecode6)) {
8339  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8340  }
8341  arg6 = (PLFLT)(val6);
8342  ecode7 = SWIG_AsVal_double(obj4, &val7);
8343  if (!SWIG_IsOK(ecode7)) {
8344  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8345  }
8346  arg7 = (PLFLT)(val7);
8347  ecode8 = SWIG_AsVal_double(obj5, &val8);
8348  if (!SWIG_IsOK(ecode8)) {
8349  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8350  }
8351  arg8 = (PLFLT)(val8);
8352  ecode9 = SWIG_AsVal_int(obj6, &val9);
8353  if (!SWIG_IsOK(ecode9)) {
8354  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8355  }
8356  arg9 = (PLINT)(val9);
8357  ecode10 = SWIG_AsVal_int(obj7, &val10);
8358  if (!SWIG_IsOK(ecode10)) {
8359  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8360  }
8361  arg10 = (PLINT)(val10);
8362  ecode11 = SWIG_AsVal_int(obj8, &val11);
8363  if (!SWIG_IsOK(ecode11)) {
8364  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8365  }
8366  arg11 = (PLINT)(val11);
8367  ecode12 = SWIG_AsVal_double(obj9, &val12);
8368  if (!SWIG_IsOK(ecode12)) {
8369  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8370  }
8371  arg12 = (PLFLT)(val12);
8372  ecode13 = SWIG_AsVal_double(obj10, &val13);
8373  if (!SWIG_IsOK(ecode13)) {
8374  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8375  }
8376  arg13 = (PLFLT)(val13);
8377  ecode14 = SWIG_AsVal_int(obj11, &val14);
8378  if (!SWIG_IsOK(ecode14)) {
8379  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8380  }
8381  arg14 = (PLINT)(val14);
8382  ecode15 = SWIG_AsVal_double(obj12, &val15);
8383  if (!SWIG_IsOK(ecode15)) {
8384  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8385  }
8386  arg15 = (PLFLT)(val15);
8387  {
8388  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
8389  if ( tmp16 == NULL )
8390  return NULL;
8391  arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8392  arg17 = (PLINT *) PyArray_DATA( tmp16 );
8393  }
8394  {
8395  int i;
8396  tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( obj14, NPY_STRING, 1, 1 );
8397  if ( tmp18 == NULL )
8398  return NULL;
8399  if ( PyArray_DIMS( tmp18 )[0] != Alen )
8400  {
8401  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8402  return NULL;
8403  }
8404  arg18 = (char **) malloc( sizeof ( char* ) * Alen );
8405  for ( i = 0; i < Alen; i++ )
8406  {
8407  arg18[i] = PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8408  if ( arg18[i] == NULL )
8409  {
8410  free( arg18 );
8411  return NULL;
8412  }
8413  }
8414  }
8415  {
8416  int i;
8417  tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( obj15, NPY_STRING, 1, 1 );
8418  if ( tmp19 == NULL )
8419  return NULL;
8420  Alen = PyArray_DIMS( tmp19 )[0];
8421  arg19 = Alen;
8422  arg20 = (char **) malloc( sizeof ( char* ) * Alen );
8423  for ( i = 0; i < Alen; i++ )
8424  {
8425  arg20[i] = PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8426  if ( arg20[i] == NULL )
8427  {
8428  free( arg20 );
8429  return NULL;
8430  }
8431  }
8432  }
8433  {
8434  tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( obj16, NPY_PLFLT, 1, 1 );
8435  if ( tmp21 == NULL )
8436  return NULL;
8437  if ( PyArray_DIMS( tmp21 )[0] != Alen )
8438  {
8439  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8440  return NULL;
8441  }
8442  arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8443  }
8444  {
8445  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
8446  if ( tmp22 == NULL )
8447  return NULL;
8448  if ( PyArray_DIMS( tmp22 )[0] != Alen )
8449  {
8450  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8451  return NULL;
8452  }
8453  arg22 = (PLINT *) PyArray_DATA( tmp22 );
8454  }
8455  {
8456  int i;
8457  tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
8458  if ( tmp23 == NULL )
8459  return NULL;
8460  if ( PyArray_DIMS( tmp23 )[0] != Alen )
8461  {
8462  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8463  return NULL;
8464  }
8465  Xlen = PyArray_DIMS( tmp23 )[0];
8466  arg23 = (PLINT *) PyArray_DATA( tmp23 );
8467  Ylen = -1;
8468  for ( i = 0; i < Xlen; i++ )
8469  if ( arg23[i] > Ylen )
8470  Ylen = arg23[i];
8471  }
8472  {
8473  int i, size;
8474  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 2, 2 );
8475  if ( tmp24 == NULL )
8476  return NULL;
8477  if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8478  {
8479  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8480  return NULL;
8481  }
8482  size = sizeof ( PLFLT ) * Ylen;
8483  arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * Xlen );
8484  for ( i = 0; i < Xlen; i++ )
8485  arg24[i] = (PLFLT *) ( PyArray_DATA( tmp24 ) + i * size );
8486  }
8487  plcolorbar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,(int const *)arg17,(char const **)arg18,arg19,(char const **)arg20,(double const *)arg21,(int const *)arg22,(int const *)arg23,(double const **)arg24);
8488  resultobj = SWIG_Py_Void();
8489  if (SWIG_IsTmpObj(res1)) {
8490  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8491  } else {
8492  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8493  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8494  }
8495  if (SWIG_IsTmpObj(res2)) {
8496  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8497  } else {
8498  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8499  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8500  }
8501  {
8502  Py_DECREF( tmp16 );
8503  }
8504  {
8505  Py_DECREF( tmp18 ); free( arg18 );
8506  }
8507  {
8508  Py_DECREF( tmp19 ); free( arg20 );
8509  }
8510  {
8511  Py_DECREF( tmp21 );
8512  }
8513  {
8514  Py_DECREF( tmp22 );
8515  }
8516  {
8517  Py_DECREF( tmp23 );
8518  }
8519  {
8520  Py_DECREF( tmp24 );
8521  free( arg24 );
8522  }
8523  return resultobj;
8524 fail:
8525  {
8526  Py_DECREF( tmp16 );
8527  }
8528  {
8529  Py_DECREF( tmp18 ); free( arg18 );
8530  }
8531  {
8532  Py_DECREF( tmp19 ); free( arg20 );
8533  }
8534  {
8535  Py_DECREF( tmp21 );
8536  }
8537  {
8538  Py_DECREF( tmp22 );
8539  }
8540  {
8541  Py_DECREF( tmp23 );
8542  }
8543  {
8544  Py_DECREF( tmp24 );
8545  free( arg24 );
8546  }
8547  return NULL;
8548 }
8549 
8550 
8551 SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8552  PyObject *resultobj = 0;
8553  PLFLT arg1 ;
8554  PLFLT arg2 ;
8555  PLFLT arg3 ;
8556  double val1 ;
8557  int ecode1 = 0 ;
8558  double val2 ;
8559  int ecode2 = 0 ;
8560  double val3 ;
8561  int ecode3 = 0 ;
8562  PyObject * obj0 = 0 ;
8563  PyObject * obj1 = 0 ;
8564  PyObject * obj2 = 0 ;
8565 
8566  if (!PyArg_ParseTuple(args,(char *)"OOO:pllightsource",&obj0,&obj1,&obj2)) SWIG_fail;
8567  ecode1 = SWIG_AsVal_double(obj0, &val1);
8568  if (!SWIG_IsOK(ecode1)) {
8569  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8570  }
8571  arg1 = (PLFLT)(val1);
8572  ecode2 = SWIG_AsVal_double(obj1, &val2);
8573  if (!SWIG_IsOK(ecode2)) {
8574  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8575  }
8576  arg2 = (PLFLT)(val2);
8577  ecode3 = SWIG_AsVal_double(obj2, &val3);
8578  if (!SWIG_IsOK(ecode3)) {
8579  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8580  }
8581  arg3 = (PLFLT)(val3);
8582  pllightsource(arg1,arg2,arg3);
8583  resultobj = SWIG_Py_Void();
8584  return resultobj;
8585 fail:
8586  return NULL;
8587 }
8588 
8589 
8590 SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8591  PyObject *resultobj = 0;
8592  PLINT arg1 ;
8593  PLFLT *arg2 = (PLFLT *) 0 ;
8594  PLFLT *arg3 = (PLFLT *) 0 ;
8595  PyArrayObject *tmp1 ;
8596  PyArrayObject *tmp3 ;
8597  PyObject * obj0 = 0 ;
8598  PyObject * obj1 = 0 ;
8599 
8600  if (!PyArg_ParseTuple(args,(char *)"OO:plline",&obj0,&obj1)) SWIG_fail;
8601  {
8602  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8603  if ( tmp1 == NULL )
8604  return NULL;
8605  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8606  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8607  }
8608  {
8609  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8610  if ( tmp3 == NULL )
8611  return NULL;
8612  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8613  {
8614  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8615  return NULL;
8616  }
8617  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8618  }
8619  plline(arg1,(double const *)arg2,(double const *)arg3);
8620  resultobj = SWIG_Py_Void();
8621  {
8622  Py_DECREF( tmp1 );
8623  }
8624  {
8625  Py_DECREF( tmp3 );
8626  }
8627  return resultobj;
8628 fail:
8629  {
8630  Py_DECREF( tmp1 );
8631  }
8632  {
8633  Py_DECREF( tmp3 );
8634  }
8635  return NULL;
8636 }
8637 
8638 
8639 SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8640  PyObject *resultobj = 0;
8641  PLINT arg1 ;
8642  PLFLT *arg2 = (PLFLT *) 0 ;
8643  PLFLT *arg3 = (PLFLT *) 0 ;
8644  PLFLT *arg4 = (PLFLT *) 0 ;
8645  PyArrayObject *tmp1 ;
8646  PyArrayObject *tmp3 ;
8647  PyArrayObject *tmp4 ;
8648  PyObject * obj0 = 0 ;
8649  PyObject * obj1 = 0 ;
8650  PyObject * obj2 = 0 ;
8651 
8652  if (!PyArg_ParseTuple(args,(char *)"OOO:plline3",&obj0,&obj1,&obj2)) SWIG_fail;
8653  {
8654  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8655  if ( tmp1 == NULL )
8656  return NULL;
8657  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8658  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8659  }
8660  {
8661  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8662  if ( tmp3 == NULL )
8663  return NULL;
8664  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8665  {
8666  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8667  return NULL;
8668  }
8669  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8670  }
8671  {
8672  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
8673  if ( tmp4 == NULL )
8674  return NULL;
8675  if ( PyArray_DIMS( tmp4 )[0] != Alen )
8676  {
8677  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8678  return NULL;
8679  }
8680  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8681  }
8682  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8683  resultobj = SWIG_Py_Void();
8684  {
8685  Py_DECREF( tmp1 );
8686  }
8687  {
8688  Py_DECREF( tmp3 );
8689  }
8690  {
8691  Py_DECREF( tmp4 );
8692  }
8693  return resultobj;
8694 fail:
8695  {
8696  Py_DECREF( tmp1 );
8697  }
8698  {
8699  Py_DECREF( tmp3 );
8700  }
8701  {
8702  Py_DECREF( tmp4 );
8703  }
8704  return NULL;
8705 }
8706 
8707 
8708 SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8709  PyObject *resultobj = 0;
8710  PLINT arg1 ;
8711  int val1 ;
8712  int ecode1 = 0 ;
8713  PyObject * obj0 = 0 ;
8714 
8715  if (!PyArg_ParseTuple(args,(char *)"O:pllsty",&obj0)) SWIG_fail;
8716  ecode1 = SWIG_AsVal_int(obj0, &val1);
8717  if (!SWIG_IsOK(ecode1)) {
8718  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
8719  }
8720  arg1 = (PLINT)(val1);
8721  pllsty(arg1);
8722  resultobj = SWIG_Py_Void();
8723  return resultobj;
8724 fail:
8725  return NULL;
8726 }
8727 
8728 
8729 SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8730  PyObject *resultobj = 0;
8731  PLFLT *arg1 = (PLFLT *) 0 ;
8732  PLFLT *arg2 = (PLFLT *) 0 ;
8733  PLFLT **arg3 = (PLFLT **) 0 ;
8734  PLINT arg4 ;
8735  PLINT arg5 ;
8736  PLINT arg6 ;
8737  PyArrayObject *tmp1 ;
8738  PyArrayObject *tmp2 ;
8739  PyArrayObject *tmp3 ;
8740  int val6 ;
8741  int ecode6 = 0 ;
8742  PyObject * obj0 = 0 ;
8743  PyObject * obj1 = 0 ;
8744  PyObject * obj2 = 0 ;
8745  PyObject * obj3 = 0 ;
8746 
8747  if (!PyArg_ParseTuple(args,(char *)"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8748  {
8749  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8750  if ( tmp1 == NULL )
8751  return NULL;
8752  Xlen = PyArray_DIMS( tmp1 )[0];
8753  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8754  }
8755  {
8756  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8757  if ( tmp2 == NULL )
8758  return NULL;
8759  Ylen = PyArray_DIMS( tmp2 )[0];
8760  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8761  }
8762  {
8763  int i, size;
8764  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
8765  if ( tmp3 == NULL )
8766  return NULL;
8767  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8768  {
8769  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8770  return NULL;
8771  }
8772  arg4 = PyArray_DIMS( tmp3 )[0];
8773  arg5 = PyArray_DIMS( tmp3 )[1];
8774  size = sizeof ( PLFLT ) * arg5;
8775  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
8776  for ( i = 0; i < arg4; i++ )
8777  arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
8778  }
8779  ecode6 = SWIG_AsVal_int(obj3, &val6);
8780  if (!SWIG_IsOK(ecode6)) {
8781  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
8782  }
8783  arg6 = (PLINT)(val6);
8784  plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
8785  resultobj = SWIG_Py_Void();
8786  {
8787  Py_DECREF( tmp1 );
8788  }
8789  {
8790  Py_DECREF( tmp2 );
8791  }
8792  {
8793  Py_DECREF( tmp3 );
8794  free( arg3 );
8795  }
8796  return resultobj;
8797 fail:
8798  {
8799  Py_DECREF( tmp1 );
8800  }
8801  {
8802  Py_DECREF( tmp2 );
8803  }
8804  {
8805  Py_DECREF( tmp3 );
8806  free( arg3 );
8807  }
8808  return NULL;
8809 }
8810 
8811 
8812 SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8813  PyObject *resultobj = 0;
8814  PLFLT *arg1 = (PLFLT *) 0 ;
8815  PLFLT *arg2 = (PLFLT *) 0 ;
8816  PLFLT **arg3 = (PLFLT **) 0 ;
8817  PLINT arg4 ;
8818  PLINT arg5 ;
8819  PLINT arg6 ;
8820  PLFLT *arg7 = (PLFLT *) 0 ;
8821  PLINT arg8 ;
8822  PyArrayObject *tmp1 ;
8823  PyArrayObject *tmp2 ;
8824  PyArrayObject *tmp3 ;
8825  int val6 ;
8826  int ecode6 = 0 ;
8827  PyArrayObject *tmp7 ;
8828  PyObject * obj0 = 0 ;
8829  PyObject * obj1 = 0 ;
8830  PyObject * obj2 = 0 ;
8831  PyObject * obj3 = 0 ;
8832  PyObject * obj4 = 0 ;
8833 
8834  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8835  {
8836  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8837  if ( tmp1 == NULL )
8838  return NULL;
8839  Xlen = PyArray_DIMS( tmp1 )[0];
8840  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8841  }
8842  {
8843  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8844  if ( tmp2 == NULL )
8845  return NULL;
8846  Ylen = PyArray_DIMS( tmp2 )[0];
8847  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8848  }
8849  {
8850  int i, size;
8851  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
8852  if ( tmp3 == NULL )
8853  return NULL;
8854  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8855  {
8856  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8857  return NULL;
8858  }
8859  arg4 = PyArray_DIMS( tmp3 )[0];
8860  arg5 = PyArray_DIMS( tmp3 )[1];
8861  size = sizeof ( PLFLT ) * arg5;
8862  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
8863  for ( i = 0; i < arg4; i++ )
8864  arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
8865  }
8866  ecode6 = SWIG_AsVal_int(obj3, &val6);
8867  if (!SWIG_IsOK(ecode6)) {
8868  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
8869  }
8870  arg6 = (PLINT)(val6);
8871  {
8872  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
8873  if ( tmp7 == NULL )
8874  return NULL;
8875  arg8 = PyArray_DIMS( tmp7 )[0];
8876  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8877  }
8878  plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
8879  resultobj = SWIG_Py_Void();
8880  {
8881  Py_DECREF( tmp1 );
8882  }
8883  {
8884  Py_DECREF( tmp2 );
8885  }
8886  {
8887  Py_DECREF( tmp3 );
8888  free( arg3 );
8889  }
8890  {
8891  Py_DECREF( tmp7 );
8892  }
8893  return resultobj;
8894 fail:
8895  {
8896  Py_DECREF( tmp1 );
8897  }
8898  {
8899  Py_DECREF( tmp2 );
8900  }
8901  {
8902  Py_DECREF( tmp3 );
8903  free( arg3 );
8904  }
8905  {
8906  Py_DECREF( tmp7 );
8907  }
8908  return NULL;
8909 }
8910 
8911 
8912 SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8913  PyObject *resultobj = 0;
8914  PLINT *arg1 = (PLINT *) 0 ;
8915  PLINT temp1 ;
8916  int res1 = SWIG_TMPOBJ ;
8917 
8918  arg1 = &temp1;
8919  if (!PyArg_ParseTuple(args,(char *)":plmkstrm")) SWIG_fail;
8920  plmkstrm(arg1);
8921  resultobj = SWIG_Py_Void();
8922  if (SWIG_IsTmpObj(res1)) {
8923  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
8924  } else {
8925  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8926  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8927  }
8928  return resultobj;
8929 fail:
8930  return NULL;
8931 }
8932 
8933 
8934 SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8935  PyObject *resultobj = 0;
8936  char *arg1 = (char *) 0 ;
8937  PLFLT arg2 ;
8938  PLFLT arg3 ;
8939  PLFLT arg4 ;
8940  char *arg5 = (char *) 0 ;
8941  int res1 ;
8942  char *buf1 = 0 ;
8943  int alloc1 = 0 ;
8944  double val2 ;
8945  int ecode2 = 0 ;
8946  double val3 ;
8947  int ecode3 = 0 ;
8948  double val4 ;
8949  int ecode4 = 0 ;
8950  int res5 ;
8951  char *buf5 = 0 ;
8952  int alloc5 = 0 ;
8953  PyObject * obj0 = 0 ;
8954  PyObject * obj1 = 0 ;
8955  PyObject * obj2 = 0 ;
8956  PyObject * obj3 = 0 ;
8957  PyObject * obj4 = 0 ;
8958 
8959  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8960  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
8961  if (!SWIG_IsOK(res1)) {
8962  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
8963  }
8964  arg1 = (char *)(buf1);
8965  ecode2 = SWIG_AsVal_double(obj1, &val2);
8966  if (!SWIG_IsOK(ecode2)) {
8967  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
8968  }
8969  arg2 = (PLFLT)(val2);
8970  ecode3 = SWIG_AsVal_double(obj2, &val3);
8971  if (!SWIG_IsOK(ecode3)) {
8972  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
8973  }
8974  arg3 = (PLFLT)(val3);
8975  ecode4 = SWIG_AsVal_double(obj3, &val4);
8976  if (!SWIG_IsOK(ecode4)) {
8977  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
8978  }
8979  arg4 = (PLFLT)(val4);
8980  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
8981  if (!SWIG_IsOK(res5)) {
8982  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
8983  }
8984  arg5 = (char *)(buf5);
8985  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
8986  resultobj = SWIG_Py_Void();
8987  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8988  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8989  return resultobj;
8990 fail:
8991  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8992  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8993  return NULL;
8994 }
8995 
8996 
8997 SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8998  PyObject *resultobj = 0;
8999  char *arg1 = (char *) 0 ;
9000  PLFLT arg2 ;
9001  PLFLT arg3 ;
9002  PLFLT arg4 ;
9003  char *arg5 = (char *) 0 ;
9004  int res1 ;
9005  char *buf1 = 0 ;
9006  int alloc1 = 0 ;
9007  double val2 ;
9008  int ecode2 = 0 ;
9009  double val3 ;
9010  int ecode3 = 0 ;
9011  double val4 ;
9012  int ecode4 = 0 ;
9013  int res5 ;
9014  char *buf5 = 0 ;
9015  int alloc5 = 0 ;
9016  PyObject * obj0 = 0 ;
9017  PyObject * obj1 = 0 ;
9018  PyObject * obj2 = 0 ;
9019  PyObject * obj3 = 0 ;
9020  PyObject * obj4 = 0 ;
9021 
9022  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9023  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
9024  if (!SWIG_IsOK(res1)) {
9025  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9026  }
9027  arg1 = (char *)(buf1);
9028  ecode2 = SWIG_AsVal_double(obj1, &val2);
9029  if (!SWIG_IsOK(ecode2)) {
9030  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9031  }
9032  arg2 = (PLFLT)(val2);
9033  ecode3 = SWIG_AsVal_double(obj2, &val3);
9034  if (!SWIG_IsOK(ecode3)) {
9035  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9036  }
9037  arg3 = (PLFLT)(val3);
9038  ecode4 = SWIG_AsVal_double(obj3, &val4);
9039  if (!SWIG_IsOK(ecode4)) {
9040  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9041  }
9042  arg4 = (PLFLT)(val4);
9043  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
9044  if (!SWIG_IsOK(res5)) {
9045  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9046  }
9047  arg5 = (char *)(buf5);
9048  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9049  resultobj = SWIG_Py_Void();
9050  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9051  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9052  return resultobj;
9053 fail:
9054  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9055  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9056  return NULL;
9057 }
9058 
9059 
9060 SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9061  PyObject *resultobj = 0;
9062  PLFLT *arg1 = (PLFLT *) 0 ;
9063  PLFLT *arg2 = (PLFLT *) 0 ;
9064  PLFLT **arg3 = (PLFLT **) 0 ;
9065  PLINT arg4 ;
9066  PLINT arg5 ;
9067  PLINT arg6 ;
9068  PLBOOL arg7 ;
9069  PyArrayObject *tmp1 ;
9070  PyArrayObject *tmp2 ;
9071  PyArrayObject *tmp3 ;
9072  int val6 ;
9073  int ecode6 = 0 ;
9074  int val7 ;
9075  int ecode7 = 0 ;
9076  PyObject * obj0 = 0 ;
9077  PyObject * obj1 = 0 ;
9078  PyObject * obj2 = 0 ;
9079  PyObject * obj3 = 0 ;
9080  PyObject * obj4 = 0 ;
9081 
9082  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9083  {
9084  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9085  if ( tmp1 == NULL )
9086  return NULL;
9087  Xlen = PyArray_DIMS( tmp1 )[0];
9088  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9089  }
9090  {
9091  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9092  if ( tmp2 == NULL )
9093  return NULL;
9094  Ylen = PyArray_DIMS( tmp2 )[0];
9095  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9096  }
9097  {
9098  int i, size;
9099  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9100  if ( tmp3 == NULL )
9101  return NULL;
9102  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9103  {
9104  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9105  return NULL;
9106  }
9107  arg4 = PyArray_DIMS( tmp3 )[0];
9108  arg5 = PyArray_DIMS( tmp3 )[1];
9109  size = sizeof ( PLFLT ) * arg5;
9110  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
9111  for ( i = 0; i < arg4; i++ )
9112  arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9113  }
9114  ecode6 = SWIG_AsVal_int(obj3, &val6);
9115  if (!SWIG_IsOK(ecode6)) {
9116  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9117  }
9118  arg6 = (PLINT)(val6);
9119  ecode7 = SWIG_AsVal_int(obj4, &val7);
9120  if (!SWIG_IsOK(ecode7)) {
9121  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9122  }
9123  arg7 = (PLBOOL)(val7);
9124  plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9125  resultobj = SWIG_Py_Void();
9126  {
9127  Py_DECREF( tmp1 );
9128  }
9129  {
9130  Py_DECREF( tmp2 );
9131  }
9132  {
9133  Py_DECREF( tmp3 );
9134  free( arg3 );
9135  }
9136  return resultobj;
9137 fail:
9138  {
9139  Py_DECREF( tmp1 );
9140  }
9141  {
9142  Py_DECREF( tmp2 );
9143  }
9144  {
9145  Py_DECREF( tmp3 );
9146  free( arg3 );
9147  }
9148  return NULL;
9149 }
9150 
9151 
9152 SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9153  PyObject *resultobj = 0;
9154  PLFLT *arg1 = (PLFLT *) 0 ;
9155  PLFLT *arg2 = (PLFLT *) 0 ;
9156  PLFLT **arg3 = (PLFLT **) 0 ;
9157  PLINT arg4 ;
9158  PLINT arg5 ;
9159  PLINT arg6 ;
9160  PLFLT *arg7 = (PLFLT *) 0 ;
9161  PLINT arg8 ;
9162  PyArrayObject *tmp1 ;
9163  PyArrayObject *tmp2 ;
9164  PyArrayObject *tmp3 ;
9165  int val6 ;
9166  int ecode6 = 0 ;
9167  PyArrayObject *tmp7 ;
9168  PyObject * obj0 = 0 ;
9169  PyObject * obj1 = 0 ;
9170  PyObject * obj2 = 0 ;
9171  PyObject * obj3 = 0 ;
9172  PyObject * obj4 = 0 ;
9173 
9174  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9175  {
9176  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9177  if ( tmp1 == NULL )
9178  return NULL;
9179  Xlen = PyArray_DIMS( tmp1 )[0];
9180  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9181  }
9182  {
9183  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9184  if ( tmp2 == NULL )
9185  return NULL;
9186  Ylen = PyArray_DIMS( tmp2 )[0];
9187  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9188  }
9189  {
9190  int i, size;
9191  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9192  if ( tmp3 == NULL )
9193  return NULL;
9194  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9195  {
9196  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9197  return NULL;
9198  }
9199  arg4 = PyArray_DIMS( tmp3 )[0];
9200  arg5 = PyArray_DIMS( tmp3 )[1];
9201  size = sizeof ( PLFLT ) * arg5;
9202  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
9203  for ( i = 0; i < arg4; i++ )
9204  arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9205  }
9206  ecode6 = SWIG_AsVal_int(obj3, &val6);
9207  if (!SWIG_IsOK(ecode6)) {
9208  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9209  }
9210  arg6 = (PLINT)(val6);
9211  {
9212  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9213  if ( tmp7 == NULL )
9214  return NULL;
9215  arg8 = PyArray_DIMS( tmp7 )[0];
9216  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9217  }
9218  plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9219  resultobj = SWIG_Py_Void();
9220  {
9221  Py_DECREF( tmp1 );
9222  }
9223  {
9224  Py_DECREF( tmp2 );
9225  }
9226  {
9227  Py_DECREF( tmp3 );
9228  free( arg3 );
9229  }
9230  {
9231  Py_DECREF( tmp7 );
9232  }
9233  return resultobj;
9234 fail:
9235  {
9236  Py_DECREF( tmp1 );
9237  }
9238  {
9239  Py_DECREF( tmp2 );
9240  }
9241  {
9242  Py_DECREF( tmp3 );
9243  free( arg3 );
9244  }
9245  {
9246  Py_DECREF( tmp7 );
9247  }
9248  return NULL;
9249 }
9250 
9251 
9252 SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9253  PyObject *resultobj = 0;
9254  PLFLT *arg1 = (PLFLT *) 0 ;
9255  PLFLT *arg2 = (PLFLT *) 0 ;
9256  PLFLT **arg3 = (PLFLT **) 0 ;
9257  PLINT arg4 ;
9258  PLINT arg5 ;
9259  PLINT arg6 ;
9260  PLFLT *arg7 = (PLFLT *) 0 ;
9261  PLINT arg8 ;
9262  PLINT arg9 ;
9263  PLINT arg10 ;
9264  PLINT *arg11 = (PLINT *) 0 ;
9265  PLINT *arg12 = (PLINT *) 0 ;
9266  PyArrayObject *tmp1 ;
9267  PyArrayObject *tmp2 ;
9268  PyArrayObject *tmp3 ;
9269  int val6 ;
9270  int ecode6 = 0 ;
9271  PyArrayObject *tmp7 ;
9272  int val9 ;
9273  int ecode9 = 0 ;
9274  PyArrayObject *tmp10 ;
9275  PyArrayObject *tmp12 ;
9276  PyObject * obj0 = 0 ;
9277  PyObject * obj1 = 0 ;
9278  PyObject * obj2 = 0 ;
9279  PyObject * obj3 = 0 ;
9280  PyObject * obj4 = 0 ;
9281  PyObject * obj5 = 0 ;
9282  PyObject * obj6 = 0 ;
9283  PyObject * obj7 = 0 ;
9284 
9285  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9286  {
9287  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9288  if ( tmp1 == NULL )
9289  return NULL;
9290  Xlen = PyArray_DIMS( tmp1 )[0];
9291  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9292  }
9293  {
9294  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9295  if ( tmp2 == NULL )
9296  return NULL;
9297  Ylen = PyArray_DIMS( tmp2 )[0];
9298  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9299  }
9300  {
9301  int i, size;
9302  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9303  if ( tmp3 == NULL )
9304  return NULL;
9305  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9306  {
9307  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9308  return NULL;
9309  }
9310  arg4 = PyArray_DIMS( tmp3 )[0];
9311  arg5 = PyArray_DIMS( tmp3 )[1];
9312  size = sizeof ( PLFLT ) * arg5;
9313  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
9314  for ( i = 0; i < arg4; i++ )
9315  arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9316  }
9317  ecode6 = SWIG_AsVal_int(obj3, &val6);
9318  if (!SWIG_IsOK(ecode6)) {
9319  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9320  }
9321  arg6 = (PLINT)(val6);
9322  {
9323  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9324  if ( tmp7 == NULL )
9325  return NULL;
9326  arg8 = PyArray_DIMS( tmp7 )[0];
9327  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9328  }
9329  ecode9 = SWIG_AsVal_int(obj5, &val9);
9330  if (!SWIG_IsOK(ecode9)) {
9331  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9332  }
9333  arg9 = (PLINT)(val9);
9334  {
9335  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9336  if ( tmp10 == NULL )
9337  return NULL;
9338  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9339  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9340  }
9341  {
9342  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9343  if ( tmp12 == NULL )
9344  return NULL;
9345  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9346  {
9347  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9348  return NULL;
9349  }
9350  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9351  }
9352  plot3dcl((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8,arg9,arg10,(int const *)arg11,(int const *)arg12);
9353  resultobj = SWIG_Py_Void();
9354  {
9355  Py_DECREF( tmp1 );
9356  }
9357  {
9358  Py_DECREF( tmp2 );
9359  }
9360  {
9361  Py_DECREF( tmp3 );
9362  free( arg3 );
9363  }
9364  {
9365  Py_DECREF( tmp7 );
9366  }
9367  {
9368  Py_DECREF( tmp10 );
9369  }
9370  {
9371  Py_DECREF( tmp12 );
9372  }
9373  return resultobj;
9374 fail:
9375  {
9376  Py_DECREF( tmp1 );
9377  }
9378  {
9379  Py_DECREF( tmp2 );
9380  }
9381  {
9382  Py_DECREF( tmp3 );
9383  free( arg3 );
9384  }
9385  {
9386  Py_DECREF( tmp7 );
9387  }
9388  {
9389  Py_DECREF( tmp10 );
9390  }
9391  {
9392  Py_DECREF( tmp12 );
9393  }
9394  return NULL;
9395 }
9396 
9397 
9398 SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9399  PyObject *resultobj = 0;
9400  PLFLT *arg1 = (PLFLT *) 0 ;
9401  PLFLT *arg2 = (PLFLT *) 0 ;
9402  PLFLT **arg3 = (PLFLT **) 0 ;
9403  PLINT arg4 ;
9404  PLINT arg5 ;
9405  PLINT arg6 ;
9406  PLFLT *arg7 = (PLFLT *) 0 ;
9407  PLINT arg8 ;
9408  PyArrayObject *tmp1 ;
9409  PyArrayObject *tmp2 ;
9410  PyArrayObject *tmp3 ;
9411  int val6 ;
9412  int ecode6 = 0 ;
9413  PyArrayObject *tmp7 ;
9414  PyObject * obj0 = 0 ;
9415  PyObject * obj1 = 0 ;
9416  PyObject * obj2 = 0 ;
9417  PyObject * obj3 = 0 ;
9418  PyObject * obj4 = 0 ;
9419 
9420  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9421  {
9422  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9423  if ( tmp1 == NULL )
9424  return NULL;
9425  Xlen = PyArray_DIMS( tmp1 )[0];
9426  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9427  }
9428  {
9429  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9430  if ( tmp2 == NULL )
9431  return NULL;
9432  Ylen = PyArray_DIMS( tmp2 )[0];
9433  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9434  }
9435  {
9436  int i, size;
9437  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9438  if ( tmp3 == NULL )
9439  return NULL;
9440  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9441  {
9442  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9443  return NULL;
9444  }
9445  arg4 = PyArray_DIMS( tmp3 )[0];
9446  arg5 = PyArray_DIMS( tmp3 )[1];
9447  size = sizeof ( PLFLT ) * arg5;
9448  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
9449  for ( i = 0; i < arg4; i++ )
9450  arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9451  }
9452  ecode6 = SWIG_AsVal_int(obj3, &val6);
9453  if (!SWIG_IsOK(ecode6)) {
9454  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9455  }
9456  arg6 = (PLINT)(val6);
9457  {
9458  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9459  if ( tmp7 == NULL )
9460  return NULL;
9461  arg8 = PyArray_DIMS( tmp7 )[0];
9462  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9463  }
9464  plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9465  resultobj = SWIG_Py_Void();
9466  {
9467  Py_DECREF( tmp1 );
9468  }
9469  {
9470  Py_DECREF( tmp2 );
9471  }
9472  {
9473  Py_DECREF( tmp3 );
9474  free( arg3 );
9475  }
9476  {
9477  Py_DECREF( tmp7 );
9478  }
9479  return resultobj;
9480 fail:
9481  {
9482  Py_DECREF( tmp1 );
9483  }
9484  {
9485  Py_DECREF( tmp2 );
9486  }
9487  {
9488  Py_DECREF( tmp3 );
9489  free( arg3 );
9490  }
9491  {
9492  Py_DECREF( tmp7 );
9493  }
9494  return NULL;
9495 }
9496 
9497 
9498 SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9499  PyObject *resultobj = 0;
9500  PLFLT *arg1 = (PLFLT *) 0 ;
9501  PLFLT *arg2 = (PLFLT *) 0 ;
9502  PLFLT **arg3 = (PLFLT **) 0 ;
9503  PLINT arg4 ;
9504  PLINT arg5 ;
9505  PLINT arg6 ;
9506  PLFLT *arg7 = (PLFLT *) 0 ;
9507  PLINT arg8 ;
9508  PLINT arg9 ;
9509  PLINT arg10 ;
9510  PLINT *arg11 = (PLINT *) 0 ;
9511  PLINT *arg12 = (PLINT *) 0 ;
9512  PyArrayObject *tmp1 ;
9513  PyArrayObject *tmp2 ;
9514  PyArrayObject *tmp3 ;
9515  int val6 ;
9516  int ecode6 = 0 ;
9517  PyArrayObject *tmp7 ;
9518  int val9 ;
9519  int ecode9 = 0 ;
9520  PyArrayObject *tmp10 ;
9521  PyArrayObject *tmp12 ;
9522  PyObject * obj0 = 0 ;
9523  PyObject * obj1 = 0 ;
9524  PyObject * obj2 = 0 ;
9525  PyObject * obj3 = 0 ;
9526  PyObject * obj4 = 0 ;
9527  PyObject * obj5 = 0 ;
9528  PyObject * obj6 = 0 ;
9529  PyObject * obj7 = 0 ;
9530 
9531  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9532  {
9533  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9534  if ( tmp1 == NULL )
9535  return NULL;
9536  Xlen = PyArray_DIMS( tmp1 )[0];
9537  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9538  }
9539  {
9540  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9541  if ( tmp2 == NULL )
9542  return NULL;
9543  Ylen = PyArray_DIMS( tmp2 )[0];
9544  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9545  }
9546  {
9547  int i, size;
9548  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9549  if ( tmp3 == NULL )
9550  return NULL;
9551  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9552  {
9553  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9554  return NULL;
9555  }
9556  arg4 = PyArray_DIMS( tmp3 )[0];
9557  arg5 = PyArray_DIMS( tmp3 )[1];
9558  size = sizeof ( PLFLT ) * arg5;
9559  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
9560  for ( i = 0; i < arg4; i++ )
9561  arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9562  }
9563  ecode6 = SWIG_AsVal_int(obj3, &val6);
9564  if (!SWIG_IsOK(ecode6)) {
9565  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9566  }
9567  arg6 = (PLINT)(val6);
9568  {
9569  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9570  if ( tmp7 == NULL )
9571  return NULL;
9572  arg8 = PyArray_DIMS( tmp7 )[0];
9573  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9574  }
9575  ecode9 = SWIG_AsVal_int(obj5, &val9);
9576  if (!SWIG_IsOK(ecode9)) {
9577  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9578  }
9579  arg9 = (PLINT)(val9);
9580  {
9581  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9582  if ( tmp10 == NULL )
9583  return NULL;
9584  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9585  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9586  }
9587  {
9588  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9589  if ( tmp12 == NULL )
9590  return NULL;
9591  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9592  {
9593  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9594  return NULL;
9595  }
9596  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9597  }
9598  plsurf3dl((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8,arg9,arg10,(int const *)arg11,(int const *)arg12);
9599  resultobj = SWIG_Py_Void();
9600  {
9601  Py_DECREF( tmp1 );
9602  }
9603  {
9604  Py_DECREF( tmp2 );
9605  }
9606  {
9607  Py_DECREF( tmp3 );
9608  free( arg3 );
9609  }
9610  {
9611  Py_DECREF( tmp7 );
9612  }
9613  {
9614  Py_DECREF( tmp10 );
9615  }
9616  {
9617  Py_DECREF( tmp12 );
9618  }
9619  return resultobj;
9620 fail:
9621  {
9622  Py_DECREF( tmp1 );
9623  }
9624  {
9625  Py_DECREF( tmp2 );
9626  }
9627  {
9628  Py_DECREF( tmp3 );
9629  free( arg3 );
9630  }
9631  {
9632  Py_DECREF( tmp7 );
9633  }
9634  {
9635  Py_DECREF( tmp10 );
9636  }
9637  {
9638  Py_DECREF( tmp12 );
9639  }
9640  return NULL;
9641 }
9642 
9643 
9644 SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9645  PyObject *resultobj = 0;
9646  int *arg1 = (int *) 0 ;
9647  char **arg2 = (char **) 0 ;
9648  PLINT arg3 ;
9649  int tmp1 ;
9650  int val3 ;
9651  int ecode3 = 0 ;
9652  PyObject * obj0 = 0 ;
9653  PyObject * obj1 = 0 ;
9654  PLINT result;
9655 
9656  if (!PyArg_ParseTuple(args,(char *)"OO:plparseopts",&obj0,&obj1)) SWIG_fail;
9657  {
9658  int i;
9659  if ( !PyList_Check( obj0 ) )
9660  {
9661  PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9662  return NULL;
9663  }
9664  tmp1 = PyList_Size( obj0 );
9665  arg1 = &tmp1;
9666  arg2 = (char **) malloc( ( tmp1 + 1 ) * sizeof ( char * ) );
9667  for ( i = 0; i < tmp1; i++ )
9668  {
9669  PyObject *s = PyList_GetItem( obj0, i );
9670  if ( !PyString_Check( s ) )
9671  {
9672  free( arg2 );
9673  PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9674  return NULL;
9675  }
9676  arg2[i] = PyString_AsString( s );
9677  }
9678  arg2[i] = 0;
9679  }
9680  ecode3 = SWIG_AsVal_int(obj1, &val3);
9681  if (!SWIG_IsOK(ecode3)) {
9682  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9683  }
9684  arg3 = (PLINT)(val3);
9685  result = (PLINT)plparseopts(arg1,(char const **)arg2,arg3);
9686  resultobj = SWIG_From_int((int)(result));
9687  {
9688  if ( arg2 )
9689  free( arg2 );
9690  }
9691  return resultobj;
9692 fail:
9693  {
9694  if ( arg2 )
9695  free( arg2 );
9696  }
9697  return NULL;
9698 }
9699 
9700 
9701 SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9702  PyObject *resultobj = 0;
9703  PLINT arg1 ;
9704  PLINT *arg2 = (PLINT *) 0 ;
9705  PLINT *arg3 = (PLINT *) 0 ;
9706  PyArrayObject *tmp1 ;
9707  PyArrayObject *tmp3 ;
9708  PyObject * obj0 = 0 ;
9709  PyObject * obj1 = 0 ;
9710 
9711  if (!PyArg_ParseTuple(args,(char *)"OO:plpat",&obj0,&obj1)) SWIG_fail;
9712  {
9713  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
9714  if ( tmp1 == NULL )
9715  return NULL;
9716  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9717  arg2 = (PLINT *) PyArray_DATA( tmp1 );
9718  }
9719  {
9720  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
9721  if ( tmp3 == NULL )
9722  return NULL;
9723  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9724  {
9725  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9726  return NULL;
9727  }
9728  arg3 = (PLINT *) PyArray_DATA( tmp3 );
9729  }
9730  plpat(arg1,(int const *)arg2,(int const *)arg3);
9731  resultobj = SWIG_Py_Void();
9732  {
9733  Py_DECREF( tmp1 );
9734  }
9735  {
9736  Py_DECREF( tmp3 );
9737  }
9738  return resultobj;
9739 fail:
9740  {
9741  Py_DECREF( tmp1 );
9742  }
9743  {
9744  Py_DECREF( tmp3 );
9745  }
9746  return NULL;
9747 }
9748 
9749 
9750 SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9751  PyObject *resultobj = 0;
9752  PLINT arg1 ;
9753  PLFLT *arg2 = (PLFLT *) 0 ;
9754  PLFLT *arg3 = (PLFLT *) 0 ;
9755  PLINT arg4 ;
9756  PyArrayObject *tmp1 ;
9757  PyArrayObject *tmp3 ;
9758  int val4 ;
9759  int ecode4 = 0 ;
9760  PyObject * obj0 = 0 ;
9761  PyObject * obj1 = 0 ;
9762  PyObject * obj2 = 0 ;
9763 
9764  if (!PyArg_ParseTuple(args,(char *)"OOO:plpoin",&obj0,&obj1,&obj2)) SWIG_fail;
9765  {
9766  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9767  if ( tmp1 == NULL )
9768  return NULL;
9769  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9770  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9771  }
9772  {
9773  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9774  if ( tmp3 == NULL )
9775  return NULL;
9776  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9777  {
9778  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9779  return NULL;
9780  }
9781  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9782  }
9783  ecode4 = SWIG_AsVal_int(obj2, &val4);
9784  if (!SWIG_IsOK(ecode4)) {
9785  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
9786  }
9787  arg4 = (PLINT)(val4);
9788  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
9789  resultobj = SWIG_Py_Void();
9790  {
9791  Py_DECREF( tmp1 );
9792  }
9793  {
9794  Py_DECREF( tmp3 );
9795  }
9796  return resultobj;
9797 fail:
9798  {
9799  Py_DECREF( tmp1 );
9800  }
9801  {
9802  Py_DECREF( tmp3 );
9803  }
9804  return NULL;
9805 }
9806 
9807 
9808 SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9809  PyObject *resultobj = 0;
9810  PLINT arg1 ;
9811  PLFLT *arg2 = (PLFLT *) 0 ;
9812  PLFLT *arg3 = (PLFLT *) 0 ;
9813  PLFLT *arg4 = (PLFLT *) 0 ;
9814  PLINT arg5 ;
9815  PyArrayObject *tmp1 ;
9816  PyArrayObject *tmp3 ;
9817  PyArrayObject *tmp4 ;
9818  int val5 ;
9819  int ecode5 = 0 ;
9820  PyObject * obj0 = 0 ;
9821  PyObject * obj1 = 0 ;
9822  PyObject * obj2 = 0 ;
9823  PyObject * obj3 = 0 ;
9824 
9825  if (!PyArg_ParseTuple(args,(char *)"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9826  {
9827  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9828  if ( tmp1 == NULL )
9829  return NULL;
9830  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9831  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9832  }
9833  {
9834  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9835  if ( tmp3 == NULL )
9836  return NULL;
9837  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9838  {
9839  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9840  return NULL;
9841  }
9842  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9843  }
9844  {
9845  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
9846  if ( tmp4 == NULL )
9847  return NULL;
9848  if ( PyArray_DIMS( tmp4 )[0] != Alen )
9849  {
9850  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9851  return NULL;
9852  }
9853  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9854  }
9855  ecode5 = SWIG_AsVal_int(obj3, &val5);
9856  if (!SWIG_IsOK(ecode5)) {
9857  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
9858  }
9859  arg5 = (PLINT)(val5);
9860  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
9861  resultobj = SWIG_Py_Void();
9862  {
9863  Py_DECREF( tmp1 );
9864  }
9865  {
9866  Py_DECREF( tmp3 );
9867  }
9868  {
9869  Py_DECREF( tmp4 );
9870  }
9871  return resultobj;
9872 fail:
9873  {
9874  Py_DECREF( tmp1 );
9875  }
9876  {
9877  Py_DECREF( tmp3 );
9878  }
9879  {
9880  Py_DECREF( tmp4 );
9881  }
9882  return NULL;
9883 }
9884 
9885 
9886 SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9887  PyObject *resultobj = 0;
9888  PLINT arg1 ;
9889  PLFLT *arg2 = (PLFLT *) 0 ;
9890  PLFLT *arg3 = (PLFLT *) 0 ;
9891  PLFLT *arg4 = (PLFLT *) 0 ;
9892  PLBOOL *arg5 = (PLBOOL *) 0 ;
9893  PLBOOL arg6 ;
9894  PyArrayObject *tmp1 ;
9895  PyArrayObject *tmp3 ;
9896  PyArrayObject *tmp4 ;
9897  PyArrayObject *tmp5 ;
9898  int val6 ;
9899  int ecode6 = 0 ;
9900  PyObject * obj0 = 0 ;
9901  PyObject * obj1 = 0 ;
9902  PyObject * obj2 = 0 ;
9903  PyObject * obj3 = 0 ;
9904  PyObject * obj4 = 0 ;
9905 
9906  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9907  {
9908  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9909  if ( tmp1 == NULL )
9910  return NULL;
9911  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9912  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9913  }
9914  {
9915  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9916  if ( tmp3 == NULL )
9917  return NULL;
9918  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9919  {
9920  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9921  return NULL;
9922  }
9923  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9924  }
9925  {
9926  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
9927  if ( tmp4 == NULL )
9928  return NULL;
9929  if ( PyArray_DIMS( tmp4 )[0] != Alen )
9930  {
9931  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9932  return NULL;
9933  }
9934  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9935  }
9936  {
9937  tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj3, NPY_PLINT, 1, 1 );
9938  if ( tmp5 == NULL )
9939  return NULL;
9940  if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
9941  {
9942  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
9943  return NULL;
9944  }
9945  arg5 = (PLINT *) PyArray_DATA( tmp5 );
9946  }
9947  ecode6 = SWIG_AsVal_int(obj4, &val6);
9948  if (!SWIG_IsOK(ecode6)) {
9949  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
9950  }
9951  arg6 = (PLBOOL)(val6);
9952  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
9953  resultobj = SWIG_Py_Void();
9954  {
9955  Py_DECREF( tmp1 );
9956  }
9957  {
9958  Py_DECREF( tmp3 );
9959  }
9960  {
9961  Py_DECREF( tmp4 );
9962  }
9963  {
9964  Py_DECREF( tmp5 );
9965  }
9966  return resultobj;
9967 fail:
9968  {
9969  Py_DECREF( tmp1 );
9970  }
9971  {
9972  Py_DECREF( tmp3 );
9973  }
9974  {
9975  Py_DECREF( tmp4 );
9976  }
9977  {
9978  Py_DECREF( tmp5 );
9979  }
9980  return NULL;
9981 }
9982 
9983 
9984 SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9985  PyObject *resultobj = 0;
9986  PLINT arg1 ;
9987  PLINT arg2 ;
9988  int val1 ;
9989  int ecode1 = 0 ;
9990  int val2 ;
9991  int ecode2 = 0 ;
9992  PyObject * obj0 = 0 ;
9993  PyObject * obj1 = 0 ;
9994 
9995  if (!PyArg_ParseTuple(args,(char *)"OO:plprec",&obj0,&obj1)) SWIG_fail;
9996  ecode1 = SWIG_AsVal_int(obj0, &val1);
9997  if (!SWIG_IsOK(ecode1)) {
9998  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
9999  }
10000  arg1 = (PLINT)(val1);
10001  ecode2 = SWIG_AsVal_int(obj1, &val2);
10002  if (!SWIG_IsOK(ecode2)) {
10003  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10004  }
10005  arg2 = (PLINT)(val2);
10006  plprec(arg1,arg2);
10007  resultobj = SWIG_Py_Void();
10008  return resultobj;
10009 fail:
10010  return NULL;
10011 }
10012 
10013 
10014 SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10015  PyObject *resultobj = 0;
10016  PLINT arg1 ;
10017  int val1 ;
10018  int ecode1 = 0 ;
10019  PyObject * obj0 = 0 ;
10020 
10021  if (!PyArg_ParseTuple(args,(char *)"O:plpsty",&obj0)) SWIG_fail;
10022  ecode1 = SWIG_AsVal_int(obj0, &val1);
10023  if (!SWIG_IsOK(ecode1)) {
10024  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10025  }
10026  arg1 = (PLINT)(val1);
10027  plpsty(arg1);
10028  resultobj = SWIG_Py_Void();
10029  return resultobj;
10030 fail:
10031  return NULL;
10032 }
10033 
10034 
10035 SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10036  PyObject *resultobj = 0;
10037  PLFLT arg1 ;
10038  PLFLT arg2 ;
10039  PLFLT arg3 ;
10040  PLFLT arg4 ;
10041  PLFLT arg5 ;
10042  char *arg6 = (char *) 0 ;
10043  double val1 ;
10044  int ecode1 = 0 ;
10045  double val2 ;
10046  int ecode2 = 0 ;
10047  double val3 ;
10048  int ecode3 = 0 ;
10049  double val4 ;
10050  int ecode4 = 0 ;
10051  double val5 ;
10052  int ecode5 = 0 ;
10053  int res6 ;
10054  char *buf6 = 0 ;
10055  int alloc6 = 0 ;
10056  PyObject * obj0 = 0 ;
10057  PyObject * obj1 = 0 ;
10058  PyObject * obj2 = 0 ;
10059  PyObject * obj3 = 0 ;
10060  PyObject * obj4 = 0 ;
10061  PyObject * obj5 = 0 ;
10062 
10063  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10064  ecode1 = SWIG_AsVal_double(obj0, &val1);
10065  if (!SWIG_IsOK(ecode1)) {
10066  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10067  }
10068  arg1 = (PLFLT)(val1);
10069  ecode2 = SWIG_AsVal_double(obj1, &val2);
10070  if (!SWIG_IsOK(ecode2)) {
10071  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10072  }
10073  arg2 = (PLFLT)(val2);
10074  ecode3 = SWIG_AsVal_double(obj2, &val3);
10075  if (!SWIG_IsOK(ecode3)) {
10076  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10077  }
10078  arg3 = (PLFLT)(val3);
10079  ecode4 = SWIG_AsVal_double(obj3, &val4);
10080  if (!SWIG_IsOK(ecode4)) {
10081  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10082  }
10083  arg4 = (PLFLT)(val4);
10084  ecode5 = SWIG_AsVal_double(obj4, &val5);
10085  if (!SWIG_IsOK(ecode5)) {
10086  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10087  }
10088  arg5 = (PLFLT)(val5);
10089  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
10090  if (!SWIG_IsOK(res6)) {
10091  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10092  }
10093  arg6 = (char *)(buf6);
10094  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10095  resultobj = SWIG_Py_Void();
10096  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10097  return resultobj;
10098 fail:
10099  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10100  return NULL;
10101 }
10102 
10103 
10104 SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10105  PyObject *resultobj = 0;
10106  PLFLT arg1 ;
10107  PLFLT arg2 ;
10108  PLFLT arg3 ;
10109  PLFLT arg4 ;
10110  PLFLT arg5 ;
10111  PLFLT arg6 ;
10112  PLFLT arg7 ;
10113  PLFLT arg8 ;
10114  PLFLT arg9 ;
10115  PLFLT arg10 ;
10116  char *arg11 = (char *) 0 ;
10117  double val1 ;
10118  int ecode1 = 0 ;
10119  double val2 ;
10120  int ecode2 = 0 ;
10121  double val3 ;
10122  int ecode3 = 0 ;
10123  double val4 ;
10124  int ecode4 = 0 ;
10125  double val5 ;
10126  int ecode5 = 0 ;
10127  double val6 ;
10128  int ecode6 = 0 ;
10129  double val7 ;
10130  int ecode7 = 0 ;
10131  double val8 ;
10132  int ecode8 = 0 ;
10133  double val9 ;
10134  int ecode9 = 0 ;
10135  double val10 ;
10136  int ecode10 = 0 ;
10137  int res11 ;
10138  char *buf11 = 0 ;
10139  int alloc11 = 0 ;
10140  PyObject * obj0 = 0 ;
10141  PyObject * obj1 = 0 ;
10142  PyObject * obj2 = 0 ;
10143  PyObject * obj3 = 0 ;
10144  PyObject * obj4 = 0 ;
10145  PyObject * obj5 = 0 ;
10146  PyObject * obj6 = 0 ;
10147  PyObject * obj7 = 0 ;
10148  PyObject * obj8 = 0 ;
10149  PyObject * obj9 = 0 ;
10150  PyObject * obj10 = 0 ;
10151 
10152  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
10153  ecode1 = SWIG_AsVal_double(obj0, &val1);
10154  if (!SWIG_IsOK(ecode1)) {
10155  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10156  }
10157  arg1 = (PLFLT)(val1);
10158  ecode2 = SWIG_AsVal_double(obj1, &val2);
10159  if (!SWIG_IsOK(ecode2)) {
10160  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10161  }
10162  arg2 = (PLFLT)(val2);
10163  ecode3 = SWIG_AsVal_double(obj2, &val3);
10164  if (!SWIG_IsOK(ecode3)) {
10165  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10166  }
10167  arg3 = (PLFLT)(val3);
10168  ecode4 = SWIG_AsVal_double(obj3, &val4);
10169  if (!SWIG_IsOK(ecode4)) {
10170  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10171  }
10172  arg4 = (PLFLT)(val4);
10173  ecode5 = SWIG_AsVal_double(obj4, &val5);
10174  if (!SWIG_IsOK(ecode5)) {
10175  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10176  }
10177  arg5 = (PLFLT)(val5);
10178  ecode6 = SWIG_AsVal_double(obj5, &val6);
10179  if (!SWIG_IsOK(ecode6)) {
10180  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10181  }
10182  arg6 = (PLFLT)(val6);
10183  ecode7 = SWIG_AsVal_double(obj6, &val7);
10184  if (!SWIG_IsOK(ecode7)) {
10185  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10186  }
10187  arg7 = (PLFLT)(val7);
10188  ecode8 = SWIG_AsVal_double(obj7, &val8);
10189  if (!SWIG_IsOK(ecode8)) {
10190  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10191  }
10192  arg8 = (PLFLT)(val8);
10193  ecode9 = SWIG_AsVal_double(obj8, &val9);
10194  if (!SWIG_IsOK(ecode9)) {
10195  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10196  }
10197  arg9 = (PLFLT)(val9);
10198  ecode10 = SWIG_AsVal_double(obj9, &val10);
10199  if (!SWIG_IsOK(ecode10)) {
10200  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10201  }
10202  arg10 = (PLFLT)(val10);
10203  res11 = SWIG_AsCharPtrAndSize(obj10, &buf11, NULL, &alloc11);
10204  if (!SWIG_IsOK(res11)) {
10205  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10206  }
10207  arg11 = (char *)(buf11);
10208  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10209  resultobj = SWIG_Py_Void();
10210  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10211  return resultobj;
10212 fail:
10213  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10214  return NULL;
10215 }
10216 
10217 
10218 SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10219  PyObject *resultobj = 0;
10220  PLFLT result;
10221 
10222  if (!PyArg_ParseTuple(args,(char *)":plrandd")) SWIG_fail;
10223  result = (PLFLT)plrandd();
10224  resultobj = SWIG_From_double((double)(result));
10225  return resultobj;
10226 fail:
10227  return NULL;
10228 }
10229 
10230 
10231 SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10232  PyObject *resultobj = 0;
10233 
10234  if (!PyArg_ParseTuple(args,(char *)":plreplot")) SWIG_fail;
10235  plreplot();
10236  resultobj = SWIG_Py_Void();
10237  return resultobj;
10238 fail:
10239  return NULL;
10240 }
10241 
10242 
10243 SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10244  PyObject *resultobj = 0;
10245  PLFLT arg1 ;
10246  PLFLT arg2 ;
10247  PLFLT arg3 ;
10248  PLFLT *arg4 = (PLFLT *) 0 ;
10249  PLFLT *arg5 = (PLFLT *) 0 ;
10250  PLFLT *arg6 = (PLFLT *) 0 ;
10251  double val1 ;
10252  int ecode1 = 0 ;
10253  double val2 ;
10254  int ecode2 = 0 ;
10255  double val3 ;
10256  int ecode3 = 0 ;
10257  PLFLT temp4 ;
10258  int res4 = SWIG_TMPOBJ ;
10259  PLFLT temp5 ;
10260  int res5 = SWIG_TMPOBJ ;
10261  PLFLT temp6 ;
10262  int res6 = SWIG_TMPOBJ ;
10263  PyObject * obj0 = 0 ;
10264  PyObject * obj1 = 0 ;
10265  PyObject * obj2 = 0 ;
10266 
10267  arg4 = &temp4;
10268  arg5 = &temp5;
10269  arg6 = &temp6;
10270  if (!PyArg_ParseTuple(args,(char *)"OOO:plrgbhls",&obj0,&obj1,&obj2)) SWIG_fail;
10271  ecode1 = SWIG_AsVal_double(obj0, &val1);
10272  if (!SWIG_IsOK(ecode1)) {
10273  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10274  }
10275  arg1 = (PLFLT)(val1);
10276  ecode2 = SWIG_AsVal_double(obj1, &val2);
10277  if (!SWIG_IsOK(ecode2)) {
10278  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10279  }
10280  arg2 = (PLFLT)(val2);
10281  ecode3 = SWIG_AsVal_double(obj2, &val3);
10282  if (!SWIG_IsOK(ecode3)) {
10283  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10284  }
10285  arg3 = (PLFLT)(val3);
10286  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10287  resultobj = SWIG_Py_Void();
10288  if (SWIG_IsTmpObj(res4)) {
10289  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
10290  } else {
10291  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10292  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
10293  }
10294  if (SWIG_IsTmpObj(res5)) {
10295  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
10296  } else {
10297  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10298  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10299  }
10300  if (SWIG_IsTmpObj(res6)) {
10301  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10302  } else {
10303  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10304  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10305  }
10306  return resultobj;
10307 fail:
10308  return NULL;
10309 }
10310 
10311 
10312 SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10313  PyObject *resultobj = 0;
10314  PLFLT arg1 ;
10315  PLFLT arg2 ;
10316  double val1 ;
10317  int ecode1 = 0 ;
10318  double val2 ;
10319  int ecode2 = 0 ;
10320  PyObject * obj0 = 0 ;
10321  PyObject * obj1 = 0 ;
10322 
10323  if (!PyArg_ParseTuple(args,(char *)"OO:plschr",&obj0,&obj1)) SWIG_fail;
10324  ecode1 = SWIG_AsVal_double(obj0, &val1);
10325  if (!SWIG_IsOK(ecode1)) {
10326  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10327  }
10328  arg1 = (PLFLT)(val1);
10329  ecode2 = SWIG_AsVal_double(obj1, &val2);
10330  if (!SWIG_IsOK(ecode2)) {
10331  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10332  }
10333  arg2 = (PLFLT)(val2);
10334  plschr(arg1,arg2);
10335  resultobj = SWIG_Py_Void();
10336  return resultobj;
10337 fail:
10338  return NULL;
10339 }
10340 
10341 
10342 SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10343  PyObject *resultobj = 0;
10344  PLINT *arg1 = (PLINT *) 0 ;
10345  PLINT *arg2 = (PLINT *) 0 ;
10346  PLINT *arg3 = (PLINT *) 0 ;
10347  PLINT arg4 ;
10348  PyArrayObject *tmp1 ;
10349  PyArrayObject *tmp2 ;
10350  PyArrayObject *tmp3 ;
10351  PyObject * obj0 = 0 ;
10352  PyObject * obj1 = 0 ;
10353  PyObject * obj2 = 0 ;
10354 
10355  if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap0",&obj0,&obj1,&obj2)) SWIG_fail;
10356  {
10357  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10358  if ( tmp1 == NULL )
10359  return NULL;
10360  Alen = PyArray_DIMS( tmp1 )[0];
10361  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10362  }
10363  {
10364  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10365  if ( tmp2 == NULL )
10366  return NULL;
10367  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10368  {
10369  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10370  return NULL;
10371  }
10372  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10373  }
10374  {
10375  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10376  if ( tmp3 == NULL )
10377  return NULL;
10378  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10379  {
10380  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10381  return NULL;
10382  }
10383  arg4 = PyArray_DIMS( tmp3 )[0];
10384  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10385  }
10386  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10387  resultobj = SWIG_Py_Void();
10388  {
10389  Py_DECREF( tmp1 );
10390  }
10391  {
10392  Py_DECREF( tmp2 );
10393  }
10394  {
10395  Py_DECREF( tmp3 );
10396  }
10397  return resultobj;
10398 fail:
10399  {
10400  Py_DECREF( tmp1 );
10401  }
10402  {
10403  Py_DECREF( tmp2 );
10404  }
10405  {
10406  Py_DECREF( tmp3 );
10407  }
10408  return NULL;
10409 }
10410 
10411 
10412 SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10413  PyObject *resultobj = 0;
10414  PLINT *arg1 = (PLINT *) 0 ;
10415  PLINT *arg2 = (PLINT *) 0 ;
10416  PLINT *arg3 = (PLINT *) 0 ;
10417  PLFLT *arg4 = (PLFLT *) 0 ;
10418  PLINT arg5 ;
10419  PyArrayObject *tmp1 ;
10420  PyArrayObject *tmp2 ;
10421  PyArrayObject *tmp3 ;
10422  PyArrayObject *tmp4 ;
10423  PyObject * obj0 = 0 ;
10424  PyObject * obj1 = 0 ;
10425  PyObject * obj2 = 0 ;
10426  PyObject * obj3 = 0 ;
10427 
10428  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10429  {
10430  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10431  if ( tmp1 == NULL )
10432  return NULL;
10433  Alen = PyArray_DIMS( tmp1 )[0];
10434  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10435  }
10436  {
10437  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10438  if ( tmp2 == NULL )
10439  return NULL;
10440  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10441  {
10442  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10443  return NULL;
10444  }
10445  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10446  }
10447  {
10448  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10449  if ( tmp3 == NULL )
10450  return NULL;
10451  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10452  {
10453  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10454  return NULL;
10455  }
10456  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10457  }
10458  {
10459  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10460  if ( tmp4 == NULL )
10461  return NULL;
10462  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10463  {
10464  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10465  return NULL;
10466  }
10467  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10468  arg5 = PyArray_DIMS( tmp4 )[0];
10469  }
10470  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10471  resultobj = SWIG_Py_Void();
10472  {
10473  Py_DECREF( tmp1 );
10474  }
10475  {
10476  Py_DECREF( tmp2 );
10477  }
10478  {
10479  Py_DECREF( tmp3 );
10480  }
10481  {
10482  Py_DECREF( tmp4 );
10483  }
10484  return resultobj;
10485 fail:
10486  {
10487  Py_DECREF( tmp1 );
10488  }
10489  {
10490  Py_DECREF( tmp2 );
10491  }
10492  {
10493  Py_DECREF( tmp3 );
10494  }
10495  {
10496  Py_DECREF( tmp4 );
10497  }
10498  return NULL;
10499 }
10500 
10501 
10502 SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10503  PyObject *resultobj = 0;
10504  PLINT arg1 ;
10505  int val1 ;
10506  int ecode1 = 0 ;
10507  PyObject * obj0 = 0 ;
10508 
10509  if (!PyArg_ParseTuple(args,(char *)"O:plscmap0n",&obj0)) SWIG_fail;
10510  ecode1 = SWIG_AsVal_int(obj0, &val1);
10511  if (!SWIG_IsOK(ecode1)) {
10512  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10513  }
10514  arg1 = (PLINT)(val1);
10515  plscmap0n(arg1);
10516  resultobj = SWIG_Py_Void();
10517  return resultobj;
10518 fail:
10519  return NULL;
10520 }
10521 
10522 
10523 SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10524  PyObject *resultobj = 0;
10525  PLINT *arg1 = (PLINT *) 0 ;
10526  PLINT *arg2 = (PLINT *) 0 ;
10527  PLINT *arg3 = (PLINT *) 0 ;
10528  PLINT arg4 ;
10529  PyArrayObject *tmp1 ;
10530  PyArrayObject *tmp2 ;
10531  PyArrayObject *tmp3 ;
10532  PyObject * obj0 = 0 ;
10533  PyObject * obj1 = 0 ;
10534  PyObject * obj2 = 0 ;
10535 
10536  if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap1",&obj0,&obj1,&obj2)) SWIG_fail;
10537  {
10538  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10539  if ( tmp1 == NULL )
10540  return NULL;
10541  Alen = PyArray_DIMS( tmp1 )[0];
10542  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10543  }
10544  {
10545  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10546  if ( tmp2 == NULL )
10547  return NULL;
10548  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10549  {
10550  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10551  return NULL;
10552  }
10553  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10554  }
10555  {
10556  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10557  if ( tmp3 == NULL )
10558  return NULL;
10559  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10560  {
10561  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10562  return NULL;
10563  }
10564  arg4 = PyArray_DIMS( tmp3 )[0];
10565  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10566  }
10567  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10568  resultobj = SWIG_Py_Void();
10569  {
10570  Py_DECREF( tmp1 );
10571  }
10572  {
10573  Py_DECREF( tmp2 );
10574  }
10575  {
10576  Py_DECREF( tmp3 );
10577  }
10578  return resultobj;
10579 fail:
10580  {
10581  Py_DECREF( tmp1 );
10582  }
10583  {
10584  Py_DECREF( tmp2 );
10585  }
10586  {
10587  Py_DECREF( tmp3 );
10588  }
10589  return NULL;
10590 }
10591 
10592 
10593 SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10594  PyObject *resultobj = 0;
10595  PLINT *arg1 = (PLINT *) 0 ;
10596  PLINT *arg2 = (PLINT *) 0 ;
10597  PLINT *arg3 = (PLINT *) 0 ;
10598  PLFLT *arg4 = (PLFLT *) 0 ;
10599  PLINT arg5 ;
10600  PyArrayObject *tmp1 ;
10601  PyArrayObject *tmp2 ;
10602  PyArrayObject *tmp3 ;
10603  PyArrayObject *tmp4 ;
10604  PyObject * obj0 = 0 ;
10605  PyObject * obj1 = 0 ;
10606  PyObject * obj2 = 0 ;
10607  PyObject * obj3 = 0 ;
10608 
10609  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10610  {
10611  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10612  if ( tmp1 == NULL )
10613  return NULL;
10614  Alen = PyArray_DIMS( tmp1 )[0];
10615  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10616  }
10617  {
10618  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10619  if ( tmp2 == NULL )
10620  return NULL;
10621  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10622  {
10623  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10624  return NULL;
10625  }
10626  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10627  }
10628  {
10629  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10630  if ( tmp3 == NULL )
10631  return NULL;
10632  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10633  {
10634  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10635  return NULL;
10636  }
10637  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10638  }
10639  {
10640  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10641  if ( tmp4 == NULL )
10642  return NULL;
10643  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10644  {
10645  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10646  return NULL;
10647  }
10648  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10649  arg5 = PyArray_DIMS( tmp4 )[0];
10650  }
10651  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10652  resultobj = SWIG_Py_Void();
10653  {
10654  Py_DECREF( tmp1 );
10655  }
10656  {
10657  Py_DECREF( tmp2 );
10658  }
10659  {
10660  Py_DECREF( tmp3 );
10661  }
10662  {
10663  Py_DECREF( tmp4 );
10664  }
10665  return resultobj;
10666 fail:
10667  {
10668  Py_DECREF( tmp1 );
10669  }
10670  {
10671  Py_DECREF( tmp2 );
10672  }
10673  {
10674  Py_DECREF( tmp3 );
10675  }
10676  {
10677  Py_DECREF( tmp4 );
10678  }
10679  return NULL;
10680 }
10681 
10682 
10683 SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10684  PyObject *resultobj = 0;
10685  PLBOOL arg1 ;
10686  PLINT arg2 ;
10687  PLFLT *arg3 = (PLFLT *) 0 ;
10688  PLFLT *arg4 = (PLFLT *) 0 ;
10689  PLFLT *arg5 = (PLFLT *) 0 ;
10690  PLFLT *arg6 = (PLFLT *) 0 ;
10691  PLBOOL *arg7 = (PLBOOL *) 0 ;
10692  int val1 ;
10693  int ecode1 = 0 ;
10694  PyArrayObject *tmp2 ;
10695  PyArrayObject *tmp4 ;
10696  PyArrayObject *tmp5 ;
10697  PyArrayObject *tmp6 ;
10698  PyArrayObject *tmp7 ;
10699  PyObject * obj0 = 0 ;
10700  PyObject * obj1 = 0 ;
10701  PyObject * obj2 = 0 ;
10702  PyObject * obj3 = 0 ;
10703  PyObject * obj4 = 0 ;
10704  PyObject * obj5 = 0 ;
10705 
10706  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10707  ecode1 = SWIG_AsVal_int(obj0, &val1);
10708  if (!SWIG_IsOK(ecode1)) {
10709  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10710  }
10711  arg1 = (PLBOOL)(val1);
10712  {
10713  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10714  if ( tmp2 == NULL )
10715  return NULL;
10716  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10717  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10718  }
10719  {
10720  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10721  if ( tmp4 == NULL )
10722  return NULL;
10723  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10724  {
10725  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10726  return NULL;
10727  }
10728  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10729  }
10730  {
10731  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10732  if ( tmp5 == NULL )
10733  return NULL;
10734  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10735  {
10736  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10737  return NULL;
10738  }
10739  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10740  }
10741  {
10742  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
10743  if ( tmp6 == NULL )
10744  return NULL;
10745  if ( PyArray_DIMS( tmp6 )[0] != Alen )
10746  {
10747  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10748  return NULL;
10749  }
10750  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10751  }
10752  {
10753  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj5, NPY_PLINT, 1, 1 );
10754  if ( tmp7 == NULL )
10755  return NULL;
10756  if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10757  {
10758  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10759  return NULL;
10760  }
10761  arg7 = (PLINT *) PyArray_DATA( tmp7 );
10762  }
10763  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
10764  resultobj = SWIG_Py_Void();
10765  {
10766  Py_DECREF( tmp2 );
10767  }
10768  {
10769  Py_DECREF( tmp4 );
10770  }
10771  {
10772  Py_DECREF( tmp5 );
10773  }
10774  {
10775  Py_DECREF( tmp6 );
10776  }
10777  {
10778  Py_DECREF( tmp7 );
10779  }
10780  return resultobj;
10781 fail:
10782  {
10783  Py_DECREF( tmp2 );
10784  }
10785  {
10786  Py_DECREF( tmp4 );
10787  }
10788  {
10789  Py_DECREF( tmp5 );
10790  }
10791  {
10792  Py_DECREF( tmp6 );
10793  }
10794  {
10795  Py_DECREF( tmp7 );
10796  }
10797  return NULL;
10798 }
10799 
10800 
10801 SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10802  PyObject *resultobj = 0;
10803  PLBOOL arg1 ;
10804  PLINT arg2 ;
10805  PLFLT *arg3 = (PLFLT *) 0 ;
10806  PLFLT *arg4 = (PLFLT *) 0 ;
10807  PLFLT *arg5 = (PLFLT *) 0 ;
10808  PLFLT *arg6 = (PLFLT *) 0 ;
10809  PLFLT *arg7 = (PLFLT *) 0 ;
10810  PLBOOL *arg8 = (PLBOOL *) 0 ;
10811  int val1 ;
10812  int ecode1 = 0 ;
10813  PyArrayObject *tmp2 ;
10814  PyArrayObject *tmp4 ;
10815  PyArrayObject *tmp5 ;
10816  PyArrayObject *tmp6 ;
10817  PyArrayObject *tmp7 ;
10818  PyArrayObject *tmp8 ;
10819  PyObject * obj0 = 0 ;
10820  PyObject * obj1 = 0 ;
10821  PyObject * obj2 = 0 ;
10822  PyObject * obj3 = 0 ;
10823  PyObject * obj4 = 0 ;
10824  PyObject * obj5 = 0 ;
10825  PyObject * obj6 = 0 ;
10826 
10827  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10828  ecode1 = SWIG_AsVal_int(obj0, &val1);
10829  if (!SWIG_IsOK(ecode1)) {
10830  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
10831  }
10832  arg1 = (PLBOOL)(val1);
10833  {
10834  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10835  if ( tmp2 == NULL )
10836  return NULL;
10837  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10838  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10839  }
10840  {
10841  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10842  if ( tmp4 == NULL )
10843  return NULL;
10844  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10845  {
10846  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10847  return NULL;
10848  }
10849  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10850  }
10851  {
10852  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10853  if ( tmp5 == NULL )
10854  return NULL;
10855  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10856  {
10857  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10858  return NULL;
10859  }
10860  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10861  }
10862  {
10863  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
10864  if ( tmp6 == NULL )
10865  return NULL;
10866  if ( PyArray_DIMS( tmp6 )[0] != Alen )
10867  {
10868  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10869  return NULL;
10870  }
10871  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10872  }
10873  {
10874  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
10875  if ( tmp7 == NULL )
10876  return NULL;
10877  if ( PyArray_DIMS( tmp7 )[0] != Alen )
10878  {
10879  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10880  return NULL;
10881  }
10882  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
10883  }
10884  {
10885  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
10886  if ( tmp8 == NULL )
10887  return NULL;
10888  if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
10889  {
10890  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10891  return NULL;
10892  }
10893  arg8 = (PLINT *) PyArray_DATA( tmp8 );
10894  }
10895  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
10896  resultobj = SWIG_Py_Void();
10897  {
10898  Py_DECREF( tmp2 );
10899  }
10900  {
10901  Py_DECREF( tmp4 );
10902  }
10903  {
10904  Py_DECREF( tmp5 );
10905  }
10906  {
10907  Py_DECREF( tmp6 );
10908  }
10909  {
10910  Py_DECREF( tmp7 );
10911  }
10912  {
10913  Py_DECREF( tmp8 );
10914  }
10915  return resultobj;
10916 fail:
10917  {
10918  Py_DECREF( tmp2 );
10919  }
10920  {
10921  Py_DECREF( tmp4 );
10922  }
10923  {
10924  Py_DECREF( tmp5 );
10925  }
10926  {
10927  Py_DECREF( tmp6 );
10928  }
10929  {
10930  Py_DECREF( tmp7 );
10931  }
10932  {
10933  Py_DECREF( tmp8 );
10934  }
10935  return NULL;
10936 }
10937 
10938 
10939 SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10940  PyObject *resultobj = 0;
10941  PLINT arg1 ;
10942  int val1 ;
10943  int ecode1 = 0 ;
10944  PyObject * obj0 = 0 ;
10945 
10946  if (!PyArg_ParseTuple(args,(char *)"O:plscmap1n",&obj0)) SWIG_fail;
10947  ecode1 = SWIG_AsVal_int(obj0, &val1);
10948  if (!SWIG_IsOK(ecode1)) {
10949  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
10950  }
10951  arg1 = (PLINT)(val1);
10952  plscmap1n(arg1);
10953  resultobj = SWIG_Py_Void();
10954  return resultobj;
10955 fail:
10956  return NULL;
10957 }
10958 
10959 
10960 SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10961  PyObject *resultobj = 0;
10962  PLFLT arg1 ;
10963  PLFLT arg2 ;
10964  double val1 ;
10965  int ecode1 = 0 ;
10966  double val2 ;
10967  int ecode2 = 0 ;
10968  PyObject * obj0 = 0 ;
10969  PyObject * obj1 = 0 ;
10970 
10971  if (!PyArg_ParseTuple(args,(char *)"OO:plscmap1_range",&obj0,&obj1)) SWIG_fail;
10972  ecode1 = SWIG_AsVal_double(obj0, &val1);
10973  if (!SWIG_IsOK(ecode1)) {
10974  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
10975  }
10976  arg1 = (PLFLT)(val1);
10977  ecode2 = SWIG_AsVal_double(obj1, &val2);
10978  if (!SWIG_IsOK(ecode2)) {
10979  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
10980  }
10981  arg2 = (PLFLT)(val2);
10982  plscmap1_range(arg1,arg2);
10983  resultobj = SWIG_Py_Void();
10984  return resultobj;
10985 fail:
10986  return NULL;
10987 }
10988 
10989 
10990 SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10991  PyObject *resultobj = 0;
10992  PLFLT *arg1 = (PLFLT *) 0 ;
10993  PLFLT *arg2 = (PLFLT *) 0 ;
10994  PLFLT temp1 ;
10995  int res1 = SWIG_TMPOBJ ;
10996  PLFLT temp2 ;
10997  int res2 = SWIG_TMPOBJ ;
10998 
10999  arg1 = &temp1;
11000  arg2 = &temp2;
11001  if (!PyArg_ParseTuple(args,(char *)":plgcmap1_range")) SWIG_fail;
11002  plgcmap1_range(arg1,arg2);
11003  resultobj = SWIG_Py_Void();
11004  if (SWIG_IsTmpObj(res1)) {
11005  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
11006  } else {
11007  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11008  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11009  }
11010  if (SWIG_IsTmpObj(res2)) {
11011  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
11012  } else {
11013  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11014  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11015  }
11016  return resultobj;
11017 fail:
11018  return NULL;
11019 }
11020 
11021 
11022 SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11023  PyObject *resultobj = 0;
11024  PLINT arg1 ;
11025  PLINT arg2 ;
11026  PLINT arg3 ;
11027  PLINT arg4 ;
11028  int val1 ;
11029  int ecode1 = 0 ;
11030  int val2 ;
11031  int ecode2 = 0 ;
11032  int val3 ;
11033  int ecode3 = 0 ;
11034  int val4 ;
11035  int ecode4 = 0 ;
11036  PyObject * obj0 = 0 ;
11037  PyObject * obj1 = 0 ;
11038  PyObject * obj2 = 0 ;
11039  PyObject * obj3 = 0 ;
11040 
11041  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11042  ecode1 = SWIG_AsVal_int(obj0, &val1);
11043  if (!SWIG_IsOK(ecode1)) {
11044  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11045  }
11046  arg1 = (PLINT)(val1);
11047  ecode2 = SWIG_AsVal_int(obj1, &val2);
11048  if (!SWIG_IsOK(ecode2)) {
11049  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11050  }
11051  arg2 = (PLINT)(val2);
11052  ecode3 = SWIG_AsVal_int(obj2, &val3);
11053  if (!SWIG_IsOK(ecode3)) {
11054  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11055  }
11056  arg3 = (PLINT)(val3);
11057  ecode4 = SWIG_AsVal_int(obj3, &val4);
11058  if (!SWIG_IsOK(ecode4)) {
11059  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11060  }
11061  arg4 = (PLINT)(val4);
11062  plscol0(arg1,arg2,arg3,arg4);
11063  resultobj = SWIG_Py_Void();
11064  return resultobj;
11065 fail:
11066  return NULL;
11067 }
11068 
11069 
11070 SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11071  PyObject *resultobj = 0;
11072  PLINT arg1 ;
11073  PLINT arg2 ;
11074  PLINT arg3 ;
11075  PLINT arg4 ;
11076  PLFLT arg5 ;
11077  int val1 ;
11078  int ecode1 = 0 ;
11079  int val2 ;
11080  int ecode2 = 0 ;
11081  int val3 ;
11082  int ecode3 = 0 ;
11083  int val4 ;
11084  int ecode4 = 0 ;
11085  double val5 ;
11086  int ecode5 = 0 ;
11087  PyObject * obj0 = 0 ;
11088  PyObject * obj1 = 0 ;
11089  PyObject * obj2 = 0 ;
11090  PyObject * obj3 = 0 ;
11091  PyObject * obj4 = 0 ;
11092 
11093  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11094  ecode1 = SWIG_AsVal_int(obj0, &val1);
11095  if (!SWIG_IsOK(ecode1)) {
11096  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11097  }
11098  arg1 = (PLINT)(val1);
11099  ecode2 = SWIG_AsVal_int(obj1, &val2);
11100  if (!SWIG_IsOK(ecode2)) {
11101  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11102  }
11103  arg2 = (PLINT)(val2);
11104  ecode3 = SWIG_AsVal_int(obj2, &val3);
11105  if (!SWIG_IsOK(ecode3)) {
11106  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11107  }
11108  arg3 = (PLINT)(val3);
11109  ecode4 = SWIG_AsVal_int(obj3, &val4);
11110  if (!SWIG_IsOK(ecode4)) {
11111  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11112  }
11113  arg4 = (PLINT)(val4);
11114  ecode5 = SWIG_AsVal_double(obj4, &val5);
11115  if (!SWIG_IsOK(ecode5)) {
11116  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11117  }
11118  arg5 = (PLFLT)(val5);
11119  plscol0a(arg1,arg2,arg3,arg4,arg5);
11120  resultobj = SWIG_Py_Void();
11121  return resultobj;
11122 fail:
11123  return NULL;
11124 }
11125 
11126 
11127 SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11128  PyObject *resultobj = 0;
11129  PLINT arg1 ;
11130  PLINT arg2 ;
11131  PLINT arg3 ;
11132  int val1 ;
11133  int ecode1 = 0 ;
11134  int val2 ;
11135  int ecode2 = 0 ;
11136  int val3 ;
11137  int ecode3 = 0 ;
11138  PyObject * obj0 = 0 ;
11139  PyObject * obj1 = 0 ;
11140  PyObject * obj2 = 0 ;
11141 
11142  if (!PyArg_ParseTuple(args,(char *)"OOO:plscolbg",&obj0,&obj1,&obj2)) SWIG_fail;
11143  ecode1 = SWIG_AsVal_int(obj0, &val1);
11144  if (!SWIG_IsOK(ecode1)) {
11145  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11146  }
11147  arg1 = (PLINT)(val1);
11148  ecode2 = SWIG_AsVal_int(obj1, &val2);
11149  if (!SWIG_IsOK(ecode2)) {
11150  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11151  }
11152  arg2 = (PLINT)(val2);
11153  ecode3 = SWIG_AsVal_int(obj2, &val3);
11154  if (!SWIG_IsOK(ecode3)) {
11155  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11156  }
11157  arg3 = (PLINT)(val3);
11158  plscolbg(arg1,arg2,arg3);
11159  resultobj = SWIG_Py_Void();
11160  return resultobj;
11161 fail:
11162  return NULL;
11163 }
11164 
11165 
11166 SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11167  PyObject *resultobj = 0;
11168  PLINT arg1 ;
11169  PLINT arg2 ;
11170  PLINT arg3 ;
11171  PLFLT arg4 ;
11172  int val1 ;
11173  int ecode1 = 0 ;
11174  int val2 ;
11175  int ecode2 = 0 ;
11176  int val3 ;
11177  int ecode3 = 0 ;
11178  double val4 ;
11179  int ecode4 = 0 ;
11180  PyObject * obj0 = 0 ;
11181  PyObject * obj1 = 0 ;
11182  PyObject * obj2 = 0 ;
11183  PyObject * obj3 = 0 ;
11184 
11185  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11186  ecode1 = SWIG_AsVal_int(obj0, &val1);
11187  if (!SWIG_IsOK(ecode1)) {
11188  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11189  }
11190  arg1 = (PLINT)(val1);
11191  ecode2 = SWIG_AsVal_int(obj1, &val2);
11192  if (!SWIG_IsOK(ecode2)) {
11193  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11194  }
11195  arg2 = (PLINT)(val2);
11196  ecode3 = SWIG_AsVal_int(obj2, &val3);
11197  if (!SWIG_IsOK(ecode3)) {
11198  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11199  }
11200  arg3 = (PLINT)(val3);
11201  ecode4 = SWIG_AsVal_double(obj3, &val4);
11202  if (!SWIG_IsOK(ecode4)) {
11203  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11204  }
11205  arg4 = (PLFLT)(val4);
11206  plscolbga(arg1,arg2,arg3,arg4);
11207  resultobj = SWIG_Py_Void();
11208  return resultobj;
11209 fail:
11210  return NULL;
11211 }
11212 
11213 
11214 SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11215  PyObject *resultobj = 0;
11216  PLINT arg1 ;
11217  int val1 ;
11218  int ecode1 = 0 ;
11219  PyObject * obj0 = 0 ;
11220 
11221  if (!PyArg_ParseTuple(args,(char *)"O:plscolor",&obj0)) SWIG_fail;
11222  ecode1 = SWIG_AsVal_int(obj0, &val1);
11223  if (!SWIG_IsOK(ecode1)) {
11224  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11225  }
11226  arg1 = (PLINT)(val1);
11227  plscolor(arg1);
11228  resultobj = SWIG_Py_Void();
11229  return resultobj;
11230 fail:
11231  return NULL;
11232 }
11233 
11234 
11235 SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11236  PyObject *resultobj = 0;
11237  PLINT arg1 ;
11238  int val1 ;
11239  int ecode1 = 0 ;
11240  PyObject * obj0 = 0 ;
11241 
11242  if (!PyArg_ParseTuple(args,(char *)"O:plscompression",&obj0)) SWIG_fail;
11243  ecode1 = SWIG_AsVal_int(obj0, &val1);
11244  if (!SWIG_IsOK(ecode1)) {
11245  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11246  }
11247  arg1 = (PLINT)(val1);
11248  plscompression(arg1);
11249  resultobj = SWIG_Py_Void();
11250  return resultobj;
11251 fail:
11252  return NULL;
11253 }
11254 
11255 
11256 SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11257  PyObject *resultobj = 0;
11258  char *arg1 = (char *) 0 ;
11259  int res1 ;
11260  char *buf1 = 0 ;
11261  int alloc1 = 0 ;
11262  PyObject * obj0 = 0 ;
11263 
11264  if (!PyArg_ParseTuple(args,(char *)"O:plsdev",&obj0)) SWIG_fail;
11265  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11266  if (!SWIG_IsOK(res1)) {
11267  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11268  }
11269  arg1 = (char *)(buf1);
11270  plsdev((char const *)arg1);
11271  resultobj = SWIG_Py_Void();
11272  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11273  return resultobj;
11274 fail:
11275  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11276  return NULL;
11277 }
11278 
11279 
11280 SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11281  PyObject *resultobj = 0;
11282  PLFLT arg1 ;
11283  PLFLT arg2 ;
11284  PLFLT arg3 ;
11285  PLFLT arg4 ;
11286  double val1 ;
11287  int ecode1 = 0 ;
11288  double val2 ;
11289  int ecode2 = 0 ;
11290  double val3 ;
11291  int ecode3 = 0 ;
11292  double val4 ;
11293  int ecode4 = 0 ;
11294  PyObject * obj0 = 0 ;
11295  PyObject * obj1 = 0 ;
11296  PyObject * obj2 = 0 ;
11297  PyObject * obj3 = 0 ;
11298 
11299  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11300  ecode1 = SWIG_AsVal_double(obj0, &val1);
11301  if (!SWIG_IsOK(ecode1)) {
11302  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11303  }
11304  arg1 = (PLFLT)(val1);
11305  ecode2 = SWIG_AsVal_double(obj1, &val2);
11306  if (!SWIG_IsOK(ecode2)) {
11307  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11308  }
11309  arg2 = (PLFLT)(val2);
11310  ecode3 = SWIG_AsVal_double(obj2, &val3);
11311  if (!SWIG_IsOK(ecode3)) {
11312  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11313  }
11314  arg3 = (PLFLT)(val3);
11315  ecode4 = SWIG_AsVal_double(obj3, &val4);
11316  if (!SWIG_IsOK(ecode4)) {
11317  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11318  }
11319  arg4 = (PLFLT)(val4);
11320  plsdidev(arg1,arg2,arg3,arg4);
11321  resultobj = SWIG_Py_Void();
11322  return resultobj;
11323 fail:
11324  return NULL;
11325 }
11326 
11327 
11328 SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11329  PyObject *resultobj = 0;
11330  PLINT arg1 ;
11331  PLINT arg2 ;
11332  PLINT arg3 ;
11333  PLINT arg4 ;
11334  PLFLT arg5 ;
11335  PLFLT arg6 ;
11336  int val1 ;
11337  int ecode1 = 0 ;
11338  int val2 ;
11339  int ecode2 = 0 ;
11340  int val3 ;
11341  int ecode3 = 0 ;
11342  int val4 ;
11343  int ecode4 = 0 ;
11344  double val5 ;
11345  int ecode5 = 0 ;
11346  double val6 ;
11347  int ecode6 = 0 ;
11348  PyObject * obj0 = 0 ;
11349  PyObject * obj1 = 0 ;
11350  PyObject * obj2 = 0 ;
11351  PyObject * obj3 = 0 ;
11352  PyObject * obj4 = 0 ;
11353  PyObject * obj5 = 0 ;
11354 
11355  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
11356  ecode1 = SWIG_AsVal_int(obj0, &val1);
11357  if (!SWIG_IsOK(ecode1)) {
11358  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11359  }
11360  arg1 = (PLINT)(val1);
11361  ecode2 = SWIG_AsVal_int(obj1, &val2);
11362  if (!SWIG_IsOK(ecode2)) {
11363  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11364  }
11365  arg2 = (PLINT)(val2);
11366  ecode3 = SWIG_AsVal_int(obj2, &val3);
11367  if (!SWIG_IsOK(ecode3)) {
11368  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11369  }
11370  arg3 = (PLINT)(val3);
11371  ecode4 = SWIG_AsVal_int(obj3, &val4);
11372  if (!SWIG_IsOK(ecode4)) {
11373  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11374  }
11375  arg4 = (PLINT)(val4);
11376  ecode5 = SWIG_AsVal_double(obj4, &val5);
11377  if (!SWIG_IsOK(ecode5)) {
11378  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11379  }
11380  arg5 = (PLFLT)(val5);
11381  ecode6 = SWIG_AsVal_double(obj5, &val6);
11382  if (!SWIG_IsOK(ecode6)) {
11383  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11384  }
11385  arg6 = (PLFLT)(val6);
11386  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11387  resultobj = SWIG_Py_Void();
11388  return resultobj;
11389 fail:
11390  return NULL;
11391 }
11392 
11393 
11394 SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11395  PyObject *resultobj = 0;
11396  PLFLT arg1 ;
11397  double val1 ;
11398  int ecode1 = 0 ;
11399  PyObject * obj0 = 0 ;
11400 
11401  if (!PyArg_ParseTuple(args,(char *)"O:plsdiori",&obj0)) SWIG_fail;
11402  ecode1 = SWIG_AsVal_double(obj0, &val1);
11403  if (!SWIG_IsOK(ecode1)) {
11404  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11405  }
11406  arg1 = (PLFLT)(val1);
11407  plsdiori(arg1);
11408  resultobj = SWIG_Py_Void();
11409  return resultobj;
11410 fail:
11411  return NULL;
11412 }
11413 
11414 
11415 SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11416  PyObject *resultobj = 0;
11417  PLFLT arg1 ;
11418  PLFLT arg2 ;
11419  PLFLT arg3 ;
11420  PLFLT arg4 ;
11421  double val1 ;
11422  int ecode1 = 0 ;
11423  double val2 ;
11424  int ecode2 = 0 ;
11425  double val3 ;
11426  int ecode3 = 0 ;
11427  double val4 ;
11428  int ecode4 = 0 ;
11429  PyObject * obj0 = 0 ;
11430  PyObject * obj1 = 0 ;
11431  PyObject * obj2 = 0 ;
11432  PyObject * obj3 = 0 ;
11433 
11434  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11435  ecode1 = SWIG_AsVal_double(obj0, &val1);
11436  if (!SWIG_IsOK(ecode1)) {
11437  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11438  }
11439  arg1 = (PLFLT)(val1);
11440  ecode2 = SWIG_AsVal_double(obj1, &val2);
11441  if (!SWIG_IsOK(ecode2)) {
11442  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11443  }
11444  arg2 = (PLFLT)(val2);
11445  ecode3 = SWIG_AsVal_double(obj2, &val3);
11446  if (!SWIG_IsOK(ecode3)) {
11447  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11448  }
11449  arg3 = (PLFLT)(val3);
11450  ecode4 = SWIG_AsVal_double(obj3, &val4);
11451  if (!SWIG_IsOK(ecode4)) {
11452  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11453  }
11454  arg4 = (PLFLT)(val4);
11455  plsdiplt(arg1,arg2,arg3,arg4);
11456  resultobj = SWIG_Py_Void();
11457  return resultobj;
11458 fail:
11459  return NULL;
11460 }
11461 
11462 
11463 SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11464  PyObject *resultobj = 0;
11465  PLFLT arg1 ;
11466  PLFLT arg2 ;
11467  PLFLT arg3 ;
11468  PLFLT arg4 ;
11469  double val1 ;
11470  int ecode1 = 0 ;
11471  double val2 ;
11472  int ecode2 = 0 ;
11473  double val3 ;
11474  int ecode3 = 0 ;
11475  double val4 ;
11476  int ecode4 = 0 ;
11477  PyObject * obj0 = 0 ;
11478  PyObject * obj1 = 0 ;
11479  PyObject * obj2 = 0 ;
11480  PyObject * obj3 = 0 ;
11481 
11482  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11483  ecode1 = SWIG_AsVal_double(obj0, &val1);
11484  if (!SWIG_IsOK(ecode1)) {
11485  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11486  }
11487  arg1 = (PLFLT)(val1);
11488  ecode2 = SWIG_AsVal_double(obj1, &val2);
11489  if (!SWIG_IsOK(ecode2)) {
11490  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11491  }
11492  arg2 = (PLFLT)(val2);
11493  ecode3 = SWIG_AsVal_double(obj2, &val3);
11494  if (!SWIG_IsOK(ecode3)) {
11495  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11496  }
11497  arg3 = (PLFLT)(val3);
11498  ecode4 = SWIG_AsVal_double(obj3, &val4);
11499  if (!SWIG_IsOK(ecode4)) {
11500  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11501  }
11502  arg4 = (PLFLT)(val4);
11503  plsdiplz(arg1,arg2,arg3,arg4);
11504  resultobj = SWIG_Py_Void();
11505  return resultobj;
11506 fail:
11507  return NULL;
11508 }
11509 
11510 
11511 SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11512  PyObject *resultobj = 0;
11513  unsigned int arg1 ;
11514  unsigned int val1 ;
11515  int ecode1 = 0 ;
11516  PyObject * obj0 = 0 ;
11517 
11518  if (!PyArg_ParseTuple(args,(char *)"O:plseed",&obj0)) SWIG_fail;
11519  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11520  if (!SWIG_IsOK(ecode1)) {
11521  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11522  }
11523  arg1 = (unsigned int)(val1);
11524  plseed(arg1);
11525  resultobj = SWIG_Py_Void();
11526  return resultobj;
11527 fail:
11528  return NULL;
11529 }
11530 
11531 
11532 SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11533  PyObject *resultobj = 0;
11534  char arg1 ;
11535  char val1 ;
11536  int ecode1 = 0 ;
11537  PyObject * obj0 = 0 ;
11538 
11539  if (!PyArg_ParseTuple(args,(char *)"O:plsesc",&obj0)) SWIG_fail;
11540  ecode1 = SWIG_AsVal_char(obj0, &val1);
11541  if (!SWIG_IsOK(ecode1)) {
11542  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11543  }
11544  arg1 = (char)(val1);
11545  plsesc(arg1);
11546  resultobj = SWIG_Py_Void();
11547  return resultobj;
11548 fail:
11549  return NULL;
11550 }
11551 
11552 
11553 SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11554  PyObject *resultobj = 0;
11555  char *arg1 = (char *) 0 ;
11556  char *arg2 = (char *) 0 ;
11557  int res1 ;
11558  char *buf1 = 0 ;
11559  int alloc1 = 0 ;
11560  int res2 ;
11561  char *buf2 = 0 ;
11562  int alloc2 = 0 ;
11563  PyObject * obj0 = 0 ;
11564  PyObject * obj1 = 0 ;
11565  PLINT result;
11566 
11567  if (!PyArg_ParseTuple(args,(char *)"OO:plsetopt",&obj0,&obj1)) SWIG_fail;
11568  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11569  if (!SWIG_IsOK(res1)) {
11570  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11571  }
11572  arg1 = (char *)(buf1);
11573  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11574  if (!SWIG_IsOK(res2)) {
11575  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11576  }
11577  arg2 = (char *)(buf2);
11578  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11579  resultobj = SWIG_From_int((int)(result));
11580  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11581  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11582  return resultobj;
11583 fail:
11584  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11585  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11586  return NULL;
11587 }
11588 
11589 
11590 SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11591  PyObject *resultobj = 0;
11592  PLINT arg1 ;
11593  PLINT arg2 ;
11594  PLINT arg3 ;
11595  int val1 ;
11596  int ecode1 = 0 ;
11597  int val2 ;
11598  int ecode2 = 0 ;
11599  int val3 ;
11600  int ecode3 = 0 ;
11601  PyObject * obj0 = 0 ;
11602  PyObject * obj1 = 0 ;
11603  PyObject * obj2 = 0 ;
11604 
11605  if (!PyArg_ParseTuple(args,(char *)"OOO:plsfam",&obj0,&obj1,&obj2)) SWIG_fail;
11606  ecode1 = SWIG_AsVal_int(obj0, &val1);
11607  if (!SWIG_IsOK(ecode1)) {
11608  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11609  }
11610  arg1 = (PLINT)(val1);
11611  ecode2 = SWIG_AsVal_int(obj1, &val2);
11612  if (!SWIG_IsOK(ecode2)) {
11613  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11614  }
11615  arg2 = (PLINT)(val2);
11616  ecode3 = SWIG_AsVal_int(obj2, &val3);
11617  if (!SWIG_IsOK(ecode3)) {
11618  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11619  }
11620  arg3 = (PLINT)(val3);
11621  plsfam(arg1,arg2,arg3);
11622  resultobj = SWIG_Py_Void();
11623  return resultobj;
11624 fail:
11625  return NULL;
11626 }
11627 
11628 
11629 SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11630  PyObject *resultobj = 0;
11631  PLUNICODE arg1 ;
11632  unsigned int val1 ;
11633  int ecode1 = 0 ;
11634  PyObject * obj0 = 0 ;
11635 
11636  if (!PyArg_ParseTuple(args,(char *)"O:plsfci",&obj0)) SWIG_fail;
11637  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11638  if (!SWIG_IsOK(ecode1)) {
11639  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11640  }
11641  arg1 = (PLUNICODE)(val1);
11642  plsfci(arg1);
11643  resultobj = SWIG_Py_Void();
11644  return resultobj;
11645 fail:
11646  return NULL;
11647 }
11648 
11649 
11650 SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11651  PyObject *resultobj = 0;
11652  char *arg1 = (char *) 0 ;
11653  int res1 ;
11654  char *buf1 = 0 ;
11655  int alloc1 = 0 ;
11656  PyObject * obj0 = 0 ;
11657 
11658  if (!PyArg_ParseTuple(args,(char *)"O:plsfnam",&obj0)) SWIG_fail;
11659  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11660  if (!SWIG_IsOK(res1)) {
11661  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11662  }
11663  arg1 = (char *)(buf1);
11664  plsfnam((char const *)arg1);
11665  resultobj = SWIG_Py_Void();
11666  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11667  return resultobj;
11668 fail:
11669  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11670  return NULL;
11671 }
11672 
11673 
11674 SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11675  PyObject *resultobj = 0;
11676  PLINT arg1 ;
11677  PLINT arg2 ;
11678  PLINT arg3 ;
11679  int val1 ;
11680  int ecode1 = 0 ;
11681  int val2 ;
11682  int ecode2 = 0 ;
11683  int val3 ;
11684  int ecode3 = 0 ;
11685  PyObject * obj0 = 0 ;
11686  PyObject * obj1 = 0 ;
11687  PyObject * obj2 = 0 ;
11688 
11689  if (!PyArg_ParseTuple(args,(char *)"OOO:plsfont",&obj0,&obj1,&obj2)) SWIG_fail;
11690  ecode1 = SWIG_AsVal_int(obj0, &val1);
11691  if (!SWIG_IsOK(ecode1)) {
11692  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11693  }
11694  arg1 = (PLINT)(val1);
11695  ecode2 = SWIG_AsVal_int(obj1, &val2);
11696  if (!SWIG_IsOK(ecode2)) {
11697  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11698  }
11699  arg2 = (PLINT)(val2);
11700  ecode3 = SWIG_AsVal_int(obj2, &val3);
11701  if (!SWIG_IsOK(ecode3)) {
11702  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11703  }
11704  arg3 = (PLINT)(val3);
11705  plsfont(arg1,arg2,arg3);
11706  resultobj = SWIG_Py_Void();
11707  return resultobj;
11708 fail:
11709  return NULL;
11710 }
11711 
11712 
11713 SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11714  PyObject *resultobj = 0;
11715  PLFLT **arg1 = (PLFLT **) 0 ;
11716  PLINT arg2 ;
11717  PLINT arg3 ;
11718  defined_func arg4 = (defined_func) 0 ;
11719  PLFLT arg5 ;
11720  PLFLT arg6 ;
11721  PLFLT arg7 ;
11722  PLFLT arg8 ;
11723  PLFLT *arg9 = (PLFLT *) 0 ;
11724  PLINT arg10 ;
11725  PLFLT arg11 ;
11726  PLINT arg12 ;
11727  PLFLT arg13 ;
11728  fill_func arg14 = (fill_func) 0 ;
11729  PLBOOL arg15 ;
11730  pltr_func arg16 = (pltr_func) 0 ;
11731  PLPointer arg17 = (PLPointer) 0 ;
11732  PyArrayObject *tmp1 ;
11733  double val5 ;
11734  int ecode5 = 0 ;
11735  double val6 ;
11736  int ecode6 = 0 ;
11737  double val7 ;
11738  int ecode7 = 0 ;
11739  double val8 ;
11740  int ecode8 = 0 ;
11741  PyArrayObject *tmp9 ;
11742  double val11 ;
11743  int ecode11 = 0 ;
11744  int val12 ;
11745  int ecode12 = 0 ;
11746  double val13 ;
11747  int ecode13 = 0 ;
11748  int val15 ;
11749  int ecode15 = 0 ;
11750  PyObject * obj0 = 0 ;
11751  PyObject * obj1 = 0 ;
11752  PyObject * obj2 = 0 ;
11753  PyObject * obj3 = 0 ;
11754  PyObject * obj4 = 0 ;
11755  PyObject * obj5 = 0 ;
11756  PyObject * obj6 = 0 ;
11757  PyObject * obj7 = 0 ;
11758  PyObject * obj8 = 0 ;
11759  PyObject * obj9 = 0 ;
11760  PyObject * obj10 = 0 ;
11761  PyObject * obj11 = 0 ;
11762 
11763  {
11764  python_pltr = 0;
11765  arg16 = NULL;
11766  }
11767  {
11768  arg17 = NULL;
11769  }
11770  {
11771  arg4 = NULL;
11772  }
11773  {
11774  arg14 = plfill;
11775  }
11776  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
11777  {
11778  int i, size;
11779  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
11780  if ( tmp1 == NULL )
11781  return NULL;
11782  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11783  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11784  size = sizeof ( PLFLT ) * arg3;
11785  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
11786  for ( i = 0; i < arg2; i++ )
11787  arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
11788  }
11789  ecode5 = SWIG_AsVal_double(obj1, &val5);
11790  if (!SWIG_IsOK(ecode5)) {
11791  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
11792  }
11793  arg5 = (PLFLT)(val5);
11794  ecode6 = SWIG_AsVal_double(obj2, &val6);
11795  if (!SWIG_IsOK(ecode6)) {
11796  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
11797  }
11798  arg6 = (PLFLT)(val6);
11799  ecode7 = SWIG_AsVal_double(obj3, &val7);
11800  if (!SWIG_IsOK(ecode7)) {
11801  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
11802  }
11803  arg7 = (PLFLT)(val7);
11804  ecode8 = SWIG_AsVal_double(obj4, &val8);
11805  if (!SWIG_IsOK(ecode8)) {
11806  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
11807  }
11808  arg8 = (PLFLT)(val8);
11809  {
11810  tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
11811  if ( tmp9 == NULL )
11812  return NULL;
11813  arg10 = PyArray_DIMS( tmp9 )[0];
11814  arg9 = (PLFLT *) PyArray_DATA( tmp9 );
11815  }
11816  ecode11 = SWIG_AsVal_double(obj6, &val11);
11817  if (!SWIG_IsOK(ecode11)) {
11818  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
11819  }
11820  arg11 = (PLFLT)(val11);
11821  ecode12 = SWIG_AsVal_int(obj7, &val12);
11822  if (!SWIG_IsOK(ecode12)) {
11823  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
11824  }
11825  arg12 = (PLINT)(val12);
11826  ecode13 = SWIG_AsVal_double(obj8, &val13);
11827  if (!SWIG_IsOK(ecode13)) {
11828  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
11829  }
11830  arg13 = (PLFLT)(val13);
11831  ecode15 = SWIG_AsVal_int(obj9, &val15);
11832  if (!SWIG_IsOK(ecode15)) {
11833  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
11834  }
11835  arg15 = (PLBOOL)(val15);
11836  if (obj10) {
11837  {
11838  // it must be a callable or None
11839  if ( obj10 == Py_None )
11840  {
11841  arg16 = NULL;
11842  }
11843  else
11844  {
11845  if ( !PyCallable_Check( (PyObject *) obj10 ) )
11846  {
11847  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11848  return NULL;
11849  }
11850  arg16 = marshal_pltr( obj10 );
11851  }
11852  }
11853  }
11854  if (obj11) {
11855  {
11856  if ( obj11 == Py_None )
11857  arg17 = NULL;
11858  else
11859  {
11860  arg17 = marshal_PLPointer( obj11, 0 );
11861  }
11862  }
11863  }
11864  plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11865  resultobj = SWIG_Py_Void();
11866  {
11867  Py_DECREF( tmp1 );
11868  free( arg1 );
11869  }
11870  {
11871  Py_DECREF( tmp9 );
11872  }
11873  {
11874  cleanup_pltr();
11875  }
11876  {
11878  }
11879  return resultobj;
11880 fail:
11881  {
11882  Py_DECREF( tmp1 );
11883  free( arg1 );
11884  }
11885  {
11886  Py_DECREF( tmp9 );
11887  }
11888  {
11889  cleanup_pltr();
11890  }
11891  {
11893  }
11894  return NULL;
11895 }
11896 
11897 
11898 SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11899  PyObject *resultobj = 0;
11900  PLFLT **arg1 = (PLFLT **) 0 ;
11901  PLINT arg2 ;
11902  PLINT arg3 ;
11903  defined_func arg4 = (defined_func) 0 ;
11904  PLFLT arg5 ;
11905  PLFLT arg6 ;
11906  PLFLT arg7 ;
11907  PLFLT arg8 ;
11908  PLFLT arg9 ;
11909  PLFLT arg10 ;
11910  PLINT arg11 ;
11911  PLFLT arg12 ;
11912  PLFLT arg13 ;
11913  PLINT arg14 ;
11914  PLFLT arg15 ;
11915  PLINT arg16 ;
11916  PLFLT arg17 ;
11917  fill_func arg18 = (fill_func) 0 ;
11918  PLBOOL arg19 ;
11919  pltr_func arg20 = (pltr_func) 0 ;
11920  PLPointer arg21 = (PLPointer) 0 ;
11921  PyArrayObject *tmp1 ;
11922  double val5 ;
11923  int ecode5 = 0 ;
11924  double val6 ;
11925  int ecode6 = 0 ;
11926  double val7 ;
11927  int ecode7 = 0 ;
11928  double val8 ;
11929  int ecode8 = 0 ;
11930  double val9 ;
11931  int ecode9 = 0 ;
11932  double val10 ;
11933  int ecode10 = 0 ;
11934  int val11 ;
11935  int ecode11 = 0 ;
11936  double val12 ;
11937  int ecode12 = 0 ;
11938  double val13 ;
11939  int ecode13 = 0 ;
11940  int val14 ;
11941  int ecode14 = 0 ;
11942  double val15 ;
11943  int ecode15 = 0 ;
11944  int val16 ;
11945  int ecode16 = 0 ;
11946  double val17 ;
11947  int ecode17 = 0 ;
11948  int val19 ;
11949  int ecode19 = 0 ;
11950  PyObject * obj0 = 0 ;
11951  PyObject * obj1 = 0 ;
11952  PyObject * obj2 = 0 ;
11953  PyObject * obj3 = 0 ;
11954  PyObject * obj4 = 0 ;
11955  PyObject * obj5 = 0 ;
11956  PyObject * obj6 = 0 ;
11957  PyObject * obj7 = 0 ;
11958  PyObject * obj8 = 0 ;
11959  PyObject * obj9 = 0 ;
11960  PyObject * obj10 = 0 ;
11961  PyObject * obj11 = 0 ;
11962  PyObject * obj12 = 0 ;
11963  PyObject * obj13 = 0 ;
11964  PyObject * obj14 = 0 ;
11965  PyObject * obj15 = 0 ;
11966  PyObject * obj16 = 0 ;
11967 
11968  {
11969  python_pltr = 0;
11970  arg20 = NULL;
11971  }
11972  {
11973  arg21 = NULL;
11974  }
11975  {
11976  arg4 = NULL;
11977  }
11978  {
11979  arg18 = plfill;
11980  }
11981  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO|OO:plshade",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
11982  {
11983  int i, size;
11984  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
11985  if ( tmp1 == NULL )
11986  return NULL;
11987  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11988  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11989  size = sizeof ( PLFLT ) * arg3;
11990  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
11991  for ( i = 0; i < arg2; i++ )
11992  arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
11993  }
11994  ecode5 = SWIG_AsVal_double(obj1, &val5);
11995  if (!SWIG_IsOK(ecode5)) {
11996  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
11997  }
11998  arg5 = (PLFLT)(val5);
11999  ecode6 = SWIG_AsVal_double(obj2, &val6);
12000  if (!SWIG_IsOK(ecode6)) {
12001  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12002  }
12003  arg6 = (PLFLT)(val6);
12004  ecode7 = SWIG_AsVal_double(obj3, &val7);
12005  if (!SWIG_IsOK(ecode7)) {
12006  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12007  }
12008  arg7 = (PLFLT)(val7);
12009  ecode8 = SWIG_AsVal_double(obj4, &val8);
12010  if (!SWIG_IsOK(ecode8)) {
12011  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12012  }
12013  arg8 = (PLFLT)(val8);
12014  ecode9 = SWIG_AsVal_double(obj5, &val9);
12015  if (!SWIG_IsOK(ecode9)) {
12016  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12017  }
12018  arg9 = (PLFLT)(val9);
12019  ecode10 = SWIG_AsVal_double(obj6, &val10);
12020  if (!SWIG_IsOK(ecode10)) {
12021  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12022  }
12023  arg10 = (PLFLT)(val10);
12024  ecode11 = SWIG_AsVal_int(obj7, &val11);
12025  if (!SWIG_IsOK(ecode11)) {
12026  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12027  }
12028  arg11 = (PLINT)(val11);
12029  ecode12 = SWIG_AsVal_double(obj8, &val12);
12030  if (!SWIG_IsOK(ecode12)) {
12031  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12032  }
12033  arg12 = (PLFLT)(val12);
12034  ecode13 = SWIG_AsVal_double(obj9, &val13);
12035  if (!SWIG_IsOK(ecode13)) {
12036  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12037  }
12038  arg13 = (PLFLT)(val13);
12039  ecode14 = SWIG_AsVal_int(obj10, &val14);
12040  if (!SWIG_IsOK(ecode14)) {
12041  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12042  }
12043  arg14 = (PLINT)(val14);
12044  ecode15 = SWIG_AsVal_double(obj11, &val15);
12045  if (!SWIG_IsOK(ecode15)) {
12046  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12047  }
12048  arg15 = (PLFLT)(val15);
12049  ecode16 = SWIG_AsVal_int(obj12, &val16);
12050  if (!SWIG_IsOK(ecode16)) {
12051  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12052  }
12053  arg16 = (PLINT)(val16);
12054  ecode17 = SWIG_AsVal_double(obj13, &val17);
12055  if (!SWIG_IsOK(ecode17)) {
12056  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12057  }
12058  arg17 = (PLFLT)(val17);
12059  ecode19 = SWIG_AsVal_int(obj14, &val19);
12060  if (!SWIG_IsOK(ecode19)) {
12061  SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12062  }
12063  arg19 = (PLBOOL)(val19);
12064  if (obj15) {
12065  {
12066  // it must be a callable or None
12067  if ( obj15 == Py_None )
12068  {
12069  arg20 = NULL;
12070  }
12071  else
12072  {
12073  if ( !PyCallable_Check( (PyObject *) obj15 ) )
12074  {
12075  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12076  return NULL;
12077  }
12078  arg20 = marshal_pltr( obj15 );
12079  }
12080  }
12081  }
12082  if (obj16) {
12083  {
12084  if ( obj16 == Py_None )
12085  arg21 = NULL;
12086  else
12087  {
12088  arg21 = marshal_PLPointer( obj16, 0 );
12089  }
12090  }
12091  }
12092  plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12093  resultobj = SWIG_Py_Void();
12094  {
12095  Py_DECREF( tmp1 );
12096  free( arg1 );
12097  }
12098  {
12099  cleanup_pltr();
12100  }
12101  {
12103  }
12104  return resultobj;
12105 fail:
12106  {
12107  Py_DECREF( tmp1 );
12108  free( arg1 );
12109  }
12110  {
12111  cleanup_pltr();
12112  }
12113  {
12115  }
12116  return NULL;
12117 }
12118 
12119 
12120 SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12121  PyObject *resultobj = 0;
12122  label_func arg1 = (label_func) 0 ;
12123  PLPointer arg2 = (PLPointer) 0 ;
12124  int res2 ;
12125  PyObject * obj0 = 0 ;
12126  PyObject * obj1 = 0 ;
12127 
12128  if (!PyArg_ParseTuple(args,(char *)"OO:plslabelfunc",&obj0,&obj1)) SWIG_fail;
12129  {
12130  // Release reference to previous function if applicable
12131  if ( python_label )
12132  {
12133  Py_XDECREF( python_label );
12134  python_label = 0;
12135  }
12136  // it must be a callable or None
12137  if ( obj0 == Py_None )
12138  {
12139  arg1 = NULL;
12140  }
12141  else
12142  {
12143  if ( !PyCallable_Check( (PyObject *) obj0 ) )
12144  {
12145  PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12146  return NULL;
12147  }
12148  // hold a reference to it
12149  Py_XINCREF( (PyObject *) obj0 );
12150  python_label = (PyObject *) obj0;
12151  // this function handles calling the python function
12152  arg1 = do_label_callback;
12153  }
12154  }
12155  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12156  if (!SWIG_IsOK(res2)) {
12157  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12158  }
12159  plslabelfunc(arg1,arg2);
12160  resultobj = SWIG_Py_Void();
12161  return resultobj;
12162 fail:
12163  return NULL;
12164 }
12165 
12166 
12167 SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12168  PyObject *resultobj = 0;
12169  PLFLT arg1 ;
12170  PLFLT arg2 ;
12171  double val1 ;
12172  int ecode1 = 0 ;
12173  double val2 ;
12174  int ecode2 = 0 ;
12175  PyObject * obj0 = 0 ;
12176  PyObject * obj1 = 0 ;
12177 
12178  if (!PyArg_ParseTuple(args,(char *)"OO:plsmaj",&obj0,&obj1)) SWIG_fail;
12179  ecode1 = SWIG_AsVal_double(obj0, &val1);
12180  if (!SWIG_IsOK(ecode1)) {
12181  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12182  }
12183  arg1 = (PLFLT)(val1);
12184  ecode2 = SWIG_AsVal_double(obj1, &val2);
12185  if (!SWIG_IsOK(ecode2)) {
12186  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12187  }
12188  arg2 = (PLFLT)(val2);
12189  plsmaj(arg1,arg2);
12190  resultobj = SWIG_Py_Void();
12191  return resultobj;
12192 fail:
12193  return NULL;
12194 }
12195 
12196 
12197 SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12198  PyObject *resultobj = 0;
12199  PLINT arg1 ;
12200  PLINT arg2 ;
12201  void *arg3 = (void *) 0 ;
12202  int val1 ;
12203  int ecode1 = 0 ;
12204  int val2 ;
12205  int ecode2 = 0 ;
12206  int res3 ;
12207  Py_ssize_t size3 = 0 ;
12208  void *buf3 = 0 ;
12209  PyObject * obj0 = 0 ;
12210  PyObject * obj1 = 0 ;
12211  PyObject * obj2 = 0 ;
12212 
12213  if (!PyArg_ParseTuple(args,(char *)"OOO:plsmem",&obj0,&obj1,&obj2)) SWIG_fail;
12214  ecode1 = SWIG_AsVal_int(obj0, &val1);
12215  if (!SWIG_IsOK(ecode1)) {
12216  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12217  }
12218  arg1 = (PLINT)(val1);
12219  ecode2 = SWIG_AsVal_int(obj1, &val2);
12220  if (!SWIG_IsOK(ecode2)) {
12221  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12222  }
12223  arg2 = (PLINT)(val2);
12224  {
12225  res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12226  if (res3<0) {
12227  PyErr_Clear();
12228  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12229  }
12230  arg3 = (void *) buf3;
12231  }
12232  plsmem(arg1,arg2,arg3);
12233  resultobj = SWIG_Py_Void();
12234  return resultobj;
12235 fail:
12236  return NULL;
12237 }
12238 
12239 
12240 SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12241  PyObject *resultobj = 0;
12242  PLINT arg1 ;
12243  PLINT arg2 ;
12244  void *arg3 = (void *) 0 ;
12245  int val1 ;
12246  int ecode1 = 0 ;
12247  int val2 ;
12248  int ecode2 = 0 ;
12249  int res3 ;
12250  Py_ssize_t size3 = 0 ;
12251  void *buf3 = 0 ;
12252  PyObject * obj0 = 0 ;
12253  PyObject * obj1 = 0 ;
12254  PyObject * obj2 = 0 ;
12255 
12256  if (!PyArg_ParseTuple(args,(char *)"OOO:plsmema",&obj0,&obj1,&obj2)) SWIG_fail;
12257  ecode1 = SWIG_AsVal_int(obj0, &val1);
12258  if (!SWIG_IsOK(ecode1)) {
12259  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12260  }
12261  arg1 = (PLINT)(val1);
12262  ecode2 = SWIG_AsVal_int(obj1, &val2);
12263  if (!SWIG_IsOK(ecode2)) {
12264  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12265  }
12266  arg2 = (PLINT)(val2);
12267  {
12268  res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12269  if (res3<0) {
12270  PyErr_Clear();
12271  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12272  }
12273  arg3 = (void *) buf3;
12274  }
12275  plsmema(arg1,arg2,arg3);
12276  resultobj = SWIG_Py_Void();
12277  return resultobj;
12278 fail:
12279  return NULL;
12280 }
12281 
12282 
12283 SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12284  PyObject *resultobj = 0;
12285  PLFLT arg1 ;
12286  PLFLT arg2 ;
12287  double val1 ;
12288  int ecode1 = 0 ;
12289  double val2 ;
12290  int ecode2 = 0 ;
12291  PyObject * obj0 = 0 ;
12292  PyObject * obj1 = 0 ;
12293 
12294  if (!PyArg_ParseTuple(args,(char *)"OO:plsmin",&obj0,&obj1)) SWIG_fail;
12295  ecode1 = SWIG_AsVal_double(obj0, &val1);
12296  if (!SWIG_IsOK(ecode1)) {
12297  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12298  }
12299  arg1 = (PLFLT)(val1);
12300  ecode2 = SWIG_AsVal_double(obj1, &val2);
12301  if (!SWIG_IsOK(ecode2)) {
12302  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12303  }
12304  arg2 = (PLFLT)(val2);
12305  plsmin(arg1,arg2);
12306  resultobj = SWIG_Py_Void();
12307  return resultobj;
12308 fail:
12309  return NULL;
12310 }
12311 
12312 
12313 SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12314  PyObject *resultobj = 0;
12315  PLINT arg1 ;
12316  int val1 ;
12317  int ecode1 = 0 ;
12318  PyObject * obj0 = 0 ;
12319 
12320  if (!PyArg_ParseTuple(args,(char *)"O:plsori",&obj0)) SWIG_fail;
12321  ecode1 = SWIG_AsVal_int(obj0, &val1);
12322  if (!SWIG_IsOK(ecode1)) {
12323  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12324  }
12325  arg1 = (PLINT)(val1);
12326  plsori(arg1);
12327  resultobj = SWIG_Py_Void();
12328  return resultobj;
12329 fail:
12330  return NULL;
12331 }
12332 
12333 
12334 SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12335  PyObject *resultobj = 0;
12336  PLFLT arg1 ;
12337  PLFLT arg2 ;
12338  PLINT arg3 ;
12339  PLINT arg4 ;
12340  PLINT arg5 ;
12341  PLINT arg6 ;
12342  double val1 ;
12343  int ecode1 = 0 ;
12344  double val2 ;
12345  int ecode2 = 0 ;
12346  int val3 ;
12347  int ecode3 = 0 ;
12348  int val4 ;
12349  int ecode4 = 0 ;
12350  int val5 ;
12351  int ecode5 = 0 ;
12352  int val6 ;
12353  int ecode6 = 0 ;
12354  PyObject * obj0 = 0 ;
12355  PyObject * obj1 = 0 ;
12356  PyObject * obj2 = 0 ;
12357  PyObject * obj3 = 0 ;
12358  PyObject * obj4 = 0 ;
12359  PyObject * obj5 = 0 ;
12360 
12361  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
12362  ecode1 = SWIG_AsVal_double(obj0, &val1);
12363  if (!SWIG_IsOK(ecode1)) {
12364  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12365  }
12366  arg1 = (PLFLT)(val1);
12367  ecode2 = SWIG_AsVal_double(obj1, &val2);
12368  if (!SWIG_IsOK(ecode2)) {
12369  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12370  }
12371  arg2 = (PLFLT)(val2);
12372  ecode3 = SWIG_AsVal_int(obj2, &val3);
12373  if (!SWIG_IsOK(ecode3)) {
12374  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12375  }
12376  arg3 = (PLINT)(val3);
12377  ecode4 = SWIG_AsVal_int(obj3, &val4);
12378  if (!SWIG_IsOK(ecode4)) {
12379  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12380  }
12381  arg4 = (PLINT)(val4);
12382  ecode5 = SWIG_AsVal_int(obj4, &val5);
12383  if (!SWIG_IsOK(ecode5)) {
12384  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12385  }
12386  arg5 = (PLINT)(val5);
12387  ecode6 = SWIG_AsVal_int(obj5, &val6);
12388  if (!SWIG_IsOK(ecode6)) {
12389  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12390  }
12391  arg6 = (PLINT)(val6);
12392  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12393  resultobj = SWIG_Py_Void();
12394  return resultobj;
12395 fail:
12396  return NULL;
12397 }
12398 
12399 
12400 SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12401  PyObject *resultobj = 0;
12402  char *arg1 = (char *) 0 ;
12403  int res1 ;
12404  char *buf1 = 0 ;
12405  int alloc1 = 0 ;
12406  PyObject * obj0 = 0 ;
12407 
12408  if (!PyArg_ParseTuple(args,(char *)"O:plspal0",&obj0)) SWIG_fail;
12409  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12410  if (!SWIG_IsOK(res1)) {
12411  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12412  }
12413  arg1 = (char *)(buf1);
12414  plspal0((char const *)arg1);
12415  resultobj = SWIG_Py_Void();
12416  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12417  return resultobj;
12418 fail:
12419  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12420  return NULL;
12421 }
12422 
12423 
12424 SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12425  PyObject *resultobj = 0;
12426  char *arg1 = (char *) 0 ;
12427  PLBOOL arg2 ;
12428  int res1 ;
12429  char *buf1 = 0 ;
12430  int alloc1 = 0 ;
12431  int val2 ;
12432  int ecode2 = 0 ;
12433  PyObject * obj0 = 0 ;
12434  PyObject * obj1 = 0 ;
12435 
12436  if (!PyArg_ParseTuple(args,(char *)"OO:plspal1",&obj0,&obj1)) SWIG_fail;
12437  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12438  if (!SWIG_IsOK(res1)) {
12439  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12440  }
12441  arg1 = (char *)(buf1);
12442  ecode2 = SWIG_AsVal_int(obj1, &val2);
12443  if (!SWIG_IsOK(ecode2)) {
12444  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12445  }
12446  arg2 = (PLBOOL)(val2);
12447  plspal1((char const *)arg1,arg2);
12448  resultobj = SWIG_Py_Void();
12449  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12450  return resultobj;
12451 fail:
12452  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12453  return NULL;
12454 }
12455 
12456 
12457 SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12458  PyObject *resultobj = 0;
12459  PLBOOL arg1 ;
12460  int val1 ;
12461  int ecode1 = 0 ;
12462  PyObject * obj0 = 0 ;
12463 
12464  if (!PyArg_ParseTuple(args,(char *)"O:plspause",&obj0)) SWIG_fail;
12465  ecode1 = SWIG_AsVal_int(obj0, &val1);
12466  if (!SWIG_IsOK(ecode1)) {
12467  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12468  }
12469  arg1 = (PLBOOL)(val1);
12470  plspause(arg1);
12471  resultobj = SWIG_Py_Void();
12472  return resultobj;
12473 fail:
12474  return NULL;
12475 }
12476 
12477 
12478 SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12479  PyObject *resultobj = 0;
12480  PLINT arg1 ;
12481  int val1 ;
12482  int ecode1 = 0 ;
12483  PyObject * obj0 = 0 ;
12484 
12485  if (!PyArg_ParseTuple(args,(char *)"O:plsstrm",&obj0)) SWIG_fail;
12486  ecode1 = SWIG_AsVal_int(obj0, &val1);
12487  if (!SWIG_IsOK(ecode1)) {
12488  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12489  }
12490  arg1 = (PLINT)(val1);
12491  plsstrm(arg1);
12492  resultobj = SWIG_Py_Void();
12493  return resultobj;
12494 fail:
12495  return NULL;
12496 }
12497 
12498 
12499 SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12500  PyObject *resultobj = 0;
12501  PLINT arg1 ;
12502  PLINT arg2 ;
12503  int val1 ;
12504  int ecode1 = 0 ;
12505  int val2 ;
12506  int ecode2 = 0 ;
12507  PyObject * obj0 = 0 ;
12508  PyObject * obj1 = 0 ;
12509 
12510  if (!PyArg_ParseTuple(args,(char *)"OO:plssub",&obj0,&obj1)) SWIG_fail;
12511  ecode1 = SWIG_AsVal_int(obj0, &val1);
12512  if (!SWIG_IsOK(ecode1)) {
12513  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12514  }
12515  arg1 = (PLINT)(val1);
12516  ecode2 = SWIG_AsVal_int(obj1, &val2);
12517  if (!SWIG_IsOK(ecode2)) {
12518  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12519  }
12520  arg2 = (PLINT)(val2);
12521  plssub(arg1,arg2);
12522  resultobj = SWIG_Py_Void();
12523  return resultobj;
12524 fail:
12525  return NULL;
12526 }
12527 
12528 
12529 SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12530  PyObject *resultobj = 0;
12531  PLFLT arg1 ;
12532  PLFLT arg2 ;
12533  double val1 ;
12534  int ecode1 = 0 ;
12535  double val2 ;
12536  int ecode2 = 0 ;
12537  PyObject * obj0 = 0 ;
12538  PyObject * obj1 = 0 ;
12539 
12540  if (!PyArg_ParseTuple(args,(char *)"OO:plssym",&obj0,&obj1)) SWIG_fail;
12541  ecode1 = SWIG_AsVal_double(obj0, &val1);
12542  if (!SWIG_IsOK(ecode1)) {
12543  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12544  }
12545  arg1 = (PLFLT)(val1);
12546  ecode2 = SWIG_AsVal_double(obj1, &val2);
12547  if (!SWIG_IsOK(ecode2)) {
12548  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12549  }
12550  arg2 = (PLFLT)(val2);
12551  plssym(arg1,arg2);
12552  resultobj = SWIG_Py_Void();
12553  return resultobj;
12554 fail:
12555  return NULL;
12556 }
12557 
12558 
12559 SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12560  PyObject *resultobj = 0;
12561  PLINT arg1 ;
12562  PLINT arg2 ;
12563  int val1 ;
12564  int ecode1 = 0 ;
12565  int val2 ;
12566  int ecode2 = 0 ;
12567  PyObject * obj0 = 0 ;
12568  PyObject * obj1 = 0 ;
12569 
12570  if (!PyArg_ParseTuple(args,(char *)"OO:plstar",&obj0,&obj1)) SWIG_fail;
12571  ecode1 = SWIG_AsVal_int(obj0, &val1);
12572  if (!SWIG_IsOK(ecode1)) {
12573  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12574  }
12575  arg1 = (PLINT)(val1);
12576  ecode2 = SWIG_AsVal_int(obj1, &val2);
12577  if (!SWIG_IsOK(ecode2)) {
12578  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12579  }
12580  arg2 = (PLINT)(val2);
12581  plstar(arg1,arg2);
12582  resultobj = SWIG_Py_Void();
12583  return resultobj;
12584 fail:
12585  return NULL;
12586 }
12587 
12588 
12589 SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12590  PyObject *resultobj = 0;
12591  char *arg1 = (char *) 0 ;
12592  PLINT arg2 ;
12593  PLINT arg3 ;
12594  int res1 ;
12595  char *buf1 = 0 ;
12596  int alloc1 = 0 ;
12597  int val2 ;
12598  int ecode2 = 0 ;
12599  int val3 ;
12600  int ecode3 = 0 ;
12601  PyObject * obj0 = 0 ;
12602  PyObject * obj1 = 0 ;
12603  PyObject * obj2 = 0 ;
12604 
12605  if (!PyArg_ParseTuple(args,(char *)"OOO:plstart",&obj0,&obj1,&obj2)) SWIG_fail;
12606  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12607  if (!SWIG_IsOK(res1)) {
12608  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12609  }
12610  arg1 = (char *)(buf1);
12611  ecode2 = SWIG_AsVal_int(obj1, &val2);
12612  if (!SWIG_IsOK(ecode2)) {
12613  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12614  }
12615  arg2 = (PLINT)(val2);
12616  ecode3 = SWIG_AsVal_int(obj2, &val3);
12617  if (!SWIG_IsOK(ecode3)) {
12618  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12619  }
12620  arg3 = (PLINT)(val3);
12621  plstart((char const *)arg1,arg2,arg3);
12622  resultobj = SWIG_Py_Void();
12623  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12624  return resultobj;
12625 fail:
12626  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12627  return NULL;
12628 }
12629 
12630 
12631 SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12632  PyObject *resultobj = 0;
12633  ct_func arg1 = (ct_func) 0 ;
12634  PLPointer arg2 = (PLPointer) 0 ;
12635  int res2 ;
12636  PyObject * obj0 = 0 ;
12637  PyObject * obj1 = 0 ;
12638 
12639  {
12640  python_ct = 0;
12641  arg1 = NULL;
12642  }
12643  if (!PyArg_ParseTuple(args,(char *)"|OO:plstransform",&obj0,&obj1)) SWIG_fail;
12644  if (obj0) {
12645  {
12646  if ( python_ct )
12647  cleanup_ct();
12648  // it must be a callable or none
12649  if ( obj0 == Py_None )
12650  {
12651  arg1 = NULL;
12652  }
12653  else
12654  {
12655  if ( !PyCallable_Check( (PyObject *) obj0 ) )
12656  {
12657  PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12658  return NULL;
12659  }
12660  arg1 = marshal_ct( obj0 );
12661  }
12662  }
12663  }
12664  if (obj1) {
12665  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12666  if (!SWIG_IsOK(res2)) {
12667  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12668  }
12669  }
12670  plstransform(arg1,arg2);
12671  resultobj = SWIG_Py_Void();
12672  return resultobj;
12673 fail:
12674  return NULL;
12675 }
12676 
12677 
12678 SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12679  PyObject *resultobj = 0;
12680  PLINT arg1 ;
12681  PLFLT *arg2 = (PLFLT *) 0 ;
12682  PLFLT *arg3 = (PLFLT *) 0 ;
12683  char *arg4 = (char *) 0 ;
12684  PyArrayObject *tmp1 ;
12685  PyArrayObject *tmp3 ;
12686  int res4 ;
12687  char *buf4 = 0 ;
12688  int alloc4 = 0 ;
12689  PyObject * obj0 = 0 ;
12690  PyObject * obj1 = 0 ;
12691  PyObject * obj2 = 0 ;
12692 
12693  if (!PyArg_ParseTuple(args,(char *)"OOO:plstring",&obj0,&obj1,&obj2)) SWIG_fail;
12694  {
12695  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12696  if ( tmp1 == NULL )
12697  return NULL;
12698  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12699  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12700  }
12701  {
12702  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
12703  if ( tmp3 == NULL )
12704  return NULL;
12705  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12706  {
12707  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12708  return NULL;
12709  }
12710  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12711  }
12712  res4 = SWIG_AsCharPtrAndSize(obj2, &buf4, NULL, &alloc4);
12713  if (!SWIG_IsOK(res4)) {
12714  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12715  }
12716  arg4 = (char *)(buf4);
12717  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12718  resultobj = SWIG_Py_Void();
12719  {
12720  Py_DECREF( tmp1 );
12721  }
12722  {
12723  Py_DECREF( tmp3 );
12724  }
12725  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12726  return resultobj;
12727 fail:
12728  {
12729  Py_DECREF( tmp1 );
12730  }
12731  {
12732  Py_DECREF( tmp3 );
12733  }
12734  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12735  return NULL;
12736 }
12737 
12738 
12739 SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12740  PyObject *resultobj = 0;
12741  PLINT arg1 ;
12742  PLFLT *arg2 = (PLFLT *) 0 ;
12743  PLFLT *arg3 = (PLFLT *) 0 ;
12744  PLFLT *arg4 = (PLFLT *) 0 ;
12745  char *arg5 = (char *) 0 ;
12746  PyArrayObject *tmp1 ;
12747  PyArrayObject *tmp3 ;
12748  PyArrayObject *tmp4 ;
12749  int res5 ;
12750  char *buf5 = 0 ;
12751  int alloc5 = 0 ;
12752  PyObject * obj0 = 0 ;
12753  PyObject * obj1 = 0 ;
12754  PyObject * obj2 = 0 ;
12755  PyObject * obj3 = 0 ;
12756 
12757  if (!PyArg_ParseTuple(args,(char *)"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12758  {
12759  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12760  if ( tmp1 == NULL )
12761  return NULL;
12762  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12763  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12764  }
12765  {
12766  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
12767  if ( tmp3 == NULL )
12768  return NULL;
12769  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12770  {
12771  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12772  return NULL;
12773  }
12774  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12775  }
12776  {
12777  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
12778  if ( tmp4 == NULL )
12779  return NULL;
12780  if ( PyArray_DIMS( tmp4 )[0] != Alen )
12781  {
12782  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12783  return NULL;
12784  }
12785  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
12786  }
12787  res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
12788  if (!SWIG_IsOK(res5)) {
12789  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
12790  }
12791  arg5 = (char *)(buf5);
12792  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
12793  resultobj = SWIG_Py_Void();
12794  {
12795  Py_DECREF( tmp1 );
12796  }
12797  {
12798  Py_DECREF( tmp3 );
12799  }
12800  {
12801  Py_DECREF( tmp4 );
12802  }
12803  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12804  return resultobj;
12805 fail:
12806  {
12807  Py_DECREF( tmp1 );
12808  }
12809  {
12810  Py_DECREF( tmp3 );
12811  }
12812  {
12813  Py_DECREF( tmp4 );
12814  }
12815  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12816  return NULL;
12817 }
12818 
12819 
12820 SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12821  PyObject *resultobj = 0;
12822  PLINT arg1 ;
12823  PLINT arg2 ;
12824  PLFLT arg3 ;
12825  PLFLT arg4 ;
12826  int val1 ;
12827  int ecode1 = 0 ;
12828  int val2 ;
12829  int ecode2 = 0 ;
12830  double val3 ;
12831  int ecode3 = 0 ;
12832  double val4 ;
12833  int ecode4 = 0 ;
12834  PyObject * obj0 = 0 ;
12835  PyObject * obj1 = 0 ;
12836  PyObject * obj2 = 0 ;
12837  PyObject * obj3 = 0 ;
12838 
12839  if (!PyArg_ParseTuple(args,(char *)"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12840  ecode1 = SWIG_AsVal_int(obj0, &val1);
12841  if (!SWIG_IsOK(ecode1)) {
12842  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
12843  }
12844  arg1 = (PLINT)(val1);
12845  ecode2 = SWIG_AsVal_int(obj1, &val2);
12846  if (!SWIG_IsOK(ecode2)) {
12847  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
12848  }
12849  arg2 = (PLINT)(val2);
12850  ecode3 = SWIG_AsVal_double(obj2, &val3);
12851  if (!SWIG_IsOK(ecode3)) {
12852  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
12853  }
12854  arg3 = (PLFLT)(val3);
12855  ecode4 = SWIG_AsVal_double(obj3, &val4);
12856  if (!SWIG_IsOK(ecode4)) {
12857  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
12858  }
12859  arg4 = (PLFLT)(val4);
12860  plstripa(arg1,arg2,arg3,arg4);
12861  resultobj = SWIG_Py_Void();
12862  return resultobj;
12863 fail:
12864  return NULL;
12865 }
12866 
12867 
12868 SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12869  PyObject *resultobj = 0;
12870  PLINT *arg1 = (PLINT *) 0 ;
12871  char *arg2 = (char *) 0 ;
12872  char *arg3 = (char *) 0 ;
12873  PLFLT arg4 ;
12874  PLFLT arg5 ;
12875  PLFLT arg6 ;
12876  PLFLT arg7 ;
12877  PLFLT arg8 ;
12878  PLFLT arg9 ;
12879  PLFLT arg10 ;
12880  PLBOOL arg11 ;
12881  PLBOOL arg12 ;
12882  PLINT arg13 ;
12883  PLINT arg14 ;
12884  PLINT *arg15 = (PLINT *) 0 ;
12885  PLINT *arg16 = (PLINT *) 0 ;
12886  char **arg17 ;
12887  char *arg18 = (char *) 0 ;
12888  char *arg19 = (char *) 0 ;
12889  char *arg20 = (char *) 0 ;
12890  PLINT temp1 ;
12891  int res1 = SWIG_TMPOBJ ;
12892  int res2 ;
12893  char *buf2 = 0 ;
12894  int alloc2 = 0 ;
12895  int res3 ;
12896  char *buf3 = 0 ;
12897  int alloc3 = 0 ;
12898  double val4 ;
12899  int ecode4 = 0 ;
12900  double val5 ;
12901  int ecode5 = 0 ;
12902  double val6 ;
12903  int ecode6 = 0 ;
12904  double val7 ;
12905  int ecode7 = 0 ;
12906  double val8 ;
12907  int ecode8 = 0 ;
12908  double val9 ;
12909  int ecode9 = 0 ;
12910  double val10 ;
12911  int ecode10 = 0 ;
12912  int val11 ;
12913  int ecode11 = 0 ;
12914  int val12 ;
12915  int ecode12 = 0 ;
12916  int val13 ;
12917  int ecode13 = 0 ;
12918  int val14 ;
12919  int ecode14 = 0 ;
12920  PyArrayObject *tmp15 ;
12921  PyArrayObject *tmp16 ;
12922  int res18 ;
12923  char *buf18 = 0 ;
12924  int alloc18 = 0 ;
12925  int res19 ;
12926  char *buf19 = 0 ;
12927  int alloc19 = 0 ;
12928  int res20 ;
12929  char *buf20 = 0 ;
12930  int alloc20 = 0 ;
12931  PyObject * obj0 = 0 ;
12932  PyObject * obj1 = 0 ;
12933  PyObject * obj2 = 0 ;
12934  PyObject * obj3 = 0 ;
12935  PyObject * obj4 = 0 ;
12936  PyObject * obj5 = 0 ;
12937  PyObject * obj6 = 0 ;
12938  PyObject * obj7 = 0 ;
12939  PyObject * obj8 = 0 ;
12940  PyObject * obj9 = 0 ;
12941  PyObject * obj10 = 0 ;
12942  PyObject * obj11 = 0 ;
12943  PyObject * obj12 = 0 ;
12944  PyObject * obj13 = 0 ;
12945  PyObject * obj14 = 0 ;
12946  PyObject * obj15 = 0 ;
12947  PyObject * obj16 = 0 ;
12948  PyObject * obj17 = 0 ;
12949  PyObject * obj18 = 0 ;
12950 
12951  arg1 = &temp1;
12952  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:plstripc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
12953  res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
12954  if (!SWIG_IsOK(res2)) {
12955  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
12956  }
12957  arg2 = (char *)(buf2);
12958  res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
12959  if (!SWIG_IsOK(res3)) {
12960  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
12961  }
12962  arg3 = (char *)(buf3);
12963  ecode4 = SWIG_AsVal_double(obj2, &val4);
12964  if (!SWIG_IsOK(ecode4)) {
12965  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
12966  }
12967  arg4 = (PLFLT)(val4);
12968  ecode5 = SWIG_AsVal_double(obj3, &val5);
12969  if (!SWIG_IsOK(ecode5)) {
12970  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
12971  }
12972  arg5 = (PLFLT)(val5);
12973  ecode6 = SWIG_AsVal_double(obj4, &val6);
12974  if (!SWIG_IsOK(ecode6)) {
12975  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
12976  }
12977  arg6 = (PLFLT)(val6);
12978  ecode7 = SWIG_AsVal_double(obj5, &val7);
12979  if (!SWIG_IsOK(ecode7)) {
12980  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
12981  }
12982  arg7 = (PLFLT)(val7);
12983  ecode8 = SWIG_AsVal_double(obj6, &val8);
12984  if (!SWIG_IsOK(ecode8)) {
12985  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
12986  }
12987  arg8 = (PLFLT)(val8);
12988  ecode9 = SWIG_AsVal_double(obj7, &val9);
12989  if (!SWIG_IsOK(ecode9)) {
12990  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
12991  }
12992  arg9 = (PLFLT)(val9);
12993  ecode10 = SWIG_AsVal_double(obj8, &val10);
12994  if (!SWIG_IsOK(ecode10)) {
12995  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
12996  }
12997  arg10 = (PLFLT)(val10);
12998  ecode11 = SWIG_AsVal_int(obj9, &val11);
12999  if (!SWIG_IsOK(ecode11)) {
13000  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
13001  }
13002  arg11 = (PLBOOL)(val11);
13003  ecode12 = SWIG_AsVal_int(obj10, &val12);
13004  if (!SWIG_IsOK(ecode12)) {
13005  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
13006  }
13007  arg12 = (PLBOOL)(val12);
13008  ecode13 = SWIG_AsVal_int(obj11, &val13);
13009  if (!SWIG_IsOK(ecode13)) {
13010  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
13011  }
13012  arg13 = (PLINT)(val13);
13013  ecode14 = SWIG_AsVal_int(obj12, &val14);
13014  if (!SWIG_IsOK(ecode14)) {
13015  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13016  }
13017  arg14 = (PLINT)(val14);
13018  {
13019  tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
13020  if ( tmp15 == NULL )
13021  return NULL;
13022  Alen = PyArray_DIMS( tmp15 )[0];
13023  arg15 = (PLINT *) PyArray_DATA( tmp15 );
13024  }
13025  {
13026  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj14, NPY_PLINT, 1, 1 );
13027  if ( tmp16 == NULL )
13028  return NULL;
13029  if ( PyArray_DIMS( tmp16 )[0] != Alen )
13030  {
13031  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13032  return NULL;
13033  }
13034  arg16 = (PLINT *) PyArray_DATA( tmp16 );
13035  }
13036  {
13037  int i;
13038  if ( !PySequence_Check( obj15 ) || PySequence_Size( obj15 ) != 4 )
13039  {
13040  PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13041  return NULL;
13042  }
13043  if ( Alen != 4 )
13044  {
13045  PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13046  return NULL;
13047  }
13048  arg17 = malloc( sizeof ( char* ) * 4 );
13049  for ( i = 0; i < 4; i++ )
13050  {
13051  arg17[i] = PyString_AsString( PySequence_Fast_GET_ITEM( obj15, i ) );
13052  if ( arg17[i] == NULL )
13053  {
13054  free( arg17 );
13055  return NULL;
13056  }
13057  }
13058  }
13059  res18 = SWIG_AsCharPtrAndSize(obj16, &buf18, NULL, &alloc18);
13060  if (!SWIG_IsOK(res18)) {
13061  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13062  }
13063  arg18 = (char *)(buf18);
13064  res19 = SWIG_AsCharPtrAndSize(obj17, &buf19, NULL, &alloc19);
13065  if (!SWIG_IsOK(res19)) {
13066  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13067  }
13068  arg19 = (char *)(buf19);
13069  res20 = SWIG_AsCharPtrAndSize(obj18, &buf20, NULL, &alloc20);
13070  if (!SWIG_IsOK(res20)) {
13071  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13072  }
13073  arg20 = (char *)(buf20);
13074  plstripc(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,(int const *)arg15,(int const *)arg16,(char const *(*))arg17,(char const *)arg18,(char const *)arg19,(char const *)arg20);
13075  resultobj = SWIG_Py_Void();
13076  if (SWIG_IsTmpObj(res1)) {
13077  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
13078  } else {
13079  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13080  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13081  }
13082  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13083  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13084  {
13085  Py_DECREF( tmp15 );
13086  }
13087  {
13088  Py_DECREF( tmp16 );
13089  }
13090  {
13091  free( arg17 );
13092  }
13093  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13094  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13095  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13096  return resultobj;
13097 fail:
13098  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13099  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13100  {
13101  Py_DECREF( tmp15 );
13102  }
13103  {
13104  Py_DECREF( tmp16 );
13105  }
13106  {
13107  free( arg17 );
13108  }
13109  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13110  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13111  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13112  return NULL;
13113 }
13114 
13115 
13116 SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13117  PyObject *resultobj = 0;
13118  PLINT arg1 ;
13119  int val1 ;
13120  int ecode1 = 0 ;
13121  PyObject * obj0 = 0 ;
13122 
13123  if (!PyArg_ParseTuple(args,(char *)"O:plstripd",&obj0)) SWIG_fail;
13124  ecode1 = SWIG_AsVal_int(obj0, &val1);
13125  if (!SWIG_IsOK(ecode1)) {
13126  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13127  }
13128  arg1 = (PLINT)(val1);
13129  plstripd(arg1);
13130  resultobj = SWIG_Py_Void();
13131  return resultobj;
13132 fail:
13133  return NULL;
13134 }
13135 
13136 
13137 SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13138  PyObject *resultobj = 0;
13139  PLINT arg1 ;
13140  PLINT *arg2 = (PLINT *) 0 ;
13141  PLINT *arg3 = (PLINT *) 0 ;
13142  PyArrayObject *tmp1 ;
13143  PyArrayObject *tmp3 ;
13144  PyObject * obj0 = 0 ;
13145  PyObject * obj1 = 0 ;
13146 
13147  if (!PyArg_ParseTuple(args,(char *)"OO:plstyl",&obj0,&obj1)) SWIG_fail;
13148  {
13149  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
13150  if ( tmp1 == NULL )
13151  return NULL;
13152  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13153  arg2 = (PLINT *) PyArray_DATA( tmp1 );
13154  }
13155  {
13156  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
13157  if ( tmp3 == NULL )
13158  return NULL;
13159  if ( PyArray_DIMS( tmp3 )[0] != Alen )
13160  {
13161  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13162  return NULL;
13163  }
13164  arg3 = (PLINT *) PyArray_DATA( tmp3 );
13165  }
13166  plstyl(arg1,(int const *)arg2,(int const *)arg3);
13167  resultobj = SWIG_Py_Void();
13168  {
13169  Py_DECREF( tmp1 );
13170  }
13171  {
13172  Py_DECREF( tmp3 );
13173  }
13174  return resultobj;
13175 fail:
13176  {
13177  Py_DECREF( tmp1 );
13178  }
13179  {
13180  Py_DECREF( tmp3 );
13181  }
13182  return NULL;
13183 }
13184 
13185 
13186 SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13187  PyObject *resultobj = 0;
13188  PLFLT *arg1 = (PLFLT *) 0 ;
13189  PLFLT *arg2 = (PLFLT *) 0 ;
13190  PLINT arg3 ;
13191  PLBOOL arg4 ;
13192  PyArrayObject *tmp1 ;
13193  PyArrayObject *tmp2 ;
13194  int val4 ;
13195  int ecode4 = 0 ;
13196  PyObject * obj0 = 0 ;
13197  PyObject * obj1 = 0 ;
13198  PyObject * obj2 = 0 ;
13199 
13200  if (!PyArg_ParseTuple(args,(char *)"OOO:plsvect",&obj0,&obj1,&obj2)) SWIG_fail;
13201  {
13202  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13203  if ( tmp1 == NULL )
13204  return NULL;
13205  Alen = PyArray_DIMS( tmp1 )[0];
13206  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13207  }
13208  {
13209  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13210  if ( tmp2 == NULL )
13211  return NULL;
13212  if ( PyArray_DIMS( tmp2 )[0] != Alen )
13213  {
13214  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13215  return NULL;
13216  }
13217  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13218  arg3 = PyArray_DIMS( tmp2 )[0];
13219  }
13220  ecode4 = SWIG_AsVal_int(obj2, &val4);
13221  if (!SWIG_IsOK(ecode4)) {
13222  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13223  }
13224  arg4 = (PLBOOL)(val4);
13225  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13226  resultobj = SWIG_Py_Void();
13227  {
13228  Py_DECREF( tmp1 );
13229  }
13230  {
13231  Py_DECREF( tmp2 );
13232  }
13233  return resultobj;
13234 fail:
13235  {
13236  Py_DECREF( tmp1 );
13237  }
13238  {
13239  Py_DECREF( tmp2 );
13240  }
13241  return NULL;
13242 }
13243 
13244 
13245 SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13246  PyObject *resultobj = 0;
13247  PLFLT arg1 ;
13248  PLFLT arg2 ;
13249  PLFLT arg3 ;
13250  PLFLT arg4 ;
13251  double val1 ;
13252  int ecode1 = 0 ;
13253  double val2 ;
13254  int ecode2 = 0 ;
13255  double val3 ;
13256  int ecode3 = 0 ;
13257  double val4 ;
13258  int ecode4 = 0 ;
13259  PyObject * obj0 = 0 ;
13260  PyObject * obj1 = 0 ;
13261  PyObject * obj2 = 0 ;
13262  PyObject * obj3 = 0 ;
13263 
13264  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13265  ecode1 = SWIG_AsVal_double(obj0, &val1);
13266  if (!SWIG_IsOK(ecode1)) {
13267  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13268  }
13269  arg1 = (PLFLT)(val1);
13270  ecode2 = SWIG_AsVal_double(obj1, &val2);
13271  if (!SWIG_IsOK(ecode2)) {
13272  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13273  }
13274  arg2 = (PLFLT)(val2);
13275  ecode3 = SWIG_AsVal_double(obj2, &val3);
13276  if (!SWIG_IsOK(ecode3)) {
13277  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13278  }
13279  arg3 = (PLFLT)(val3);
13280  ecode4 = SWIG_AsVal_double(obj3, &val4);
13281  if (!SWIG_IsOK(ecode4)) {
13282  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13283  }
13284  arg4 = (PLFLT)(val4);
13285  plsvpa(arg1,arg2,arg3,arg4);
13286  resultobj = SWIG_Py_Void();
13287  return resultobj;
13288 fail:
13289  return NULL;
13290 }
13291 
13292 
13293 SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13294  PyObject *resultobj = 0;
13295  PLINT arg1 ;
13296  PLINT arg2 ;
13297  int val1 ;
13298  int ecode1 = 0 ;
13299  int val2 ;
13300  int ecode2 = 0 ;
13301  PyObject * obj0 = 0 ;
13302  PyObject * obj1 = 0 ;
13303 
13304  if (!PyArg_ParseTuple(args,(char *)"OO:plsxax",&obj0,&obj1)) SWIG_fail;
13305  ecode1 = SWIG_AsVal_int(obj0, &val1);
13306  if (!SWIG_IsOK(ecode1)) {
13307  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13308  }
13309  arg1 = (PLINT)(val1);
13310  ecode2 = SWIG_AsVal_int(obj1, &val2);
13311  if (!SWIG_IsOK(ecode2)) {
13312  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13313  }
13314  arg2 = (PLINT)(val2);
13315  plsxax(arg1,arg2);
13316  resultobj = SWIG_Py_Void();
13317  return resultobj;
13318 fail:
13319  return NULL;
13320 }
13321 
13322 
13323 SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13324  PyObject *resultobj = 0;
13325  PLINT arg1 ;
13326  PLINT arg2 ;
13327  int val1 ;
13328  int ecode1 = 0 ;
13329  int val2 ;
13330  int ecode2 = 0 ;
13331  PyObject * obj0 = 0 ;
13332  PyObject * obj1 = 0 ;
13333 
13334  if (!PyArg_ParseTuple(args,(char *)"OO:plsyax",&obj0,&obj1)) SWIG_fail;
13335  ecode1 = SWIG_AsVal_int(obj0, &val1);
13336  if (!SWIG_IsOK(ecode1)) {
13337  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13338  }
13339  arg1 = (PLINT)(val1);
13340  ecode2 = SWIG_AsVal_int(obj1, &val2);
13341  if (!SWIG_IsOK(ecode2)) {
13342  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13343  }
13344  arg2 = (PLINT)(val2);
13345  plsyax(arg1,arg2);
13346  resultobj = SWIG_Py_Void();
13347  return resultobj;
13348 fail:
13349  return NULL;
13350 }
13351 
13352 
13353 SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13354  PyObject *resultobj = 0;
13355  PLINT arg1 ;
13356  PLFLT *arg2 = (PLFLT *) 0 ;
13357  PLFLT *arg3 = (PLFLT *) 0 ;
13358  PLINT arg4 ;
13359  PyArrayObject *tmp1 ;
13360  PyArrayObject *tmp3 ;
13361  int val4 ;
13362  int ecode4 = 0 ;
13363  PyObject * obj0 = 0 ;
13364  PyObject * obj1 = 0 ;
13365  PyObject * obj2 = 0 ;
13366 
13367  if (!PyArg_ParseTuple(args,(char *)"OOO:plsym",&obj0,&obj1,&obj2)) SWIG_fail;
13368  {
13369  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13370  if ( tmp1 == NULL )
13371  return NULL;
13372  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13373  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13374  }
13375  {
13376  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13377  if ( tmp3 == NULL )
13378  return NULL;
13379  if ( PyArray_DIMS( tmp3 )[0] != Alen )
13380  {
13381  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13382  return NULL;
13383  }
13384  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13385  }
13386  ecode4 = SWIG_AsVal_int(obj2, &val4);
13387  if (!SWIG_IsOK(ecode4)) {
13388  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13389  }
13390  arg4 = (PLINT)(val4);
13391  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13392  resultobj = SWIG_Py_Void();
13393  {
13394  Py_DECREF( tmp1 );
13395  }
13396  {
13397  Py_DECREF( tmp3 );
13398  }
13399  return resultobj;
13400 fail:
13401  {
13402  Py_DECREF( tmp1 );
13403  }
13404  {
13405  Py_DECREF( tmp3 );
13406  }
13407  return NULL;
13408 }
13409 
13410 
13411 SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13412  PyObject *resultobj = 0;
13413  PLINT arg1 ;
13414  PLINT arg2 ;
13415  int val1 ;
13416  int ecode1 = 0 ;
13417  int val2 ;
13418  int ecode2 = 0 ;
13419  PyObject * obj0 = 0 ;
13420  PyObject * obj1 = 0 ;
13421 
13422  if (!PyArg_ParseTuple(args,(char *)"OO:plszax",&obj0,&obj1)) SWIG_fail;
13423  ecode1 = SWIG_AsVal_int(obj0, &val1);
13424  if (!SWIG_IsOK(ecode1)) {
13425  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13426  }
13427  arg1 = (PLINT)(val1);
13428  ecode2 = SWIG_AsVal_int(obj1, &val2);
13429  if (!SWIG_IsOK(ecode2)) {
13430  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13431  }
13432  arg2 = (PLINT)(val2);
13433  plszax(arg1,arg2);
13434  resultobj = SWIG_Py_Void();
13435  return resultobj;
13436 fail:
13437  return NULL;
13438 }
13439 
13440 
13441 SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13442  PyObject *resultobj = 0;
13443 
13444  if (!PyArg_ParseTuple(args,(char *)":pltext")) SWIG_fail;
13445  pltext();
13446  resultobj = SWIG_Py_Void();
13447  return resultobj;
13448 fail:
13449  return NULL;
13450 }
13451 
13452 
13453 SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13454  PyObject *resultobj = 0;
13455  char *arg1 = (char *) 0 ;
13456  int res1 ;
13457  char *buf1 = 0 ;
13458  int alloc1 = 0 ;
13459  PyObject * obj0 = 0 ;
13460 
13461  if (!PyArg_ParseTuple(args,(char *)"O:pltimefmt",&obj0)) SWIG_fail;
13462  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
13463  if (!SWIG_IsOK(res1)) {
13464  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13465  }
13466  arg1 = (char *)(buf1);
13467  pltimefmt((char const *)arg1);
13468  resultobj = SWIG_Py_Void();
13469  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13470  return resultobj;
13471 fail:
13472  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13473  return NULL;
13474 }
13475 
13476 
13477 SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13478  PyObject *resultobj = 0;
13479  PLFLT arg1 ;
13480  double val1 ;
13481  int ecode1 = 0 ;
13482  PyObject * obj0 = 0 ;
13483 
13484  if (!PyArg_ParseTuple(args,(char *)"O:plvasp",&obj0)) SWIG_fail;
13485  ecode1 = SWIG_AsVal_double(obj0, &val1);
13486  if (!SWIG_IsOK(ecode1)) {
13487  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13488  }
13489  arg1 = (PLFLT)(val1);
13490  plvasp(arg1);
13491  resultobj = SWIG_Py_Void();
13492  return resultobj;
13493 fail:
13494  return NULL;
13495 }
13496 
13497 
13498 SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13499  PyObject *resultobj = 0;
13500  PLFLT **arg1 = (PLFLT **) 0 ;
13501  PLFLT **arg2 = (PLFLT **) 0 ;
13502  PLINT arg3 ;
13503  PLINT arg4 ;
13504  PLFLT arg5 ;
13505  pltr_func arg6 = (pltr_func) 0 ;
13506  PLPointer arg7 = (PLPointer) 0 ;
13507  PyArrayObject *tmp1 ;
13508  PyArrayObject *tmp2 ;
13509  double val5 ;
13510  int ecode5 = 0 ;
13511  PyObject * obj0 = 0 ;
13512  PyObject * obj1 = 0 ;
13513  PyObject * obj2 = 0 ;
13514  PyObject * obj3 = 0 ;
13515  PyObject * obj4 = 0 ;
13516 
13517  {
13518  python_pltr = 0;
13519  arg6 = NULL;
13520  }
13521  {
13522  arg7 = NULL;
13523  }
13524  if (!PyArg_ParseTuple(args,(char *)"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13525  {
13526  int i, size;
13527  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
13528  if ( tmp1 == NULL )
13529  return NULL;
13530  Xlen = PyArray_DIMS( tmp1 )[0];
13531  Ylen = PyArray_DIMS( tmp1 )[1];
13532  size = sizeof ( PLFLT ) * Ylen;
13533  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * Xlen );
13534  for ( i = 0; i < Xlen; i++ )
13535  arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
13536  }
13537  {
13538  int i, size;
13539  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 2, 2 );
13540  if ( tmp2 == NULL )
13541  return NULL;
13542  if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13543  {
13544  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13545  return NULL;
13546  }
13547  arg3 = PyArray_DIMS( tmp2 )[0];
13548  arg4 = PyArray_DIMS( tmp2 )[1];
13549  size = sizeof ( PLFLT ) * arg4;
13550  arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg3 );
13551  for ( i = 0; i < arg3; i++ )
13552  arg2[i] = (PLFLT *) ( PyArray_DATA( tmp2 ) + i * size );
13553  }
13554  ecode5 = SWIG_AsVal_double(obj2, &val5);
13555  if (!SWIG_IsOK(ecode5)) {
13556  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13557  }
13558  arg5 = (PLFLT)(val5);
13559  if (obj3) {
13560  {
13561  // it must be a callable or None
13562  if ( obj3 == Py_None )
13563  {
13564  arg6 = NULL;
13565  }
13566  else
13567  {
13568  if ( !PyCallable_Check( (PyObject *) obj3 ) )
13569  {
13570  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13571  return NULL;
13572  }
13573  arg6 = marshal_pltr( obj3 );
13574  }
13575  }
13576  }
13577  if (obj4) {
13578  {
13579  if ( obj4 == Py_None )
13580  arg7 = NULL;
13581  else
13582  {
13583  arg7 = marshal_PLPointer( obj4, 0 );
13584  }
13585  }
13586  }
13587  plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13588  resultobj = SWIG_Py_Void();
13589  {
13590  Py_DECREF( tmp1 );
13591  free( arg1 );
13592  }
13593  {
13594  Py_DECREF( tmp2 );
13595  free( arg2 );
13596  }
13597  {
13598  cleanup_pltr();
13599  }
13600  {
13602  }
13603  return resultobj;
13604 fail:
13605  {
13606  Py_DECREF( tmp1 );
13607  free( arg1 );
13608  }
13609  {
13610  Py_DECREF( tmp2 );
13611  free( arg2 );
13612  }
13613  {
13614  cleanup_pltr();
13615  }
13616  {
13618  }
13619  return NULL;
13620 }
13621 
13622 
13623 SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13624  PyObject *resultobj = 0;
13625  PLFLT arg1 ;
13626  PLFLT arg2 ;
13627  PLFLT arg3 ;
13628  PLFLT arg4 ;
13629  PLFLT arg5 ;
13630  double val1 ;
13631  int ecode1 = 0 ;
13632  double val2 ;
13633  int ecode2 = 0 ;
13634  double val3 ;
13635  int ecode3 = 0 ;
13636  double val4 ;
13637  int ecode4 = 0 ;
13638  double val5 ;
13639  int ecode5 = 0 ;
13640  PyObject * obj0 = 0 ;
13641  PyObject * obj1 = 0 ;
13642  PyObject * obj2 = 0 ;
13643  PyObject * obj3 = 0 ;
13644  PyObject * obj4 = 0 ;
13645 
13646  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13647  ecode1 = SWIG_AsVal_double(obj0, &val1);
13648  if (!SWIG_IsOK(ecode1)) {
13649  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13650  }
13651  arg1 = (PLFLT)(val1);
13652  ecode2 = SWIG_AsVal_double(obj1, &val2);
13653  if (!SWIG_IsOK(ecode2)) {
13654  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13655  }
13656  arg2 = (PLFLT)(val2);
13657  ecode3 = SWIG_AsVal_double(obj2, &val3);
13658  if (!SWIG_IsOK(ecode3)) {
13659  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13660  }
13661  arg3 = (PLFLT)(val3);
13662  ecode4 = SWIG_AsVal_double(obj3, &val4);
13663  if (!SWIG_IsOK(ecode4)) {
13664  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13665  }
13666  arg4 = (PLFLT)(val4);
13667  ecode5 = SWIG_AsVal_double(obj4, &val5);
13668  if (!SWIG_IsOK(ecode5)) {
13669  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13670  }
13671  arg5 = (PLFLT)(val5);
13672  plvpas(arg1,arg2,arg3,arg4,arg5);
13673  resultobj = SWIG_Py_Void();
13674  return resultobj;
13675 fail:
13676  return NULL;
13677 }
13678 
13679 
13680 SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13681  PyObject *resultobj = 0;
13682  PLFLT arg1 ;
13683  PLFLT arg2 ;
13684  PLFLT arg3 ;
13685  PLFLT arg4 ;
13686  double val1 ;
13687  int ecode1 = 0 ;
13688  double val2 ;
13689  int ecode2 = 0 ;
13690  double val3 ;
13691  int ecode3 = 0 ;
13692  double val4 ;
13693  int ecode4 = 0 ;
13694  PyObject * obj0 = 0 ;
13695  PyObject * obj1 = 0 ;
13696  PyObject * obj2 = 0 ;
13697  PyObject * obj3 = 0 ;
13698 
13699  if (!PyArg_ParseTuple(args,(char *)"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13700  ecode1 = SWIG_AsVal_double(obj0, &val1);
13701  if (!SWIG_IsOK(ecode1)) {
13702  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13703  }
13704  arg1 = (PLFLT)(val1);
13705  ecode2 = SWIG_AsVal_double(obj1, &val2);
13706  if (!SWIG_IsOK(ecode2)) {
13707  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13708  }
13709  arg2 = (PLFLT)(val2);
13710  ecode3 = SWIG_AsVal_double(obj2, &val3);
13711  if (!SWIG_IsOK(ecode3)) {
13712  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
13713  }
13714  arg3 = (PLFLT)(val3);
13715  ecode4 = SWIG_AsVal_double(obj3, &val4);
13716  if (!SWIG_IsOK(ecode4)) {
13717  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
13718  }
13719  arg4 = (PLFLT)(val4);
13720  plvpor(arg1,arg2,arg3,arg4);
13721  resultobj = SWIG_Py_Void();
13722  return resultobj;
13723 fail:
13724  return NULL;
13725 }
13726 
13727 
13728 SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13729  PyObject *resultobj = 0;
13730 
13731  if (!PyArg_ParseTuple(args,(char *)":plvsta")) SWIG_fail;
13732  plvsta();
13733  resultobj = SWIG_Py_Void();
13734  return resultobj;
13735 fail:
13736  return NULL;
13737 }
13738 
13739 
13740 SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13741  PyObject *resultobj = 0;
13742  PLFLT arg1 ;
13743  PLFLT arg2 ;
13744  PLFLT arg3 ;
13745  PLFLT arg4 ;
13746  PLFLT arg5 ;
13747  PLFLT arg6 ;
13748  PLFLT arg7 ;
13749  PLFLT arg8 ;
13750  PLFLT arg9 ;
13751  PLFLT arg10 ;
13752  PLFLT arg11 ;
13753  double val1 ;
13754  int ecode1 = 0 ;
13755  double val2 ;
13756  int ecode2 = 0 ;
13757  double val3 ;
13758  int ecode3 = 0 ;
13759  double val4 ;
13760  int ecode4 = 0 ;
13761  double val5 ;
13762  int ecode5 = 0 ;
13763  double val6 ;
13764  int ecode6 = 0 ;
13765  double val7 ;
13766  int ecode7 = 0 ;
13767  double val8 ;
13768  int ecode8 = 0 ;
13769  double val9 ;
13770  int ecode9 = 0 ;
13771  double val10 ;
13772  int ecode10 = 0 ;
13773  double val11 ;
13774  int ecode11 = 0 ;
13775  PyObject * obj0 = 0 ;
13776  PyObject * obj1 = 0 ;
13777  PyObject * obj2 = 0 ;
13778  PyObject * obj3 = 0 ;
13779  PyObject * obj4 = 0 ;
13780  PyObject * obj5 = 0 ;
13781  PyObject * obj6 = 0 ;
13782  PyObject * obj7 = 0 ;
13783  PyObject * obj8 = 0 ;
13784  PyObject * obj9 = 0 ;
13785  PyObject * obj10 = 0 ;
13786 
13787  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
13788  ecode1 = SWIG_AsVal_double(obj0, &val1);
13789  if (!SWIG_IsOK(ecode1)) {
13790  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
13791  }
13792  arg1 = (PLFLT)(val1);
13793  ecode2 = SWIG_AsVal_double(obj1, &val2);
13794  if (!SWIG_IsOK(ecode2)) {
13795  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
13796  }
13797  arg2 = (PLFLT)(val2);
13798  ecode3 = SWIG_AsVal_double(obj2, &val3);
13799  if (!SWIG_IsOK(ecode3)) {
13800  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
13801  }
13802  arg3 = (PLFLT)(val3);
13803  ecode4 = SWIG_AsVal_double(obj3, &val4);
13804  if (!SWIG_IsOK(ecode4)) {
13805  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
13806  }
13807  arg4 = (PLFLT)(val4);
13808  ecode5 = SWIG_AsVal_double(obj4, &val5);
13809  if (!SWIG_IsOK(ecode5)) {
13810  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
13811  }
13812  arg5 = (PLFLT)(val5);
13813  ecode6 = SWIG_AsVal_double(obj5, &val6);
13814  if (!SWIG_IsOK(ecode6)) {
13815  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
13816  }
13817  arg6 = (PLFLT)(val6);
13818  ecode7 = SWIG_AsVal_double(obj6, &val7);
13819  if (!SWIG_IsOK(ecode7)) {
13820  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
13821  }
13822  arg7 = (PLFLT)(val7);
13823  ecode8 = SWIG_AsVal_double(obj7, &val8);
13824  if (!SWIG_IsOK(ecode8)) {
13825  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
13826  }
13827  arg8 = (PLFLT)(val8);
13828  ecode9 = SWIG_AsVal_double(obj8, &val9);
13829  if (!SWIG_IsOK(ecode9)) {
13830  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
13831  }
13832  arg9 = (PLFLT)(val9);
13833  ecode10 = SWIG_AsVal_double(obj9, &val10);
13834  if (!SWIG_IsOK(ecode10)) {
13835  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
13836  }
13837  arg10 = (PLFLT)(val10);
13838  ecode11 = SWIG_AsVal_double(obj10, &val11);
13839  if (!SWIG_IsOK(ecode11)) {
13840  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
13841  }
13842  arg11 = (PLFLT)(val11);
13843  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13844  resultobj = SWIG_Py_Void();
13845  return resultobj;
13846 fail:
13847  return NULL;
13848 }
13849 
13850 
13851 SWIGINTERN PyObject *_wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13852  PyObject *resultobj = 0;
13853  PLINT arg1 ;
13854  int val1 ;
13855  int ecode1 = 0 ;
13856  PyObject * obj0 = 0 ;
13857 
13858  if (!PyArg_ParseTuple(args,(char *)"O:plwidth",&obj0)) SWIG_fail;
13859  ecode1 = SWIG_AsVal_int(obj0, &val1);
13860  if (!SWIG_IsOK(ecode1)) {
13861  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLINT""'");
13862  }
13863  arg1 = (PLINT)(val1);
13864  plwidth(arg1);
13865  resultobj = SWIG_Py_Void();
13866  return resultobj;
13867 fail:
13868  return NULL;
13869 }
13870 
13871 
13872 SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13873  PyObject *resultobj = 0;
13874  PLFLT arg1 ;
13875  PLFLT arg2 ;
13876  PLFLT arg3 ;
13877  PLFLT arg4 ;
13878  double val1 ;
13879  int ecode1 = 0 ;
13880  double val2 ;
13881  int ecode2 = 0 ;
13882  double val3 ;
13883  int ecode3 = 0 ;
13884  double val4 ;
13885  int ecode4 = 0 ;
13886  PyObject * obj0 = 0 ;
13887  PyObject * obj1 = 0 ;
13888  PyObject * obj2 = 0 ;
13889  PyObject * obj3 = 0 ;
13890 
13891  if (!PyArg_ParseTuple(args,(char *)"OOOO:plwind",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13892  ecode1 = SWIG_AsVal_double(obj0, &val1);
13893  if (!SWIG_IsOK(ecode1)) {
13894  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
13895  }
13896  arg1 = (PLFLT)(val1);
13897  ecode2 = SWIG_AsVal_double(obj1, &val2);
13898  if (!SWIG_IsOK(ecode2)) {
13899  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
13900  }
13901  arg2 = (PLFLT)(val2);
13902  ecode3 = SWIG_AsVal_double(obj2, &val3);
13903  if (!SWIG_IsOK(ecode3)) {
13904  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
13905  }
13906  arg3 = (PLFLT)(val3);
13907  ecode4 = SWIG_AsVal_double(obj3, &val4);
13908  if (!SWIG_IsOK(ecode4)) {
13909  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
13910  }
13911  arg4 = (PLFLT)(val4);
13912  plwind(arg1,arg2,arg3,arg4);
13913  resultobj = SWIG_Py_Void();
13914  return resultobj;
13915 fail:
13916  return NULL;
13917 }
13918 
13919 
13920 SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13921  PyObject *resultobj = 0;
13922  PLBOOL arg1 ;
13923  PLBOOL *arg2 = (PLBOOL *) 0 ;
13924  int val1 ;
13925  int ecode1 = 0 ;
13926  PLBOOL temp2 ;
13927  int res2 = SWIG_TMPOBJ ;
13928  PyObject * obj0 = 0 ;
13929 
13930  arg2 = &temp2;
13931  if (!PyArg_ParseTuple(args,(char *)"O:plxormod",&obj0)) SWIG_fail;
13932  ecode1 = SWIG_AsVal_int(obj0, &val1);
13933  if (!SWIG_IsOK(ecode1)) {
13934  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
13935  }
13936  arg1 = (PLBOOL)(val1);
13937  plxormod(arg1,arg2);
13938  resultobj = SWIG_Py_Void();
13939  if (SWIG_IsTmpObj(res2)) {
13940  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13941  } else {
13942  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13943  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13944  }
13945  return resultobj;
13946 fail:
13947  return NULL;
13948 }
13949 
13950 
13951 SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13952  PyObject *resultobj = 0;
13953  mapform_func arg1 = (mapform_func) 0 ;
13954  char *arg2 = (char *) 0 ;
13955  PLFLT arg3 ;
13956  PLFLT arg4 ;
13957  PLFLT arg5 ;
13958  PLFLT arg6 ;
13959  int res2 ;
13960  char *buf2 = 0 ;
13961  int alloc2 = 0 ;
13962  double val3 ;
13963  int ecode3 = 0 ;
13964  double val4 ;
13965  int ecode4 = 0 ;
13966  double val5 ;
13967  int ecode5 = 0 ;
13968  double val6 ;
13969  int ecode6 = 0 ;
13970  PyObject * obj0 = 0 ;
13971  PyObject * obj1 = 0 ;
13972  PyObject * obj2 = 0 ;
13973  PyObject * obj3 = 0 ;
13974  PyObject * obj4 = 0 ;
13975  PyObject * obj5 = 0 ;
13976 
13977  {
13978  python_mapform = 0;
13979  arg1 = NULL;
13980  }
13981  if (!PyArg_ParseTuple(args,(char *)"|OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13982  if (obj0) {
13983  {
13984  // it must be a callable or none
13985  if ( obj0 == Py_None )
13986  {
13987  arg1 = NULL;
13988  }
13989  else
13990  {
13991  if ( !PyCallable_Check( (PyObject *) obj0 ) )
13992  {
13993  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13994  return NULL;
13995  }
13996  arg1 = marshal_mapform( obj0 );
13997  }
13998  }
13999  }
14000  if (obj1) {
14001  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14002  if (!SWIG_IsOK(res2)) {
14003  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
14004  }
14005  arg2 = (char *)(buf2);
14006  }
14007  if (obj2) {
14008  ecode3 = SWIG_AsVal_double(obj2, &val3);
14009  if (!SWIG_IsOK(ecode3)) {
14010  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
14011  }
14012  arg3 = (PLFLT)(val3);
14013  }
14014  if (obj3) {
14015  ecode4 = SWIG_AsVal_double(obj3, &val4);
14016  if (!SWIG_IsOK(ecode4)) {
14017  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14018  }
14019  arg4 = (PLFLT)(val4);
14020  }
14021  if (obj4) {
14022  ecode5 = SWIG_AsVal_double(obj4, &val5);
14023  if (!SWIG_IsOK(ecode5)) {
14024  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14025  }
14026  arg5 = (PLFLT)(val5);
14027  }
14028  if (obj5) {
14029  ecode6 = SWIG_AsVal_double(obj5, &val6);
14030  if (!SWIG_IsOK(ecode6)) {
14031  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14032  }
14033  arg6 = (PLFLT)(val6);
14034  }
14035  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14036  resultobj = SWIG_Py_Void();
14037  {
14038  cleanup_mapform();
14039  }
14040  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14041  return resultobj;
14042 fail:
14043  {
14044  cleanup_mapform();
14045  }
14046  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14047  return NULL;
14048 }
14049 
14050 
14051 SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14052  PyObject *resultobj = 0;
14053  mapform_func arg1 = (mapform_func) 0 ;
14054  PLFLT arg2 ;
14055  PLFLT arg3 ;
14056  PLFLT arg4 ;
14057  PLFLT arg5 ;
14058  PLFLT arg6 ;
14059  PLFLT arg7 ;
14060  double val2 ;
14061  int ecode2 = 0 ;
14062  double val3 ;
14063  int ecode3 = 0 ;
14064  double val4 ;
14065  int ecode4 = 0 ;
14066  double val5 ;
14067  int ecode5 = 0 ;
14068  double val6 ;
14069  int ecode6 = 0 ;
14070  double val7 ;
14071  int ecode7 = 0 ;
14072  PyObject * obj0 = 0 ;
14073  PyObject * obj1 = 0 ;
14074  PyObject * obj2 = 0 ;
14075  PyObject * obj3 = 0 ;
14076  PyObject * obj4 = 0 ;
14077  PyObject * obj5 = 0 ;
14078  PyObject * obj6 = 0 ;
14079 
14080  {
14081  python_mapform = 0;
14082  arg1 = NULL;
14083  }
14084  if (!PyArg_ParseTuple(args,(char *)"|OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14085  if (obj0) {
14086  {
14087  // it must be a callable or none
14088  if ( obj0 == Py_None )
14089  {
14090  arg1 = NULL;
14091  }
14092  else
14093  {
14094  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14095  {
14096  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14097  return NULL;
14098  }
14099  arg1 = marshal_mapform( obj0 );
14100  }
14101  }
14102  }
14103  if (obj1) {
14104  ecode2 = SWIG_AsVal_double(obj1, &val2);
14105  if (!SWIG_IsOK(ecode2)) {
14106  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14107  }
14108  arg2 = (PLFLT)(val2);
14109  }
14110  if (obj2) {
14111  ecode3 = SWIG_AsVal_double(obj2, &val3);
14112  if (!SWIG_IsOK(ecode3)) {
14113  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14114  }
14115  arg3 = (PLFLT)(val3);
14116  }
14117  if (obj3) {
14118  ecode4 = SWIG_AsVal_double(obj3, &val4);
14119  if (!SWIG_IsOK(ecode4)) {
14120  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14121  }
14122  arg4 = (PLFLT)(val4);
14123  }
14124  if (obj4) {
14125  ecode5 = SWIG_AsVal_double(obj4, &val5);
14126  if (!SWIG_IsOK(ecode5)) {
14127  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14128  }
14129  arg5 = (PLFLT)(val5);
14130  }
14131  if (obj5) {
14132  ecode6 = SWIG_AsVal_double(obj5, &val6);
14133  if (!SWIG_IsOK(ecode6)) {
14134  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14135  }
14136  arg6 = (PLFLT)(val6);
14137  }
14138  if (obj6) {
14139  ecode7 = SWIG_AsVal_double(obj6, &val7);
14140  if (!SWIG_IsOK(ecode7)) {
14141  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14142  }
14143  arg7 = (PLFLT)(val7);
14144  }
14145  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14146  resultobj = SWIG_Py_Void();
14147  {
14148  cleanup_mapform();
14149  }
14150  return resultobj;
14151 fail:
14152  {
14153  cleanup_mapform();
14154  }
14155  return NULL;
14156 }
14157 
14158 
14159 SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14160  PyObject *resultobj = 0;
14161  PLFLT **arg1 = (PLFLT **) 0 ;
14162  PLINT arg2 ;
14163  PLINT arg3 ;
14164  PLFLT arg4 ;
14165  PLFLT arg5 ;
14166  PLFLT arg6 ;
14167  PLFLT arg7 ;
14168  PLFLT arg8 ;
14169  PLFLT arg9 ;
14170  PLFLT arg10 ;
14171  PLFLT arg11 ;
14172  PLFLT arg12 ;
14173  PLFLT arg13 ;
14174  PyArrayObject *tmp1 ;
14175  double val4 ;
14176  int ecode4 = 0 ;
14177  double val5 ;
14178  int ecode5 = 0 ;
14179  double val6 ;
14180  int ecode6 = 0 ;
14181  double val7 ;
14182  int ecode7 = 0 ;
14183  double val8 ;
14184  int ecode8 = 0 ;
14185  double val9 ;
14186  int ecode9 = 0 ;
14187  double val10 ;
14188  int ecode10 = 0 ;
14189  double val11 ;
14190  int ecode11 = 0 ;
14191  double val12 ;
14192  int ecode12 = 0 ;
14193  double val13 ;
14194  int ecode13 = 0 ;
14195  PyObject * obj0 = 0 ;
14196  PyObject * obj1 = 0 ;
14197  PyObject * obj2 = 0 ;
14198  PyObject * obj3 = 0 ;
14199  PyObject * obj4 = 0 ;
14200  PyObject * obj5 = 0 ;
14201  PyObject * obj6 = 0 ;
14202  PyObject * obj7 = 0 ;
14203  PyObject * obj8 = 0 ;
14204  PyObject * obj9 = 0 ;
14205  PyObject * obj10 = 0 ;
14206 
14207  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14208  {
14209  int i, size;
14210  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14211  if ( tmp1 == NULL )
14212  return NULL;
14213  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14214  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14215  size = sizeof ( PLFLT ) * arg3;
14216  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
14217  for ( i = 0; i < arg2; i++ )
14218  arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
14219  }
14220  ecode4 = SWIG_AsVal_double(obj1, &val4);
14221  if (!SWIG_IsOK(ecode4)) {
14222  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14223  }
14224  arg4 = (PLFLT)(val4);
14225  ecode5 = SWIG_AsVal_double(obj2, &val5);
14226  if (!SWIG_IsOK(ecode5)) {
14227  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14228  }
14229  arg5 = (PLFLT)(val5);
14230  ecode6 = SWIG_AsVal_double(obj3, &val6);
14231  if (!SWIG_IsOK(ecode6)) {
14232  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14233  }
14234  arg6 = (PLFLT)(val6);
14235  ecode7 = SWIG_AsVal_double(obj4, &val7);
14236  if (!SWIG_IsOK(ecode7)) {
14237  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14238  }
14239  arg7 = (PLFLT)(val7);
14240  ecode8 = SWIG_AsVal_double(obj5, &val8);
14241  if (!SWIG_IsOK(ecode8)) {
14242  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14243  }
14244  arg8 = (PLFLT)(val8);
14245  ecode9 = SWIG_AsVal_double(obj6, &val9);
14246  if (!SWIG_IsOK(ecode9)) {
14247  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14248  }
14249  arg9 = (PLFLT)(val9);
14250  ecode10 = SWIG_AsVal_double(obj7, &val10);
14251  if (!SWIG_IsOK(ecode10)) {
14252  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14253  }
14254  arg10 = (PLFLT)(val10);
14255  ecode11 = SWIG_AsVal_double(obj8, &val11);
14256  if (!SWIG_IsOK(ecode11)) {
14257  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14258  }
14259  arg11 = (PLFLT)(val11);
14260  ecode12 = SWIG_AsVal_double(obj9, &val12);
14261  if (!SWIG_IsOK(ecode12)) {
14262  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14263  }
14264  arg12 = (PLFLT)(val12);
14265  ecode13 = SWIG_AsVal_double(obj10, &val13);
14266  if (!SWIG_IsOK(ecode13)) {
14267  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14268  }
14269  arg13 = (PLFLT)(val13);
14270  plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14271  resultobj = SWIG_Py_Void();
14272  {
14273  Py_DECREF( tmp1 );
14274  free( arg1 );
14275  }
14276  return resultobj;
14277 fail:
14278  {
14279  Py_DECREF( tmp1 );
14280  free( arg1 );
14281  }
14282  return NULL;
14283 }
14284 
14285 
14286 SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14287  PyObject *resultobj = 0;
14288  PLFLT **arg1 = (PLFLT **) 0 ;
14289  PLINT arg2 ;
14290  PLINT arg3 ;
14291  PLFLT arg4 ;
14292  PLFLT arg5 ;
14293  PLFLT arg6 ;
14294  PLFLT arg7 ;
14295  PLFLT arg8 ;
14296  PLFLT arg9 ;
14297  PLFLT arg10 ;
14298  PLFLT arg11 ;
14299  pltr_func arg12 = (pltr_func) 0 ;
14300  PLPointer arg13 = (PLPointer) 0 ;
14301  PyArrayObject *tmp1 ;
14302  double val4 ;
14303  int ecode4 = 0 ;
14304  double val5 ;
14305  int ecode5 = 0 ;
14306  double val6 ;
14307  int ecode6 = 0 ;
14308  double val7 ;
14309  int ecode7 = 0 ;
14310  double val8 ;
14311  int ecode8 = 0 ;
14312  double val9 ;
14313  int ecode9 = 0 ;
14314  double val10 ;
14315  int ecode10 = 0 ;
14316  double val11 ;
14317  int ecode11 = 0 ;
14318  PyObject * obj0 = 0 ;
14319  PyObject * obj1 = 0 ;
14320  PyObject * obj2 = 0 ;
14321  PyObject * obj3 = 0 ;
14322  PyObject * obj4 = 0 ;
14323  PyObject * obj5 = 0 ;
14324  PyObject * obj6 = 0 ;
14325  PyObject * obj7 = 0 ;
14326  PyObject * obj8 = 0 ;
14327  PyObject * obj9 = 0 ;
14328  PyObject * obj10 = 0 ;
14329 
14330  {
14331  python_pltr = 0;
14332  arg12 = NULL;
14333  }
14334  {
14335  arg13 = NULL;
14336  }
14337  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14338  {
14339  int i, size;
14340  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14341  if ( tmp1 == NULL )
14342  return NULL;
14343  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14344  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14345  size = sizeof ( PLFLT ) * arg3;
14346  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
14347  for ( i = 0; i < arg2; i++ )
14348  arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
14349  }
14350  ecode4 = SWIG_AsVal_double(obj1, &val4);
14351  if (!SWIG_IsOK(ecode4)) {
14352  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14353  }
14354  arg4 = (PLFLT)(val4);
14355  ecode5 = SWIG_AsVal_double(obj2, &val5);
14356  if (!SWIG_IsOK(ecode5)) {
14357  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14358  }
14359  arg5 = (PLFLT)(val5);
14360  ecode6 = SWIG_AsVal_double(obj3, &val6);
14361  if (!SWIG_IsOK(ecode6)) {
14362  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14363  }
14364  arg6 = (PLFLT)(val6);
14365  ecode7 = SWIG_AsVal_double(obj4, &val7);
14366  if (!SWIG_IsOK(ecode7)) {
14367  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14368  }
14369  arg7 = (PLFLT)(val7);
14370  ecode8 = SWIG_AsVal_double(obj5, &val8);
14371  if (!SWIG_IsOK(ecode8)) {
14372  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14373  }
14374  arg8 = (PLFLT)(val8);
14375  ecode9 = SWIG_AsVal_double(obj6, &val9);
14376  if (!SWIG_IsOK(ecode9)) {
14377  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
14378  }
14379  arg9 = (PLFLT)(val9);
14380  ecode10 = SWIG_AsVal_double(obj7, &val10);
14381  if (!SWIG_IsOK(ecode10)) {
14382  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
14383  }
14384  arg10 = (PLFLT)(val10);
14385  ecode11 = SWIG_AsVal_double(obj8, &val11);
14386  if (!SWIG_IsOK(ecode11)) {
14387  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
14388  }
14389  arg11 = (PLFLT)(val11);
14390  if (obj9) {
14391  {
14392  // it must be a callable or None
14393  if ( obj9 == Py_None )
14394  {
14395  arg12 = NULL;
14396  }
14397  else
14398  {
14399  if ( !PyCallable_Check( (PyObject *) obj9 ) )
14400  {
14401  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
14402  return NULL;
14403  }
14404  arg12 = marshal_pltr( obj9 );
14405  }
14406  }
14407  }
14408  if (obj10) {
14409  {
14410  if ( obj10 == Py_None )
14411  arg13 = NULL;
14412  else
14413  {
14414  arg13 = marshal_PLPointer( obj10, 1 );
14415  }
14416  }
14417  }
14418  plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14419  resultobj = SWIG_Py_Void();
14420  {
14421  Py_DECREF( tmp1 );
14422  free( arg1 );
14423  }
14424  {
14425  cleanup_pltr();
14426  }
14427  {
14429  }
14430  return resultobj;
14431 fail:
14432  {
14433  Py_DECREF( tmp1 );
14434  free( arg1 );
14435  }
14436  {
14437  cleanup_pltr();
14438  }
14439  {
14441  }
14442  return NULL;
14443 }
14444 
14445 
14446 SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14447  PyObject *resultobj = 0;
14448 
14449  if (!PyArg_ParseTuple(args,(char *)":plClearOpts")) SWIG_fail;
14450  plClearOpts();
14451  resultobj = SWIG_Py_Void();
14452  return resultobj;
14453 fail:
14454  return NULL;
14455 }
14456 
14457 
14458 SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14459  PyObject *resultobj = 0;
14460 
14461  if (!PyArg_ParseTuple(args,(char *)":plResetOpts")) SWIG_fail;
14462  plResetOpts();
14463  resultobj = SWIG_Py_Void();
14464  return resultobj;
14465 fail:
14466  return NULL;
14467 }
14468 
14469 
14470 SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14471  PyObject *resultobj = 0;
14472  char *arg1 = (char *) 0 ;
14473  char *arg2 = (char *) 0 ;
14474  int res1 ;
14475  char *buf1 = 0 ;
14476  int alloc1 = 0 ;
14477  int res2 ;
14478  char *buf2 = 0 ;
14479  int alloc2 = 0 ;
14480  PyObject * obj0 = 0 ;
14481  PyObject * obj1 = 0 ;
14482 
14483  if (!PyArg_ParseTuple(args,(char *)"OO:plSetUsage",&obj0,&obj1)) SWIG_fail;
14484  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
14485  if (!SWIG_IsOK(res1)) {
14486  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
14487  }
14488  arg1 = (char *)(buf1);
14489  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14490  if (!SWIG_IsOK(res2)) {
14491  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
14492  }
14493  arg2 = (char *)(buf2);
14494  plSetUsage((char const *)arg1,(char const *)arg2);
14495  resultobj = SWIG_Py_Void();
14496  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14497  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14498  return resultobj;
14499 fail:
14500  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14501  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14502  return NULL;
14503 }
14504 
14505 
14506 SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14507  PyObject *resultobj = 0;
14508 
14509  if (!PyArg_ParseTuple(args,(char *)":plOptUsage")) SWIG_fail;
14510  plOptUsage();
14511  resultobj = SWIG_Py_Void();
14512  return resultobj;
14513 fail:
14514  return NULL;
14515 }
14516 
14517 
14518 SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14519  PyObject *resultobj = 0;
14520  PLFLT **arg1 = (PLFLT **) 0 ;
14521  PLINT arg2 ;
14522  PLINT arg3 ;
14523  PLFLT *arg4 = (PLFLT *) 0 ;
14524  PLFLT *arg5 = (PLFLT *) 0 ;
14525  PyArrayObject *tmp1 ;
14526  PLFLT temp4 ;
14527  int res4 = SWIG_TMPOBJ ;
14528  PLFLT temp5 ;
14529  int res5 = SWIG_TMPOBJ ;
14530  PyObject * obj0 = 0 ;
14531 
14532  arg4 = &temp4;
14533  arg5 = &temp5;
14534  if (!PyArg_ParseTuple(args,(char *)"O:plMinMax2dGrid",&obj0)) SWIG_fail;
14535  {
14536  int i, size;
14537  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14538  if ( tmp1 == NULL )
14539  return NULL;
14540  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14541  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14542  size = sizeof ( PLFLT ) * arg3;
14543  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
14544  for ( i = 0; i < arg2; i++ )
14545  arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
14546  }
14547  plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
14548  resultobj = SWIG_Py_Void();
14549  if (SWIG_IsTmpObj(res4)) {
14550  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
14551  } else {
14552  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14553  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14554  }
14555  if (SWIG_IsTmpObj(res5)) {
14556  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
14557  } else {
14558  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14559  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
14560  }
14561  {
14562  Py_DECREF( tmp1 );
14563  free( arg1 );
14564  }
14565  return resultobj;
14566 fail:
14567  {
14568  Py_DECREF( tmp1 );
14569  free( arg1 );
14570  }
14571  return NULL;
14572 }
14573 
14574 
14575 SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14576  PyObject *resultobj = 0;
14577  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14578  void *argp1 = 0 ;
14579  int res1 = 0 ;
14580  PyObject * obj0 = 0 ;
14581  PLINT result;
14582 
14583  if (!PyArg_ParseTuple(args,(char *)"O:plGetCursor",&obj0)) SWIG_fail;
14584  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14585  if (!SWIG_IsOK(res1)) {
14586  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14587  }
14588  arg1 = (PLGraphicsIn *)(argp1);
14589  result = (PLINT)plGetCursor(arg1);
14590  resultobj = SWIG_From_int((int)(result));
14591  return resultobj;
14592 fail:
14593  return NULL;
14594 }
14595 
14596 
14597 static PyMethodDef SwigMethods[] = {
14598  { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
14599  { (char *)"pltr0", _wrap_pltr0, METH_VARARGS, NULL},
14600  { (char *)"pltr1", _wrap_pltr1, METH_VARARGS, NULL},
14601  { (char *)"pltr2", _wrap_pltr2, METH_VARARGS, NULL},
14602  { (char *)"PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
14603  { (char *)"PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_VARARGS, NULL},
14604  { (char *)"PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
14605  { (char *)"PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_VARARGS, NULL},
14606  { (char *)"PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
14607  { (char *)"PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_VARARGS, NULL},
14608  { (char *)"PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
14609  { (char *)"PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_VARARGS, NULL},
14610  { (char *)"PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
14611  { (char *)"PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_VARARGS, NULL},
14612  { (char *)"PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
14613  { (char *)"PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_VARARGS, NULL},
14614  { (char *)"PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
14615  { (char *)"PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_VARARGS, NULL},
14616  { (char *)"PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
14617  { (char *)"PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_VARARGS, NULL},
14618  { (char *)"PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
14619  { (char *)"PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_VARARGS, NULL},
14620  { (char *)"PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
14621  { (char *)"PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_VARARGS, NULL},
14622  { (char *)"PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
14623  { (char *)"PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_VARARGS, NULL},
14624  { (char *)"PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
14625  { (char *)"PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_VARARGS, NULL},
14626  { (char *)"new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_VARARGS, NULL},
14627  { (char *)"delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_VARARGS, NULL},
14628  { (char *)"PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_VARARGS, NULL},
14629  { (char *)"plsxwin", _wrap_plsxwin, METH_VARARGS, NULL},
14630  { (char *)"pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, (char *)"\n"
14631  "Set format of numerical label for contours\n"
14632  "\n"
14633  "DESCRIPTION:\n"
14634  "\n"
14635  " Set format of numerical label for contours. \n"
14636  "\n"
14637  " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
14638  "\n"
14639  " This function is used example 9. \n"
14640  "\n"
14641  "\n"
14642  "\n"
14643  "SYNOPSIS:\n"
14644  "\n"
14645  "pl_setcontlabelformat(lexp, sigdig)\n"
14646  "\n"
14647  "ARGUMENTS:\n"
14648  "\n"
14649  " lexp (PLINT, input) : If the contour numerical label is greater\n"
14650  " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
14651  " format is used. Default value of lexp is 4. \n"
14652  "\n"
14653  " sigdig (PLINT, input) : Number of significant digits. Default\n"
14654  " value is 2. \n"
14655  "\n"
14656  ""},
14657  { (char *)"pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, (char *)"\n"
14658  "Set parameters of contour labelling other than format of numerical label\n"
14659  "\n"
14660  "DESCRIPTION:\n"
14661  "\n"
14662  " Set parameters of contour labelling other than those handled by\n"
14663  " pl_setcontlabelformat. \n"
14664  "\n"
14665  " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
14666  "\n"
14667  " This function is used in example 9. \n"
14668  "\n"
14669  "\n"
14670  "\n"
14671  "SYNOPSIS:\n"
14672  "\n"
14673  "pl_setcontlabelparam(offset, size, spacing, active)\n"
14674  "\n"
14675  "ARGUMENTS:\n"
14676  "\n"
14677  " offset (PLFLT, input) : Offset of label from contour line (if set\n"
14678  " to 0.0, labels are printed on the lines). Default value is 0.006. \n"
14679  "\n"
14680  " size (PLFLT, input) : Font height for contour labels (normalized). \n"
14681  " Default value is 0.3. \n"
14682  "\n"
14683  " spacing (PLFLT, input) : Spacing parameter for contour labels. \n"
14684  " Default value is 0.1. \n"
14685  "\n"
14686  " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
14687  " contour labels on. Default is off (0). \n"
14688  "\n"
14689  ""},
14690  { (char *)"pladv", _wrap_pladv, METH_VARARGS, (char *)"\n"
14691  "Advance the (sub-)page\n"
14692  "\n"
14693  "DESCRIPTION:\n"
14694  "\n"
14695  " Advances to the next subpage if sub=0, performing a page advance if\n"
14696  " there are no remaining subpages on the current page. If subpages\n"
14697  " aren't being used, pladv(0) will always advance the page. If sub>0,\n"
14698  " PLplot switches to the specified subpage. Note that this allows you\n"
14699  " to overwrite a plot on the specified subpage; if this is not what you\n"
14700  " intended, use pleop followed by plbop to first advance the page. This\n"
14701  " routine is called automatically (with sub=0) by plenv, but if plenv is\n"
14702  " not used, pladv must be called after initializing PLplot but before\n"
14703  " defining the viewport. \n"
14704  "\n"
14705  " Redacted form: pladv(sub)\n"
14706  "\n"
14707  " This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n"
14708  "\n"
14709  "\n"
14710  "\n"
14711  "SYNOPSIS:\n"
14712  "\n"
14713  "pladv(sub)\n"
14714  "\n"
14715  "ARGUMENTS:\n"
14716  "\n"
14717  " sub (PLINT, input) : Specifies the subpage number (starting from 1\n"
14718  " in the top left corner and increasing along the rows) to which to\n"
14719  " advance. Set to zero to advance to the next subpage. \n"
14720  "\n"
14721  ""},
14722  { (char *)"plarc", _wrap_plarc, METH_VARARGS, (char *)"\n"
14723  "Draw a circular or elliptical arc \n"
14724  "\n"
14725  "DESCRIPTION:\n"
14726  "\n"
14727  " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
14728  " semiminor axis b, starting at angle1 and ending at angle2. \n"
14729  "\n"
14730  " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
14731  " fill)\n"
14732  "\n"
14733  "\n"
14734  " This function is used in examples 3 and 27. \n"
14735  "\n"
14736  "\n"
14737  "\n"
14738  "SYNOPSIS:\n"
14739  "\n"
14740  "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
14741  "\n"
14742  "ARGUMENTS:\n"
14743  "\n"
14744  " x (PLFLT, input) : X coordinate of arc center. \n"
14745  "\n"
14746  " y (PLFLT, input) : Y coordinate of arc center. \n"
14747  "\n"
14748  " a (PLFLT, input) : Length of the semimajor axis of the arc. \n"
14749  "\n"
14750  " b (PLFLT, input) : Length of the semiminor axis of the arc. \n"
14751  "\n"
14752  " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
14753  " semimajor axis. \n"
14754  "\n"
14755  " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
14756  " semimajor axis. \n"
14757  "\n"
14758  " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
14759  " X-axis. \n"
14760  "\n"
14761  " fill (PLBOOL, input) : Draw a filled arc. \n"
14762  "\n"
14763  ""},
14764  { (char *)"plaxes", _wrap_plaxes, METH_VARARGS, (char *)"\n"
14765  "Draw a box with axes, etc. with arbitrary origin \n"
14766  "\n"
14767  "DESCRIPTION:\n"
14768  "\n"
14769  " Draws a box around the currently defined viewport with arbitrary\n"
14770  " world-coordinate origin specified by x0 and y0 and labels it with\n"
14771  " world coordinate values appropriate to the window. Thus plaxes should\n"
14772  " only be called after defining both viewport and window. The character\n"
14773  " strings xopt and yopt specify how the box should be drawn as described\n"
14774  " below. If ticks and/or subticks are to be drawn for a particular\n"
14775  " axis, the tick intervals and number of subintervals may be specified\n"
14776  " explicitly, or they may be defaulted by setting the appropriate\n"
14777  " arguments to zero. \n"
14778  "\n"
14779  " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
14780  " ytick, nysub)\n"
14781  " Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n"
14782  " yopt)\n"
14783  "\n"
14784  "\n"
14785  " This function is not used in any examples. \n"
14786  "\n"
14787  "\n"
14788  "\n"
14789  "SYNOPSIS:\n"
14790  "\n"
14791  "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14792  "\n"
14793  "ARGUMENTS:\n"
14794  "\n"
14795  " x0 (PLFLT, input) : World X coordinate of origin. \n"
14796  "\n"
14797  " y0 (PLFLT, input) : World Y coordinate of origin. \n"
14798  "\n"
14799  " xopt (const char *, input) : Pointer to character string specifying\n"
14800  " options for horizontal axis. The string can include any\n"
14801  " combination of the following letters (upper or lower case) in any\n"
14802  " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
14803  " is vertical line (x=0). \n"
14804  " b: Draws bottom (X) or left (Y) edge of frame. \n"
14805  " c: Draws top (X) or right (Y) edge of frame. \n"
14806  " d: Plot labels as date / time. Values are assumed to be\n"
14807  " seconds since the epoch (as used by gmtime). \n"
14808  " f: Always use fixed point numeric labels. \n"
14809  " g: Draws a grid at the major tick interval. \n"
14810  " h: Draws a grid at the minor tick interval. \n"
14811  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14812  " inwards. \n"
14813  " l: Labels axis logarithmically. This only affects the labels,\n"
14814  " not the data, and so it is necessary to compute the logarithms\n"
14815  " of data points before passing them to any of the drawing\n"
14816  " routines. \n"
14817  " m: Writes numeric labels at major tick intervals in the\n"
14818  " unconventional location (above box for X, right of box for Y). \n"
14819  " n: Writes numeric labels at major tick intervals in the\n"
14820  " conventional location (below box for X, left of box for Y). \n"
14821  " o: Use custom labeling function to generate axis label text. \n"
14822  " The custom labeling function can be defined with the\n"
14823  " plslabelfuncplslabelfunc; command. \n"
14824  " s: Enables subticks between major ticks, only valid if t is\n"
14825  " also specified. \n"
14826  " t: Draws major ticks. \n"
14827  "\n"
14828  "\n"
14829  " xtick (PLFLT, input) : World coordinate interval between major\n"
14830  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14831  " generates a suitable tick interval. \n"
14832  "\n"
14833  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14834  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14835  " generates a suitable minor tick interval. \n"
14836  "\n"
14837  " yopt (const char *, input) : Pointer to character string specifying\n"
14838  " options for vertical axis. The string can include any combination\n"
14839  " of the letters defined above for xopt, and in addition may\n"
14840  " contain: v: Write numeric labels for vertical axis parallel to the\n"
14841  " base of the graph, rather than parallel to the axis. \n"
14842  "\n"
14843  "\n"
14844  " ytick (PLFLT, input) : World coordinate interval between major\n"
14845  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
14846  " generates a suitable tick interval. \n"
14847  "\n"
14848  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
14849  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14850  " generates a suitable minor tick interval. \n"
14851  "\n"
14852  ""},
14853  { (char *)"plbin", _wrap_plbin, METH_VARARGS, (char *)"\n"
14854  "Plot a histogram from binned data \n"
14855  "\n"
14856  "DESCRIPTION:\n"
14857  "\n"
14858  " Plots a histogram consisting of nbin bins. The value associated with\n"
14859  " the i'th bin is placed in x[i], and the number of points in the bin is\n"
14860  " placed in y[i]. For proper operation, the values in x[i] must form a\n"
14861  " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
14862  " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
14863  " placed midway between the values in the x array. Also see plhist for\n"
14864  " drawing histograms from unbinned data. \n"
14865  "\n"
14866  " Redacted form: General: plbin(x, y, opt)\n"
14867  " Perl/PDL: plbin(nbin, x, y, opt)\n"
14868  " Python: plbin(nbin, x, y, opt)\n"
14869  "\n"
14870  "\n"
14871  " This function is not used in any examples. \n"
14872  "\n"
14873  "\n"
14874  "\n"
14875  "SYNOPSIS:\n"
14876  "\n"
14877  "plbin(nbin, x, y, opt)\n"
14878  "\n"
14879  "ARGUMENTS:\n"
14880  "\n"
14881  " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
14882  " and y arrays.) \n"
14883  "\n"
14884  " x (PLFLT *, input) : Pointer to array containing values associated\n"
14885  " with bins. These must form a strictly increasing sequence. \n"
14886  "\n"
14887  " y (PLFLT *, input) : Pointer to array containing number of points\n"
14888  " in bin. This is a PLFLT (instead of PLINT) array so as to allow\n"
14889  " histograms of probabilities, etc. \n"
14890  "\n"
14891  " opt (PLINT, input) : Is a combination of several flags:\n"
14892  " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
14893  " outer bins are expanded to fill up the entire x-axis and bins of\n"
14894  " zero height are simply drawn. \n"
14895  " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
14896  " between the x values. If the values in x are equally spaced,\n"
14897  " the values are the center values of the bins. \n"
14898  " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
14899  " size as the ones inside. \n"
14900  " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
14901  " (there is a gap for such bins). \n"
14902  "\n"
14903  ""},
14904  { (char *)"plbtime", _wrap_plbtime, METH_VARARGS, NULL},
14905  { (char *)"plbop", _wrap_plbop, METH_VARARGS, (char *)"\n"
14906  "Begin a new page\n"
14907  "\n"
14908  "DESCRIPTION:\n"
14909  "\n"
14910  " Begins a new page. For a file driver, the output file is opened if\n"
14911  " necessary. Advancing the page via pleop and plbop is useful when a\n"
14912  " page break is desired at a particular point when plotting to subpages.\n"
14913  " Another use for pleop and plbop is when plotting pages to different\n"
14914  " files, since you can manually set the file name by calling plsfnam\n"
14915  " after the call to pleop. (In fact some drivers may only support a\n"
14916  " single page per file, making this a necessity.) One way to handle\n"
14917  " this case automatically is to page advance via pladv, but enable\n"
14918  " familying (see plsfam) with a small limit on the file size so that a\n"
14919  " new family member file will be created on each page break. \n"
14920  "\n"
14921  " Redacted form: plbop()\n"
14922  "\n"
14923  " This function is used in examples 2,20. \n"
14924  "\n"
14925  "\n"
14926  "\n"
14927  "SYNOPSIS:\n"
14928  "\n"
14929  "plbop()\n"
14930  "\n"
14931  ""},
14932  { (char *)"plbox", _wrap_plbox, METH_VARARGS, (char *)"\n"
14933  "Draw a box with axes, etc\n"
14934  "\n"
14935  "DESCRIPTION:\n"
14936  "\n"
14937  " Draws a box around the currently defined viewport, and labels it with\n"
14938  " world coordinate values appropriate to the window. Thus plbox should\n"
14939  " only be called after defining both viewport and window. The character\n"
14940  " strings xopt and yopt specify how the box should be drawn as described\n"
14941  " below. If ticks and/or subticks are to be drawn for a particular\n"
14942  " axis, the tick intervals and number of subintervals may be specified\n"
14943  " explicitly, or they may be defaulted by setting the appropriate\n"
14944  " arguments to zero. \n"
14945  "\n"
14946  " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14947  " Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n"
14948  "\n"
14949  "\n"
14950  " This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n"
14951  "\n"
14952  "\n"
14953  "\n"
14954  "SYNOPSIS:\n"
14955  "\n"
14956  "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14957  "\n"
14958  "ARGUMENTS:\n"
14959  "\n"
14960  " xopt (const char *, input) : Pointer to character string specifying\n"
14961  " options for horizontal axis. The string can include any\n"
14962  " combination of the following letters (upper or lower case) in any\n"
14963  " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
14964  " is vertical line (x=0). \n"
14965  " b: Draws bottom (X) or left (Y) edge of frame. \n"
14966  " c: Draws top (X) or right (Y) edge of frame. \n"
14967  " d: Plot labels as date / time. Values are assumed to be\n"
14968  " seconds since the epoch (as used by gmtime). \n"
14969  " f: Always use fixed point numeric labels. \n"
14970  " g: Draws a grid at the major tick interval. \n"
14971  " h: Draws a grid at the minor tick interval. \n"
14972  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14973  " inwards. \n"
14974  " l: Labels axis logarithmically. This only affects the labels,\n"
14975  " not the data, and so it is necessary to compute the logarithms\n"
14976  " of data points before passing them to any of the drawing\n"
14977  " routines. \n"
14978  " m: Writes numeric labels at major tick intervals in the\n"
14979  " unconventional location (above box for X, right of box for Y). \n"
14980  " n: Writes numeric labels at major tick intervals in the\n"
14981  " conventional location (below box for X, left of box for Y). \n"
14982  " o: Use custom labeling function to generate axis label text. \n"
14983  " The custom labeling function can be defined with the\n"
14984  " plslabelfuncplslabelfunc; command. \n"
14985  " s: Enables subticks between major ticks, only valid if t is\n"
14986  " also specified. \n"
14987  " t: Draws major ticks. \n"
14988  " u: Exactly like \"b\" except don't draw edge line. \n"
14989  " w: Exactly like \"c\" except don't draw edge line. \n"
14990  "\n"
14991  "\n"
14992  " xtick (PLFLT, input) : World coordinate interval between major\n"
14993  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14994  " generates a suitable tick interval. \n"
14995  "\n"
14996  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14997  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14998  " generates a suitable minor tick interval. \n"
14999  "\n"
15000  " yopt (const char *, input) : Pointer to character string specifying\n"
15001  " options for vertical axis. The string can include any combination\n"
15002  " of the letters defined above for xopt, and in addition may\n"
15003  " contain: v: Write numeric labels for vertical axis parallel to the\n"
15004  " base of the graph, rather than parallel to the axis. \n"
15005  "\n"
15006  "\n"
15007  " ytick (PLFLT, input) : World coordinate interval between major\n"
15008  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15009  " generates a suitable tick interval. \n"
15010  "\n"
15011  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15012  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15013  " generates a suitable minor tick interval. \n"
15014  "\n"
15015  ""},
15016  { (char *)"plbox3", _wrap_plbox3, METH_VARARGS, (char *)"\n"
15017  "Draw a box with axes, etc, in 3-d \n"
15018  "\n"
15019  "DESCRIPTION:\n"
15020  "\n"
15021  " Draws axes, numeric and text labels for a three-dimensional surface\n"
15022  " plot. For a more complete description of three-dimensional plotting\n"
15023  " see the PLplot documentation. \n"
15024  "\n"
15025  " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15026  " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15027  " Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n"
15028  " xopt, xlabel, yopt, ylabel, zopt, zlabel)\n"
15029  "\n"
15030  "\n"
15031  " This function is used in examples 8,11,18,21. \n"
15032  "\n"
15033  "\n"
15034  "\n"
15035  "SYNOPSIS:\n"
15036  "\n"
15037  "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15038  "\n"
15039  "ARGUMENTS:\n"
15040  "\n"
15041  " xopt (const char *, input) : Pointer to character string specifying\n"
15042  " options for the x axis. The string can include any combination of\n"
15043  " the following letters (upper or lower case) in any order: b: Draws\n"
15044  " axis at base, at height z=\n"
15045  " zmin where zmin is defined by call to plw3d. This character must be\n"
15046  " specified in order to use any of the other options. \n"
15047  " f: Always use fixed point numeric labels. \n"
15048  " i: Inverts tick marks, so they are drawn downwards, rather\n"
15049  " than upwards. \n"
15050  " l: Labels axis logarithmically. This only affects the labels,\n"
15051  " not the data, and so it is necessary to compute the logarithms\n"
15052  " of data points before passing them to any of the drawing\n"
15053  " routines. \n"
15054  " n: Writes numeric labels at major tick intervals. \n"
15055  " o: Use custom labeling function to generate axis label text. \n"
15056  " The custom labeling function can be defined with the\n"
15057  " plslabelfuncplslabelfunc; command. \n"
15058  " s: Enables subticks between major ticks, only valid if t is\n"
15059  " also specified. \n"
15060  " t: Draws major ticks. \n"
15061  " u: If this is specified, the text label for the axis is\n"
15062  " written under the axis. \n"
15063  "\n"
15064  "\n"
15065  " xlabel (const char *, input) : Pointer to character string\n"
15066  " specifying text label for the x axis. It is only drawn if u is in\n"
15067  " the xopt string. \n"
15068  "\n"
15069  " xtick (PLFLT, input) : World coordinate interval between major\n"
15070  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15071  " generates a suitable tick interval. \n"
15072  "\n"
15073  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15074  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15075  " generates a suitable minor tick interval. \n"
15076  "\n"
15077  " yopt (const char *, input) : Pointer to character string specifying\n"
15078  " options for the y axis. The string is interpreted in the same way\n"
15079  " as xopt. \n"
15080  "\n"
15081  " ylabel (const char *, input) : Pointer to character string\n"
15082  " specifying text label for the y axis. It is only drawn if u is in\n"
15083  " the yopt string. \n"
15084  "\n"
15085  " ytick (PLFLT, input) : World coordinate interval between major\n"
15086  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15087  " generates a suitable tick interval. \n"
15088  "\n"
15089  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15090  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15091  " generates a suitable minor tick interval. \n"
15092  "\n"
15093  " zopt (const char *, input) : Pointer to character string specifying\n"
15094  " options for the z axis. The string can include any combination of\n"
15095  " the following letters (upper or lower case) in any order: b: Draws\n"
15096  " z axis to the left of the surface plot. \n"
15097  " c: Draws z axis to the right of the surface plot. \n"
15098  " d: Draws grid lines parallel to the x-y plane behind the\n"
15099  " figure. These lines are not drawn until after plot3d or\n"
15100  " plmesh are called because of the need for hidden line removal. \n"
15101  " f: Always use fixed point numeric labels. \n"
15102  " i: Inverts tick marks, so they are drawn away from the center. \n"
15103  " l: Labels axis logarithmically. This only affects the labels,\n"
15104  " not the data, and so it is necessary to compute the logarithms\n"
15105  " of data points before passing them to any of the drawing\n"
15106  " routines. \n"
15107  " m: Writes numeric labels at major tick intervals on the\n"
15108  " right-hand vertical axis. \n"
15109  " n: Writes numeric labels at major tick intervals on the\n"
15110  " left-hand vertical axis. \n"
15111  " o: Use custom labeling function to generate axis label text. \n"
15112  " The custom labeling function can be defined with the\n"
15113  " plslabelfuncplslabelfunc; command. \n"
15114  " s: Enables subticks between major ticks, only valid if t is\n"
15115  " also specified. \n"
15116  " t: Draws major ticks. \n"
15117  " u: If this is specified, the text label is written beside the\n"
15118  " left-hand axis. \n"
15119  " v: If this is specified, the text label is written beside the\n"
15120  " right-hand axis. \n"
15121  "\n"
15122  "\n"
15123  " zlabel (const char *, input) : Pointer to character string\n"
15124  " specifying text label for the z axis. It is only drawn if u or v\n"
15125  " are in the zopt string. \n"
15126  "\n"
15127  " ztick (PLFLT, input) : World coordinate interval between major\n"
15128  " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15129  " generates a suitable tick interval. \n"
15130  "\n"
15131  " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15132  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15133  " generates a suitable minor tick interval. \n"
15134  "\n"
15135  ""},
15136  { (char *)"plcalc_world", _wrap_plcalc_world, METH_VARARGS, (char *)"\n"
15137  "Calculate world coordinates and corresponding window index from relative device coordinates \n"
15138  "\n"
15139  "DESCRIPTION:\n"
15140  "\n"
15141  " Calculate world coordinates, wx and wy, and corresponding window index\n"
15142  " from relative device coordinates, rx and ry. \n"
15143  "\n"
15144  " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15145  " Perl/PDL: Not available? \n"
15146  "\n"
15147  "\n"
15148  " This function is used in example 31. \n"
15149  "\n"
15150  "\n"
15151  "\n"
15152  "SYNOPSIS:\n"
15153  "\n"
15154  "plcalc_world(rx, ry, wx, wy, window)\n"
15155  "\n"
15156  "ARGUMENTS:\n"
15157  "\n"
15158  " rx (PLFLT, input) : Input relative device coordinate (ranging from\n"
15159  " 0. to 1.) for the x coordinate. \n"
15160  "\n"
15161  " ry (PLFLT, input) : Input relative device coordinate (ranging from\n"
15162  " 0. to 1.) for the y coordinate. \n"
15163  "\n"
15164  " wx (PLFLT *, output) : Pointer to the returned world coordinate for\n"
15165  " x corresponding to the relative device coordinates rx and ry. \n"
15166  "\n"
15167  " wy (PLFLT *, output) : Pointer to the returned world coordinate for\n"
15168  " y corresponding to the relative device coordinates rx and ry. \n"
15169  "\n"
15170  " window (PLINT *, output) : Pointer to the returned last defined\n"
15171  " window index that corresponds to the input relative device\n"
15172  " coordinates (and the returned world coordinates). To give some\n"
15173  " background on the window index, for each page the initial window\n"
15174  " index is set to zero, and each time plwind is called within the\n"
15175  " page, world and device coordinates are stored for the window and\n"
15176  " the window index is incremented. Thus, for a simple page layout\n"
15177  " with non-overlapping viewports and one window per viewport, window\n"
15178  " corresponds to the viewport index (in the order which the\n"
15179  " viewport/windows were created) of the only viewport/window\n"
15180  " corresponding to rx and ry. However, for more complicated layouts\n"
15181  " with potentially overlapping viewports and possibly more than one\n"
15182  " window (set of world coordinates) per viewport, window and the\n"
15183  " corresponding output world coordinates corresponds to the last\n"
15184  " window created that fulfils the criterion that the relative device\n"
15185  " coordinates are inside it. Finally, in all cases where the input\n"
15186  " relative device coordinates are not inside any viewport/window,\n"
15187  " then window is set to -1. \n"
15188  "\n"
15189  ""},
15190  { (char *)"plclear", _wrap_plclear, METH_VARARGS, (char *)"\n"
15191  "Clear current (sub)page \n"
15192  "\n"
15193  "DESCRIPTION:\n"
15194  "\n"
15195  " Clears the current page, effectively erasing everything that have been\n"
15196  " drawn. This command only works with interactive drivers; if the\n"
15197  " driver does not support this, the page is filled with the background\n"
15198  " color in use. If the current page is divided into subpages, only the\n"
15199  " current subpage is erased. The nth subpage can be selected with\n"
15200  " pladv(n). \n"
15201  "\n"
15202  " Redacted form: General: plclear()\n"
15203  " Perl/PDL: Not available? \n"
15204  "\n"
15205  "\n"
15206  " This function is not used in any examples. \n"
15207  "\n"
15208  "\n"
15209  "\n"
15210  "SYNOPSIS:\n"
15211  "\n"
15212  "plclear()\n"
15213  "\n"
15214  ""},
15215  { (char *)"plcol0", _wrap_plcol0, METH_VARARGS, (char *)"\n"
15216  "Set color, map0 \n"
15217  "\n"
15218  "DESCRIPTION:\n"
15219  "\n"
15220  " Sets the color for color map0 (see the PLplot documentation). \n"
15221  "\n"
15222  " Redacted form: plcol0(color)\n"
15223  "\n"
15224  " This function is used in examples 1-9,11-16,18-27,29. \n"
15225  "\n"
15226  "\n"
15227  "\n"
15228  "SYNOPSIS:\n"
15229  "\n"
15230  "plcol0(color)\n"
15231  "\n"
15232  "ARGUMENTS:\n"
15233  "\n"
15234  " color (PLINT, input) : Integer representing the color. The\n"
15235  " defaults at present are (these may change): \n"
15236  " 0 black (default background) \n"
15237  " 1 red (default foreground) \n"
15238  " 2 yellow \n"
15239  " 3 green \n"
15240  " 4 aquamarine \n"
15241  " 5 pink \n"
15242  " 6 wheat \n"
15243  " 7 grey \n"
15244  " 8 brown \n"
15245  " 9 blue \n"
15246  " 10 BlueViolet \n"
15247  " 11 cyan \n"
15248  " 12 turquoise \n"
15249  " 13 magenta \n"
15250  " 14 salmon \n"
15251  " 15 white \n"
15252  "\n"
15253  " Use plscmap0 to change the entire map0 color palette and plscol0 to\n"
15254  " change an individual color in the map0 color palette. \n"
15255  "\n"
15256  ""},
15257  { (char *)"plcol1", _wrap_plcol1, METH_VARARGS, (char *)"\n"
15258  "Set color, map1 \n"
15259  "\n"
15260  "DESCRIPTION:\n"
15261  "\n"
15262  " Sets the color for color map1 (see the PLplot documentation). \n"
15263  "\n"
15264  " Redacted form: plcol1(col1)\n"
15265  "\n"
15266  " This function is used in examples 12 and 21. \n"
15267  "\n"
15268  "\n"
15269  "\n"
15270  "SYNOPSIS:\n"
15271  "\n"
15272  "plcol1(col1)\n"
15273  "\n"
15274  "ARGUMENTS:\n"
15275  "\n"
15276  " col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n"
15277  " and is mapped to color using the continuous map1 color palette\n"
15278  " which by default ranges from blue to the background color to red. \n"
15279  " The map1 palette can also be straightforwardly changed by the user\n"
15280  " with plscmap1 or plscmap1l. \n"
15281  "\n"
15282  ""},
15283  { (char *)"plconfigtime", _wrap_plconfigtime, METH_VARARGS, NULL},
15284  { (char *)"plcont", _wrap_plcont, METH_VARARGS, (char *)"\n"
15285  "Contour plot \n"
15286  "\n"
15287  "DESCRIPTION:\n"
15288  "\n"
15289  " Draws a contour plot of the data in z[\n"
15290  " nx][\n"
15291  " ny], using the nlevel contour levels specified by clevel. Only the\n"
15292  " region of the array from kx to lx and from ky to ly is plotted out. A\n"
15293  " transformation routine pointed to by pltr with a pointer pltr_data for\n"
15294  " additional data required by the transformation routine is used to map\n"
15295  " indices within the array to the world coordinates. See the following\n"
15296  " discussion of the arguments and the PLplot documentation for more\n"
15297  " information. \n"
15298  "\n"
15299  " Redacted form: [PLEASE UPDATE! ONLY PERL INFO IS LIKELY CORRECT!] F95:\n"
15300  " plcont(z, kx, lx, ky, ly, clevel, tr?) or plcont(z, kx, lx, ky, ly,\n"
15301  " clevel, xgrid, ygrid)\n"
15302  " Java: pls.cont(z, kx, lx, ky, ly, clevel, xgrid, ygrid)\n"
15303  " Perl/PDL: plcont(z, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
15304  " Python: plcont2(z, kx, lx, ky, ly, clevel)\n"
15305  "\n"
15306  "\n"
15307  " This function is used in examples 9,14,16,22. \n"
15308  "\n"
15309  "\n"
15310  "\n"
15311  "SYNOPSIS:\n"
15312  "\n"
15313  "plcont(z, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
15314  "\n"
15315  "ARGUMENTS:\n"
15316  "\n"
15317  " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
15318  " containing data to be contoured. \n"
15319  "\n"
15320  " nx, ny (PLINT, input) : Physical dimensions of array z. \n"
15321  "\n"
15322  " kx, lx (PLINT, input) : Range of x indices to consider. \n"
15323  "\n"
15324  " ky, ly (PLINT, input) : Range of y indices to consider. \n"
15325  "\n"
15326  " clevel (PLFLT *, input) : Pointer to array specifying levels at\n"
15327  " which to draw contours. \n"
15328  "\n"
15329  " nlevel (PLINT, input) : Number of contour levels to draw. \n"
15330  "\n"
15331  " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
15332  " Pointer to function that defines transformation between indices\n"
15333  " in array z and the world coordinates (C only). Transformation\n"
15334  " functions are provided in the PLplot library: pltr0 for identity\n"
15335  " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
15336  " defined by one- and two-dimensional arrays. In addition,\n"
15337  " user-supplied routines for the transformation can be used as well.\n"
15338  " Examples of all of these approaches are given in the PLplot\n"
15339  " documentation. The transformation function should have the form\n"
15340  " given by any of pltr0, pltr1, or pltr2. Note that unlike plshades\n"
15341  " and similar PLplot functions which have a pltr argument, plcont\n"
15342  " requires that a transformation function be provided in the C\n"
15343  " interface. Leaving pltr NULL will result in an error. \n"
15344  "\n"
15345  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
15346  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
15347  " externally supplied. \n"
15348  "\n"
15349  ""},
15350  { (char *)"plctime", _wrap_plctime, METH_VARARGS, NULL},
15351  { (char *)"plcpstrm", _wrap_plcpstrm, METH_VARARGS, (char *)"\n"
15352  "Copy state parameters from the reference stream to the current stream \n"
15353  "\n"
15354  "DESCRIPTION:\n"
15355  "\n"
15356  " Copies state parameters from the reference stream to the current\n"
15357  " stream. Tell driver interface to map device coordinates unless flags\n"
15358  " == 1. \n"
15359  "\n"
15360  " This function is used for making save files of selected plots (e.g.\n"
15361  " from the TK driver). After initializing, you can get a copy of the\n"
15362  " current plot to the specified device by switching to this stream and\n"
15363  " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
15364  " appropriate. The plot buffer must have previously been enabled (done\n"
15365  " automatically by some display drivers, such as X). \n"
15366  "\n"
15367  " Redacted form: plcpstrm(iplsr, flags)\n"
15368  "\n"
15369  " This function is used in example 1,20. \n"
15370  "\n"
15371  "\n"
15372  "\n"
15373  "SYNOPSIS:\n"
15374  "\n"
15375  "plcpstrm(iplsr, flags)\n"
15376  "\n"
15377  "ARGUMENTS:\n"
15378  "\n"
15379  " iplsr (PLINT, input) : Number of reference stream. \n"
15380  "\n"
15381  " flags (PLBOOL, input) : If flags is set to true the device\n"
15382  " coordinates are not copied from the reference to current stream. \n"
15383  "\n"
15384  ""},
15385  { (char *)"plend", _wrap_plend, METH_VARARGS, (char *)"\n"
15386  "End plotting session \n"
15387  "\n"
15388  "DESCRIPTION:\n"
15389  "\n"
15390  " Ends a plotting session, tidies up all the output files, switches\n"
15391  " interactive devices back into text mode and frees up any memory that\n"
15392  " was allocated. Must be called before end of program. \n"
15393  "\n"
15394  " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
15395  " wait state after a call to plend or other functions which trigger the\n"
15396  " end of a plot page. To avoid this, use the plspause function. \n"
15397  "\n"
15398  " Redacted form: plend()\n"
15399  "\n"
15400  " This function is used in all of the examples. \n"
15401  "\n"
15402  "\n"
15403  "\n"
15404  "SYNOPSIS:\n"
15405  "\n"
15406  "plend()\n"
15407  "\n"
15408  ""},
15409  { (char *)"plend1", _wrap_plend1, METH_VARARGS, (char *)"\n"
15410  "End plotting session for current stream \n"
15411  "\n"
15412  "DESCRIPTION:\n"
15413  "\n"
15414  " Ends a plotting session for the current output stream only. See\n"
15415  " plsstrm for more info. \n"
15416  "\n"
15417  " Redacted form: plend1()\n"
15418  "\n"
15419  " This function is used in examples 1,20. \n"
15420  "\n"
15421  "\n"
15422  "\n"
15423  "SYNOPSIS:\n"
15424  "\n"
15425  "plend1()\n"
15426  "\n"
15427  ""},
15428  { (char *)"plenv", _wrap_plenv, METH_VARARGS, (char *)"\n"
15429  "Set up standard window and draw box \n"
15430  "\n"
15431  "DESCRIPTION:\n"
15432  "\n"
15433  " Sets up plotter environment for simple graphs by calling pladv and\n"
15434  " setting up viewport and window to sensible default values. plenv\n"
15435  " leaves enough room around most graphs for axis labels and a title.\n"
15436  " When these defaults are not suitable, use the individual routines\n"
15437  " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
15438  " defining the window, and plbox for drawing the box. \n"
15439  "\n"
15440  " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15441  "\n"
15442  " This function is used in example 1,3,9,13,14,19-22,29. \n"
15443  "\n"
15444  "\n"
15445  "\n"
15446  "SYNOPSIS:\n"
15447  "\n"
15448  "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15449  "\n"
15450  "ARGUMENTS:\n"
15451  "\n"
15452  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15453  " world coordinates). \n"
15454  "\n"
15455  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15456  " world coordinates). \n"
15457  "\n"
15458  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15459  " coordinates). \n"
15460  "\n"
15461  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15462  " coordinates). \n"
15463  "\n"
15464  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15465  " scales will not be set, the user must set up the scale before\n"
15466  " calling plenv using plsvpa, plvasp or other. \n"
15467  " 0: the x and y axes are scaled independently to use as much of\n"
15468  " the screen as possible. \n"
15469  " 1: the scales of the x and y axes are made equal. \n"
15470  " 2: the axis of the x and y axes are made equal, and the plot\n"
15471  " box will be square. \n"
15472  "\n"
15473  "\n"
15474  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15475  " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
15476  " -1: draw box only. \n"
15477  " 0: draw box, ticks, and numeric tick labels. \n"
15478  " 1: also draw coordinate axes at x=0 and y=0. \n"
15479  " 2: also draw a grid at major tick positions in both\n"
15480  " coordinates. \n"
15481  " 3: also draw a grid at minor tick positions in both\n"
15482  " coordinates. \n"
15483  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15484  " have to be converted to logarithms separately.) \n"
15485  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15486  " have to be converted to logarithms separately.) \n"
15487  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15488  " have to be converted to logarithms separately.) \n"
15489  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15490  " have to be converted to logarithms separately.) \n"
15491  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15492  " have to be converted to logarithms separately.) \n"
15493  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15494  " have to be converted to logarithms separately.) \n"
15495  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15496  " have to be converted to logarithms separately.) \n"
15497  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15498  " have to be converted to logarithms separately.) \n"
15499  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15500  " and y data have to be converted to logarithms separately.) \n"
15501  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15502  " and y data have to be converted to logarithms separately.) \n"
15503  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15504  " and y data have to be converted to logarithms separately.) \n"
15505  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15506  " and y data have to be converted to logarithms separately.) \n"
15507  " 40: same as 0 except date / time x labels. \n"
15508  " 41: same as 1 except date / time x labels. \n"
15509  " 42: same as 2 except date / time x labels. \n"
15510  " 43: same as 3 except date / time x labels. \n"
15511  " 50: same as 0 except date / time y labels. \n"
15512  " 51: same as 1 except date / time y labels. \n"
15513  " 52: same as 2 except date / time y labels. \n"
15514  " 53: same as 3 except date / time y labels. \n"
15515  " 60: same as 0 except date / time x and y labels. \n"
15516  " 61: same as 1 except date / time x and y labels. \n"
15517  " 62: same as 2 except date / time x and y labels. \n"
15518  " 63: same as 3 except date / time x and y labels. \n"
15519  " 70: same as 0 except custom x and y labels. \n"
15520  " 71: same as 1 except custom x and y labels. \n"
15521  " 72: same as 2 except custom x and y labels. \n"
15522  " 73: same as 3 except custom x and y labels. \n"
15523  "\n"
15524  ""},
15525  { (char *)"plenv0", _wrap_plenv0, METH_VARARGS, (char *)"\n"
15526  "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it. \n"
15527  "\n"
15528  "DESCRIPTION:\n"
15529  "\n"
15530  " Sets up plotter environment for simple graphs by calling pladv and\n"
15531  " setting up viewport and window to sensible default values. plenv0\n"
15532  " leaves enough room around most graphs for axis labels and a title.\n"
15533  " When these defaults are not suitable, use the individual routines\n"
15534  " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
15535  " defining the window, and plbox for drawing the box. \n"
15536  "\n"
15537  " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15538  "\n"
15539  " This function is used in example 21. \n"
15540  "\n"
15541  "\n"
15542  "\n"
15543  "SYNOPSIS:\n"
15544  "\n"
15545  "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15546  "\n"
15547  "ARGUMENTS:\n"
15548  "\n"
15549  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15550  " world coordinates). \n"
15551  "\n"
15552  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15553  " world coordinates). \n"
15554  "\n"
15555  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15556  " coordinates). \n"
15557  "\n"
15558  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15559  " coordinates). \n"
15560  "\n"
15561  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15562  " scales will not be set, the user must set up the scale before\n"
15563  " calling plenv0 using plsvpa, plvasp or other. \n"
15564  " 0: the x and y axes are scaled independently to use as much of\n"
15565  " the screen as possible. \n"
15566  " 1: the scales of the x and y axes are made equal. \n"
15567  " 2: the axis of the x and y axes are made equal, and the plot\n"
15568  " box will be square. \n"
15569  "\n"
15570  "\n"
15571  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15572  " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
15573  " -1: draw box only. \n"
15574  " 0: draw box, ticks, and numeric tick labels. \n"
15575  " 1: also draw coordinate axes at x=0 and y=0. \n"
15576  " 2: also draw a grid at major tick positions in both\n"
15577  " coordinates. \n"
15578  " 3: also draw a grid at minor tick positions in both\n"
15579  " coordinates. \n"
15580  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15581  " have to be converted to logarithms separately.) \n"
15582  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15583  " have to be converted to logarithms separately.) \n"
15584  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15585  " have to be converted to logarithms separately.) \n"
15586  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15587  " have to be converted to logarithms separately.) \n"
15588  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15589  " have to be converted to logarithms separately.) \n"
15590  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15591  " have to be converted to logarithms separately.) \n"
15592  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15593  " have to be converted to logarithms separately.) \n"
15594  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15595  " have to be converted to logarithms separately.) \n"
15596  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15597  " and y data have to be converted to logarithms separately.) \n"
15598  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15599  " and y data have to be converted to logarithms separately.) \n"
15600  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15601  " and y data have to be converted to logarithms separately.) \n"
15602  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15603  " and y data have to be converted to logarithms separately.) \n"
15604  " 40: same as 0 except date / time x labels. \n"
15605  " 41: same as 1 except date / time x labels. \n"
15606  " 42: same as 2 except date / time x labels. \n"
15607  " 43: same as 3 except date / time x labels. \n"
15608  " 50: same as 0 except date / time y labels. \n"
15609  " 51: same as 1 except date / time y labels. \n"
15610  " 52: same as 2 except date / time y labels. \n"
15611  " 53: same as 3 except date / time y labels. \n"
15612  " 60: same as 0 except date / time x and y labels. \n"
15613  " 61: same as 1 except date / time x and y labels. \n"
15614  " 62: same as 2 except date / time x and y labels. \n"
15615  " 63: same as 3 except date / time x and y labels. \n"
15616  " 70: same as 0 except custom x and y labels. \n"
15617  " 71: same as 1 except custom x and y labels. \n"
15618  " 72: same as 2 except custom x and y labels. \n"
15619  " 73: same as 3 except custom x and y labels. \n"
15620  "\n"
15621  ""},
15622  { (char *)"pleop", _wrap_pleop, METH_VARARGS, (char *)"\n"
15623  "Eject current page \n"
15624  "\n"
15625  "DESCRIPTION:\n"
15626  "\n"
15627  " Clears the graphics screen of an interactive device, or ejects a page\n"
15628  " on a plotter. See plbop for more information. \n"
15629  "\n"
15630  " Redacted form: pleop()\n"
15631  "\n"
15632  " This function is used in example 2,14. \n"
15633  "\n"
15634  "\n"
15635  "\n"
15636  "SYNOPSIS:\n"
15637  "\n"
15638  "pleop()\n"
15639  "\n"
15640  ""},
15641  { (char *)"plerrx", _wrap_plerrx, METH_VARARGS, (char *)"\n"
15642  "Draw x error bar \n"
15643  "\n"
15644  "DESCRIPTION:\n"
15645  "\n"
15646  " Draws a set of n horizontal error bars, the i'th error bar extending\n"
15647  " from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n"
15648  " error bar are of length equal to the minor tick length (settable using\n"
15649  " plsmin). \n"
15650  "\n"
15651  " Redacted form: General: plerrx(xmin, ymax, y)\n"
15652  " Perl/PDL: plerrx(n, xmin, xmax, y)\n"
15653  "\n"
15654  "\n"
15655  " This function is used in example 29. \n"
15656  "\n"
15657  "\n"
15658  "\n"
15659  "SYNOPSIS:\n"
15660  "\n"
15661  "plerrx(n, xmin, xmax, y)\n"
15662  "\n"
15663  "ARGUMENTS:\n"
15664  "\n"
15665  " n (PLINT, input) : Number of error bars to draw. \n"
15666  "\n"
15667  " xmin (PLFLT *, input) : Pointer to array with x coordinates of\n"
15668  " left-hand endpoint of error bars. \n"
15669  "\n"
15670  " xmax (PLFLT *, input) : Pointer to array with x coordinates of\n"
15671  " right-hand endpoint of error bars. \n"
15672  "\n"
15673  " y (PLFLT *, input) : Pointer to array with y coordinates of error\n"
15674  " bar. \n"
15675  "\n"
15676  ""},
15677  { (char *)"plerry", _wrap_plerry, METH_VARARGS, (char *)"\n"
15678  "Draw y error bar \n"
15679  "\n"
15680  "DESCRIPTION:\n"
15681  "\n"
15682  " Draws a set of n vertical error bars, the i'th error bar extending\n"
15683  " from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n"
15684  " error bar are of length equal to the minor tick length (settable using\n"
15685  " plsmin). \n"
15686  "\n"
15687  " Redacted form: General: plerry(x, ymin, ymax)\n"
15688  " Perl/PDL: plerry(n, x, ymin, ymax)\n"
15689  "\n"
15690  "\n"
15691  " This function is used in example 29. \n"
15692  "\n"
15693  "\n"
15694  "\n"
15695  "SYNOPSIS:\n"
15696  "\n"
15697  "plerry(n, x, ymin, ymax)\n"
15698  "\n"
15699  "ARGUMENTS:\n"
15700  "\n"
15701  " n (PLINT, input) : Number of error bars to draw. \n"
15702  "\n"
15703  " x (PLFLT *, input) : Pointer to array with x coordinates of error\n"
15704  " bars. \n"
15705  "\n"
15706  " ymin (PLFLT *, input) : Pointer to array with y coordinates of\n"
15707  " lower endpoint of error bars. \n"
15708  "\n"
15709  " ymax (PLFLT *, input) : Pointer to array with y coordinate of upper\n"
15710  " endpoint of error bar. \n"
15711  "\n"
15712  ""},
15713  { (char *)"plfamadv", _wrap_plfamadv, METH_VARARGS, (char *)"\n"
15714  "Advance to the next family file on the next new page \n"
15715  "\n"
15716  "DESCRIPTION:\n"
15717  "\n"
15718  " Advance to the next family file on the next new page. \n"
15719  "\n"
15720  " Redacted form: plfamadv()\n"
15721  "\n"
15722  " This function is not used in any examples. \n"
15723  "\n"
15724  "\n"
15725  "\n"
15726  "SYNOPSIS:\n"
15727  "\n"
15728  "plfamadv()\n"
15729  "\n"
15730  ""},
15731  { (char *)"plfill", _wrap_plfill, METH_VARARGS, (char *)"\n"
15732  "Draw filled polygon \n"
15733  "\n"
15734  "DESCRIPTION:\n"
15735  "\n"
15736  " Fills the polygon defined by the n points (\n"
15737  " x[i], \n"
15738  " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
15739  " style is a solid fill. The routine will automatically close the\n"
15740  " polygon between the last and first vertices. If multiple closed\n"
15741  " polygons are passed in x and y then plfill will fill in between them. \n"
15742  "\n"
15743  " Redacted form: plfill(x,y)\n"
15744  "\n"
15745  " This function is used in examples 12,13,15,16,21,24,25. \n"
15746  "\n"
15747  "\n"
15748  "\n"
15749  "SYNOPSIS:\n"
15750  "\n"
15751  "plfill(n, x, y)\n"
15752  "\n"
15753  "ARGUMENTS:\n"
15754  "\n"
15755  " n (PLINT, input) : Number of vertices in polygon. \n"
15756  "\n"
15757  " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15758  " vertices. \n"
15759  "\n"
15760  " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15761  " vertices. \n"
15762  "\n"
15763  ""},
15764  { (char *)"plfill3", _wrap_plfill3, METH_VARARGS, (char *)"\n"
15765  "Draw filled polygon in 3D \n"
15766  "\n"
15767  "DESCRIPTION:\n"
15768  "\n"
15769  " Fills the 3D polygon defined by the n points in the x, y, and z arrays\n"
15770  " using the pattern defined by plpsty or plpat. The routine will\n"
15771  " automatically close the polygon between the last and first vertices. \n"
15772  " If multiple closed polygons are passed in x, y, and z then plfill3\n"
15773  " will fill in between them. \n"
15774  "\n"
15775  " Redacted form: General: plfill3(x, y, z)\n"
15776  " Perl/PDL: plfill3(n, x, y, z)\n"
15777  "\n"
15778  "\n"
15779  " This function is used in example 15. \n"
15780  "\n"
15781  "\n"
15782  "\n"
15783  "SYNOPSIS:\n"
15784  "\n"
15785  "plfill3(n, x, y, z)\n"
15786  "\n"
15787  "ARGUMENTS:\n"
15788  "\n"
15789  " n (PLINT, input) : Number of vertices in polygon. \n"
15790  "\n"
15791  " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15792  " vertices. \n"
15793  "\n"
15794  " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15795  " vertices. \n"
15796  "\n"
15797  " z (PLFLT *, input) : Pointer to array with z coordinates of\n"
15798  " vertices. \n"
15799  "\n"
15800  ""},
15801  { (char *)"plgradient", _wrap_plgradient, METH_VARARGS, (char *)"\n"
15802  "Draw linear gradient inside polygon \n"
15803  "\n"
15804  "DESCRIPTION:\n"
15805  "\n"
15806  " Draw a linear gradient using colour map 1 inside the polygon defined\n"
15807  " by the n points (\n"
15808  " x[i], \n"
15809  " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
15810  " polygon coordinates and the gradient angle are all expressed in world\n"
15811  " coordinates. The angle from the x axis for both the rotated\n"
15812  " coordinate system and the gradient vector is specified by angle. The\n"
15813  " magnitude of the gradient vector is the difference between the maximum\n"
15814  " and minimum values of x for the vertices in the rotated coordinate\n"
15815  " system. The origin of the gradient vector can be interpreted as being\n"
15816  " anywhere on the line corresponding to the minimum x value for the\n"
15817  " vertices in the rotated coordinate system. The distance along the\n"
15818  " gradient vector is linearly transformed to the independent variable of\n"
15819  " colour map 1 which ranges from 0. at the tail of the gradient vector\n"
15820  " to 1. at the head of the gradient vector. What is drawn is the RGBA\n"
15821  " colour corresponding to the independent variable of colour map 1. For\n"
15822  " more information about colour map 1 (see the PLplot documentation). \n"
15823  "\n"
15824  " Redacted form: plgradient(x,y,angle)\n"
15825  "\n"
15826  " This function is used in examples 25,30. \n"
15827  "\n"
15828  "\n"
15829  "\n"
15830  "SYNOPSIS:\n"
15831  "\n"
15832  "plgradient(n, x, y, angle)\n"
15833  "\n"
15834  "ARGUMENTS:\n"
15835  "\n"
15836  " n (PLINT, input) : Number of vertices in polygon. \n"
15837  "\n"
15838  " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15839  " vertices. \n"
15840  "\n"
15841  " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15842  " vertices. \n"
15843  "\n"
15844  " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
15845  " axis. \n"
15846  "\n"
15847  ""},
15848  { (char *)"plflush", _wrap_plflush, METH_VARARGS, (char *)"\n"
15849  "Flushes the output stream \n"
15850  "\n"
15851  "DESCRIPTION:\n"
15852  "\n"
15853  " Flushes the output stream. Use sparingly, if at all. \n"
15854  "\n"
15855  " Redacted form: plflush()\n"
15856  "\n"
15857  " This function is used in examples 1,14. \n"
15858  "\n"
15859  "\n"
15860  "\n"
15861  "SYNOPSIS:\n"
15862  "\n"
15863  "plflush()\n"
15864  "\n"
15865  ""},
15866  { (char *)"plfont", _wrap_plfont, METH_VARARGS, (char *)"\n"
15867  "Set character font \n"
15868  "\n"
15869  "DESCRIPTION:\n"
15870  "\n"
15871  " Sets the default character font for subsequent character drawing. Also\n"
15872  " affects symbols produced by plpoin. This routine has no effect unless\n"
15873  " the extended character set is loaded (see plfontld). \n"
15874  "\n"
15875  " Redacted form: plfont(font)\n"
15876  "\n"
15877  " This function is used in examples 1,2,4,7,13,24,26. \n"
15878  "\n"
15879  "\n"
15880  "\n"
15881  "SYNOPSIS:\n"
15882  "\n"
15883  "plfont(font)\n"
15884  "\n"
15885  "ARGUMENTS:\n"
15886  "\n"
15887  " font (PLINT, input) : Specifies the font: 1: Normal font (simplest\n"
15888  " and fastest) \n"
15889  " 2: Roman font \n"
15890  " 3: Italic font \n"
15891  " 4: Script font \n"
15892  "\n"
15893  ""},
15894  { (char *)"plfontld", _wrap_plfontld, METH_VARARGS, (char *)"\n"
15895  "Load character font \n"
15896  "\n"
15897  "DESCRIPTION:\n"
15898  "\n"
15899  " Sets the character set to use for subsequent character drawing. May\n"
15900  " be called before initializing PLplot. \n"
15901  "\n"
15902  " Redacted form: plfontld(set)\n"
15903  "\n"
15904  " This function is used in examples 1,7. \n"
15905  "\n"
15906  "\n"
15907  "\n"
15908  "SYNOPSIS:\n"
15909  "\n"
15910  "plfontld(set)\n"
15911  "\n"
15912  "ARGUMENTS:\n"
15913  "\n"
15914  " set (PLINT, input) : Specifies the character set to load: 0:\n"
15915  " Standard character set \n"
15916  " 1: Extended character set \n"
15917  "\n"
15918  ""},
15919  { (char *)"plgchr", _wrap_plgchr, METH_VARARGS, (char *)"\n"
15920  "Get character default height and current (scaled) height \n"
15921  "\n"
15922  "DESCRIPTION:\n"
15923  "\n"
15924  " Get character default height and current (scaled) height. \n"
15925  "\n"
15926  " Redacted form: plgchr(p_def, p_ht)\n"
15927  "\n"
15928  " This function is used in example 23. \n"
15929  "\n"
15930  "\n"
15931  "\n"
15932  "SYNOPSIS:\n"
15933  "\n"
15934  "plgchr(p_def, p_ht)\n"
15935  "\n"
15936  "ARGUMENTS:\n"
15937  "\n"
15938  " p_def (PLFLT *, output) : Pointer to default character height (mm). \n"
15939  "\n"
15940  " p_ht (PLFLT *, output) : Pointer to current (scaled) character\n"
15941  " height (mm). \n"
15942  "\n"
15943  ""},
15944  { (char *)"plgcol0", _wrap_plgcol0, METH_VARARGS, (char *)"\n"
15945  "Returns 8-bit RGB values for given color from color map0 \n"
15946  "\n"
15947  "DESCRIPTION:\n"
15948  "\n"
15949  " Returns 8-bit RGB values (0-255) for given color from color map0 (see\n"
15950  " the PLplot documentation). Values are negative if an invalid color id\n"
15951  " is given. \n"
15952  "\n"
15953  " Redacted form: plgcol0(icol0, r, g, b)\n"
15954  "\n"
15955  " This function is used in example 2. \n"
15956  "\n"
15957  "\n"
15958  "\n"
15959  "SYNOPSIS:\n"
15960  "\n"
15961  "plgcol0(icol0, r, g, b)\n"
15962  "\n"
15963  "ARGUMENTS:\n"
15964  "\n"
15965  " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
15966  "\n"
15967  " r (PLINT *, output) : Pointer to 8-bit red value. \n"
15968  "\n"
15969  " g (PLINT *, output) : Pointer to 8-bit green value. \n"
15970  "\n"
15971  " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
15972  "\n"
15973  ""},
15974  { (char *)"plgcol0a", _wrap_plgcol0a, METH_VARARGS, (char *)"\n"
15975  "Returns 8-bit RGB values and double alpha value for given color from color map0. \n"
15976  "\n"
15977  "DESCRIPTION:\n"
15978  "\n"
15979  " Returns 8-bit RGB values (0-255) and double alpha value (0.0 - 1.0)\n"
15980  " for given color from color map0 (see the PLplot documentation). \n"
15981  " Values are negative if an invalid color id is given. \n"
15982  "\n"
15983  " This function is used in example 30. \n"
15984  "\n"
15985  "\n"
15986  "\n"
15987  "SYNOPSIS:\n"
15988  "\n"
15989  "plgcol0a(icol0, r, g, b, a)\n"
15990  "\n"
15991  "ARGUMENTS:\n"
15992  "\n"
15993  " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
15994  "\n"
15995  " r (PLINT *, output) : Pointer to 8-bit red value. \n"
15996  "\n"
15997  " g (PLINT *, output) : Pointer to 8-bit green value. \n"
15998  "\n"
15999  " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
16000  "\n"
16001  " a (PLFLT *, output) : Pointer to PLFLT alpha value. \n"
16002  "\n"
16003  ""},
16004  { (char *)"plgcolbg", _wrap_plgcolbg, METH_VARARGS, (char *)"\n"
16005  "Returns the background color (cmap0[0]) by 8-bit RGB value \n"
16006  "\n"
16007  "ESCRIPTION:\n"
16008  "\n"
16009  " Returns the background color (cmap0[0]) by 8-bit RGB value. \n"
16010  "\n"
16011  " Redacted form: plgcolbg(r, g, b)\n"
16012  "\n"
16013  " This function is used in example 31. \n"
16014  "\n"
16015  "\n"
16016  "\n"
16017  "YNOPSIS:\n"
16018  "\n"
16019  "lgcolbg(r, g, b)\n"
16020  "\n"
16021  "RGUMENTS:\n"
16022  "\n"
16023  " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16024  " representing the degree of red in the color. \n"
16025  "\n"
16026  " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16027  " representing the degree of green in the color. \n"
16028  "\n"
16029  " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16030  " representing the degree of blue in the color. \n"
16031  "\n"
16032  ""},
16033  { (char *)"plgcolbga", _wrap_plgcolbga, METH_VARARGS, (char *)"\n"
16034  "Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha value. \n"
16035  "\n"
16036  "ESCRIPTION:\n"
16037  "\n"
16038  " Returns the background color (cmap0[0]) by 8-bit RGB value and double\n"
16039  " alpha value. \n"
16040  "\n"
16041  " This function is used in example 31. \n"
16042  "\n"
16043  "\n"
16044  "\n"
16045  "YNOPSIS:\n"
16046  "\n"
16047  "lgcolbga(r, g, b, a)\n"
16048  "\n"
16049  "RGUMENTS:\n"
16050  "\n"
16051  " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16052  " representing the degree of red in the color. \n"
16053  "\n"
16054  " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16055  " representing the degree of green in the color. \n"
16056  "\n"
16057  " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16058  " representing the degree of blue in the color. \n"
16059  "\n"
16060  " a (PLFLT *, output) : Pointer to PLFLT alpha value. \n"
16061  "\n"
16062  ""},
16063  { (char *)"plgcompression", _wrap_plgcompression, METH_VARARGS, (char *)"\n"
16064  "Get the current device-compression setting \n"
16065  "\n"
16066  "DESCRIPTION:\n"
16067  "\n"
16068  " Get the current device-compression setting. This parameter is only\n"
16069  " used for drivers that provide compression. \n"
16070  "\n"
16071  " Redacted form: plgcompression(compression)\n"
16072  "\n"
16073  " This function is used in example 31. \n"
16074  "\n"
16075  "\n"
16076  "\n"
16077  "SYNOPSIS:\n"
16078  "\n"
16079  "plgcompression(compression)\n"
16080  "\n"
16081  "ARGUMENTS:\n"
16082  "\n"
16083  " compression (PLINT *, output) : Pointer to a variable to be filled\n"
16084  " with the current device-compression setting. \n"
16085  "\n"
16086  ""},
16087  { (char *)"plgdev", _wrap_plgdev, METH_VARARGS, (char *)"\n"
16088  "Get the current device (keyword) name \n"
16089  "\n"
16090  "DESCRIPTION:\n"
16091  "\n"
16092  " Get the current device (keyword) name. Note: you must have allocated\n"
16093  " space for this (80 characters is safe). \n"
16094  "\n"
16095  " Redacted form: plgdev(p_dev)\n"
16096  "\n"
16097  " This function is used in example 14. \n"
16098  "\n"
16099  "\n"
16100  "\n"
16101  "SYNOPSIS:\n"
16102  "\n"
16103  "plgdev(p_dev)\n"
16104  "\n"
16105  "ARGUMENTS:\n"
16106  "\n"
16107  " p_dev (char *, output) : Pointer to device (keyword) name string. \n"
16108  "\n"
16109  ""},
16110  { (char *)"plgdidev", _wrap_plgdidev, METH_VARARGS, (char *)"\n"
16111  "Get parameters that define current device-space window \n"
16112  "\n"
16113  "DESCRIPTION:\n"
16114  "\n"
16115  " Get relative margin width, aspect ratio, and relative justification\n"
16116  " that define current device-space window. If plsdidev has not been\n"
16117  " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
16118  " p_jy will all be 0. \n"
16119  "\n"
16120  " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16121  "\n"
16122  " This function is used in example 31. \n"
16123  "\n"
16124  "\n"
16125  "\n"
16126  "SYNOPSIS:\n"
16127  "\n"
16128  "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16129  "\n"
16130  "ARGUMENTS:\n"
16131  "\n"
16132  " p_mar (PLFLT *, output) : Pointer to relative margin width. \n"
16133  "\n"
16134  " p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n"
16135  "\n"
16136  " p_jx (PLFLT *, output) : Pointer to relative justification in x. \n"
16137  "\n"
16138  " p_jy (PLFLT *, output) : Pointer to relative justification in y. \n"
16139  "\n"
16140  ""},
16141  { (char *)"plgdiori", _wrap_plgdiori, METH_VARARGS, (char *)"\n"
16142  "Get plot orientation \n"
16143  "\n"
16144  "DESCRIPTION:\n"
16145  "\n"
16146  " Get plot orientation parameter which is multiplied by 90 degrees to\n"
16147  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
16148  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
16149  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
16150  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
16151  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
16152  " not been called the default value pointed to by p_rot will be 0. \n"
16153  "\n"
16154  " Redacted form: plgdiori(p_rot)\n"
16155  "\n"
16156  " This function is not used in any examples. \n"
16157  "\n"
16158  "\n"
16159  "\n"
16160  "SYNOPSIS:\n"
16161  "\n"
16162  "plgdiori(p_rot)\n"
16163  "\n"
16164  "ARGUMENTS:\n"
16165  "\n"
16166  " p_rot (PLFLT *, output) : Pointer to orientation parameter. \n"
16167  "\n"
16168  ""},
16169  { (char *)"plgdiplt", _wrap_plgdiplt, METH_VARARGS, (char *)"\n"
16170  "Get parameters that define current plot-space window \n"
16171  "\n"
16172  "DESCRIPTION:\n"
16173  "\n"
16174  " Get relative minima and maxima that define current plot-space window.\n"
16175  " If plsdiplt has not been called the default values pointed to by\n"
16176  " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n"
16177  "\n"
16178  " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16179  "\n"
16180  " This function is used in example 31. \n"
16181  "\n"
16182  "\n"
16183  "\n"
16184  "SYNOPSIS:\n"
16185  "\n"
16186  "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16187  "\n"
16188  "ARGUMENTS:\n"
16189  "\n"
16190  " p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n"
16191  "\n"
16192  " p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n"
16193  "\n"
16194  " p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n"
16195  "\n"
16196  " p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n"
16197  "\n"
16198  ""},
16199  { (char *)"plgfam", _wrap_plgfam, METH_VARARGS, (char *)"\n"
16200  "Get family file parameters \n"
16201  "\n"
16202  "DESCRIPTION:\n"
16203  "\n"
16204  " Gets information about current family file, if familying is enabled. \n"
16205  " See the PLplot documentation for more information. \n"
16206  "\n"
16207  " Redacted form: plgfam(fam, num, bmax)\n"
16208  "\n"
16209  " This function is used in examples 14,31. \n"
16210  "\n"
16211  "\n"
16212  "\n"
16213  "SYNOPSIS:\n"
16214  "\n"
16215  "plgfam(fam, num, bmax)\n"
16216  "\n"
16217  "ARGUMENTS:\n"
16218  "\n"
16219  " fam (PLINT *, output) : Pointer to variable with the Boolean family\n"
16220  " flag value. If nonzero, familying is enabled. \n"
16221  "\n"
16222  " num (PLINT *, output) : Pointer to variable with the current family\n"
16223  " file number. \n"
16224  "\n"
16225  " bmax (PLINT *, output) : Pointer to variable with the maximum file\n"
16226  " size (in bytes) for a family file. \n"
16227  "\n"
16228  ""},
16229  { (char *)"plgfci", _wrap_plgfci, METH_VARARGS, (char *)"\n"
16230  "Get FCI (font characterization integer) \n"
16231  "\n"
16232  "DESCRIPTION:\n"
16233  "\n"
16234  " Gets information about the current font using the FCI approach. See\n"
16235  " the PLplot documentation for more information. \n"
16236  "\n"
16237  " Redacted form: plgfci(fci)\n"
16238  "\n"
16239  " This function is used in example 23. \n"
16240  "\n"
16241  "\n"
16242  "\n"
16243  "SYNOPSIS:\n"
16244  "\n"
16245  "plgfci(fci)\n"
16246  "\n"
16247  "ARGUMENTS:\n"
16248  "\n"
16249  " fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n"
16250  " integer) variable which is updated with current FCI value. \n"
16251  "\n"
16252  ""},
16253  { (char *)"plgfnam", _wrap_plgfnam, METH_VARARGS, (char *)"\n"
16254  "Get output file name \n"
16255  "\n"
16256  "DESCRIPTION:\n"
16257  "\n"
16258  " Gets the current output file name, if applicable. \n"
16259  "\n"
16260  " Redacted form: plgfnam(fnam)\n"
16261  "\n"
16262  " This function is used in example 31. \n"
16263  "\n"
16264  "\n"
16265  "\n"
16266  "SYNOPSIS:\n"
16267  "\n"
16268  "plgfnam(fnam)\n"
16269  "\n"
16270  "ARGUMENTS:\n"
16271  "\n"
16272  " fnam (char *, output) : Pointer to file name string (a preallocated\n"
16273  " string of 80 characters or more). \n"
16274  "\n"
16275  ""},
16276  { (char *)"plgfont", _wrap_plgfont, METH_VARARGS, (char *)"\n"
16277  "Get family, style and weight of the current font \n"
16278  "\n"
16279  "DESCRIPTION:\n"
16280  "\n"
16281  " Gets information about current font. See the PLplot documentation for\n"
16282  " more information on font selection. \n"
16283  "\n"
16284  " Redacted form: plgfont(p_family, p_style, p_weight)\n"
16285  "\n"
16286  " This function is used in example 23. \n"
16287  "\n"
16288  "\n"
16289  "\n"
16290  "SYNOPSIS:\n"
16291  "\n"
16292  "plgfont(p_family, p_style, p_weight)\n"
16293  "\n"
16294  "ARGUMENTS:\n"
16295  "\n"
16296  " p_family (PLINT *, output) : Pointer to variable with the current\n"
16297  " font family. The available values are given by the PL_FCI_*\n"
16298  " constants in plplot.h. Current options are PL_FCI_SANS,\n"
16299  " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
16300  " p_family is NULL then the font family is not returned. \n"
16301  "\n"
16302  " p_style (PLINT *, output) : Pointer to variable with the current\n"
16303  " font style. The available values are given by the PL_FCI_*\n"
16304  " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
16305  " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n"
16306  " font style is not returned. \n"
16307  "\n"
16308  " p_weight (PLINT *, output) : Pointer to variable with the current\n"
16309  " font weight. The available values are given by the PL_FCI_*\n"
16310  " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
16311  " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
16312  " returned. \n"
16313  "\n"
16314  ""},
16315  { (char *)"plglevel", _wrap_plglevel, METH_VARARGS, (char *)"\n"
16316  "Get the (current) run level \n"
16317  "\n"
16318  "DESCRIPTION:\n"
16319  "\n"
16320  " Get the (current) run level. Valid settings are: 0, uninitialized \n"
16321  " 1, initialized \n"
16322  " 2, viewport defined \n"
16323  " 3, world coordinates defined \n"
16324  "\n"
16325  "\n"
16326  " Redacted form: plglevel(p_level)\n"
16327  "\n"
16328  " This function is used in example 31. \n"
16329  "\n"
16330  "\n"
16331  "\n"
16332  "SYNOPSIS:\n"
16333  "\n"
16334  "plglevel(p_level)\n"
16335  "\n"
16336  "ARGUMENTS:\n"
16337  "\n"
16338  " p_level (PLINT *, output) : Pointer to the run level. \n"
16339  "\n"
16340  ""},
16341  { (char *)"plgpage", _wrap_plgpage, METH_VARARGS, (char *)"\n"
16342  "Get page parameters \n"
16343  "\n"
16344  "DESCRIPTION:\n"
16345  "\n"
16346  " Gets the current page configuration. The length and offset values are\n"
16347  " expressed in units that are specific to the current driver. For\n"
16348  " instance: screen drivers will usually interpret them as number of\n"
16349  " pixels, whereas printer drivers will usually use mm. \n"
16350  "\n"
16351  " Redacted form: plgpage(xp, yp, xleng, yleng, xoff, yoff)\n"
16352  "\n"
16353  " This function is used in examples 14 and 31. \n"
16354  "\n"
16355  "\n"
16356  "\n"
16357  "SYNOPSIS:\n"
16358  "\n"
16359  "plgpage(xp, yp, xleng, yleng, xoff, yoff)\n"
16360  "\n"
16361  "ARGUMENTS:\n"
16362  "\n"
16363  " xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n"
16364  "\n"
16365  " yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in y. \n"
16366  "\n"
16367  " xleng (PLINT *, output) : Pointer to x page length value. \n"
16368  "\n"
16369  " yleng (PLINT *, output) : Pointer to y page length value. \n"
16370  "\n"
16371  " xoff (PLINT *, output) : Pointer to x page offset. \n"
16372  "\n"
16373  " yoff (PLINT *, output) : Pointer to y page offset. \n"
16374  "\n"
16375  ""},
16376  { (char *)"plgra", _wrap_plgra, METH_VARARGS, (char *)"\n"
16377  "Switch to graphics screen \n"
16378  "\n"
16379  "DESCRIPTION:\n"
16380  "\n"
16381  " Sets an interactive device to graphics mode, used in conjunction with\n"
16382  " pltext to allow graphics and text to be interspersed. On a device\n"
16383  " which supports separate text and graphics windows, this command causes\n"
16384  " control to be switched to the graphics window. If already in graphics\n"
16385  " mode, this command is ignored. It is also ignored on devices which\n"
16386  " only support a single window or use a different method for shifting\n"
16387  " focus. See also pltext. \n"
16388  "\n"
16389  " Redacted form: plgra()\n"
16390  "\n"
16391  " This function is used in example 1. \n"
16392  "\n"
16393  "\n"
16394  "\n"
16395  "SYNOPSIS:\n"
16396  "\n"
16397  "plgra()\n"
16398  "\n"
16399  ""},
16400  { (char *)"plgriddata", _wrap_plgriddata, METH_VARARGS, (char *)"\n"
16401  "Grid data from irregularly sampled data \n"
16402  "\n"
16403  "DESCRIPTION:\n"
16404  "\n"
16405  " Real world data is frequently irregularly sampled, but all PLplot 3D\n"
16406  " plots require data placed in a uniform grid. This function takes\n"
16407  " irregularly sampled data from three input arrays x[npts], y[npts], and\n"
16408  " z[npts], reads the desired grid location from input arrays xg[nptsx]\n"
16409  " and yg[nptsy], and returns the gridded data into output array\n"
16410  " zg[nptsx][nptsy]. The algorithm used to grid the data is specified\n"
16411  " with the argument type which can have one parameter specified in\n"
16412  " argument data. \n"
16413  "\n"
16414  " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
16415  " Perl/PDL: Not available? \n"
16416  " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
16417  "\n"
16418  "\n"
16419  " This function is used in example 21. \n"
16420  "\n"
16421  "\n"
16422  "\n"
16423  "SYNOPSIS:\n"
16424  "\n"
16425  "plggriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
16426  "\n"
16427  "ARGUMENTS:\n"
16428  "\n"
16429  " x (PLFLT *, input) : The input x array. \n"
16430  "\n"
16431  " y (PLFLT *, input) : The input y array. \n"
16432  "\n"
16433  " z (PLFLT *, input) : The input z array. Each triple x[i], y[i],\n"
16434  " z[i] represents one data sample coordinate. \n"
16435  "\n"
16436  " npts (PLINT, input) : The number of data samples in the x, y and z\n"
16437  " arrays. \n"
16438  "\n"
16439  " xg (PLFLT *, input) : The input array that specifies the grid\n"
16440  " spacing in the x direction. Usually xg has nptsx equally spaced\n"
16441  " values from the minimum to the maximum values of the x input\n"
16442  " array. \n"
16443  "\n"
16444  " nptsx (PLINT, input) : The number of points in the xg array. \n"
16445  "\n"
16446  " yg (PLFLT *, input) : The input array that specifies the grid\n"
16447  " spacing in the y direction. Similar to the xg parameter. \n"
16448  "\n"
16449  " nptsy (PLINT, input) : The number of points in the yg array. \n"
16450  "\n"
16451  " zg (PLFLT **, output) : The output array, where data lies in the\n"
16452  " regular grid specified by xg and yg. the zg array must exist or be\n"
16453  " allocated by the user prior to the call, and must have dimension\n"
16454  " zg[nptsx][nptsy]. \n"
16455  "\n"
16456  " type (PLINT, input) : The type of gridding algorithm to use, which\n"
16457  " can be: GRID_CSA: Bivariate Cubic Spline approximation \n"
16458  " GRID_DTLI: Delaunay Triangulation Linear Interpolation \n"
16459  " GRID_NNI: Natural Neighbors Interpolation \n"
16460  " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted \n"
16461  " GRID_NNLI: Nearest Neighbors Linear Interpolation \n"
16462  " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
16463  " Weighted \n"
16464  " For details of the algorithms read the source file plgridd.c. \n"
16465  "\n"
16466  " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
16467  " which can be specified through this argument. Currently, for\n"
16468  " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
16469  " use, the lower the value, the noisier (more local) the\n"
16470  " approximation is. \n"
16471  " GRID_NNLI, data specifies what a thin triangle is, in the\n"
16472  " range [1. .. 2.]. High values enable the usage of very thin\n"
16473  " triangles for interpolation, possibly resulting in error in\n"
16474  " the approximation. \n"
16475  " GRID_NNI, only weights greater than data will be accepted. If\n"
16476  " 0, all weights will be accepted. \n"
16477  "\n"
16478  ""},
16479  { (char *)"plgspa", _wrap_plgspa, METH_VARARGS, (char *)"\n"
16480  "Get current subpage parameters \n"
16481  "\n"
16482  "DESCRIPTION:\n"
16483  "\n"
16484  " Gets the size of the current subpage in millimeters measured from the\n"
16485  " bottom left hand corner of the output device page or screen. Can be\n"
16486  " used in conjunction with plsvpa for setting the size of a viewport in\n"
16487  " absolute coordinates (millimeters). \n"
16488  "\n"
16489  " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
16490  "\n"
16491  " This function is used in example 23. \n"
16492  "\n"
16493  "\n"
16494  "\n"
16495  "SYNOPSIS:\n"
16496  "\n"
16497  "plgspa(xmin, xmax, ymin, ymax)\n"
16498  "\n"
16499  "ARGUMENTS:\n"
16500  "\n"
16501  " xmin (PLFLT *, output) : Pointer to variable with position of left\n"
16502  " hand edge of subpage in millimeters. \n"
16503  "\n"
16504  " xmax (PLFLT *, output) : Pointer to variable with position of right\n"
16505  " hand edge of subpage in millimeters. \n"
16506  "\n"
16507  " ymin (PLFLT *, output) : Pointer to variable with position of\n"
16508  " bottom edge of subpage in millimeters. \n"
16509  "\n"
16510  " ymax (PLFLT *, output) : Pointer to variable with position of top\n"
16511  " edge of subpage in millimeters. \n"
16512  "\n"
16513  ""},
16514  { (char *)"plgstrm", _wrap_plgstrm, METH_VARARGS, (char *)"\n"
16515  "Get current stream number \n"
16516  "\n"
16517  "DESCRIPTION:\n"
16518  "\n"
16519  " Gets the number of the current output stream. See also plsstrm. \n"
16520  "\n"
16521  " Redacted form: plgstrm(strm)\n"
16522  "\n"
16523  " This function is used in example 1,20. \n"
16524  "\n"
16525  "\n"
16526  "\n"
16527  "SYNOPSIS:\n"
16528  "\n"
16529  "plgstrm(strm)\n"
16530  "\n"
16531  "ARGUMENTS:\n"
16532  "\n"
16533  " strm (PLINT *, output) : Pointer to current stream value. \n"
16534  "\n"
16535  ""},
16536  { (char *)"plgver", _wrap_plgver, METH_VARARGS, (char *)"\n"
16537  "Get the current library version number \n"
16538  "\n"
16539  "DESCRIPTION:\n"
16540  "\n"
16541  " Get the current library version number. Note: you must have allocated\n"
16542  " space for this (80 characters is safe). \n"
16543  "\n"
16544  " Redacted form: plgver(p_ver)\n"
16545  "\n"
16546  " This function is used in example 1. \n"
16547  "\n"
16548  "\n"
16549  "\n"
16550  "SYNOPSIS:\n"
16551  "\n"
16552  "plgver(p_ver)\n"
16553  "\n"
16554  "ARGUMENTS:\n"
16555  "\n"
16556  " p_ver (char *, output) : Pointer to the current library version\n"
16557  " number. \n"
16558  "\n"
16559  ""},
16560  { (char *)"plgvpd", _wrap_plgvpd, METH_VARARGS, (char *)"\n"
16561  "Get viewport limits in normalized device coordinates \n"
16562  "\n"
16563  "DESCRIPTION:\n"
16564  "\n"
16565  " Get viewport limits in normalized device coordinates. \n"
16566  "\n"
16567  " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16568  " Perl/PDL: Not available? \n"
16569  "\n"
16570  "\n"
16571  " This function is used in example 31. \n"
16572  "\n"
16573  "\n"
16574  "\n"
16575  "SYNOPSIS:\n"
16576  "\n"
16577  "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16578  "\n"
16579  "ARGUMENTS:\n"
16580  "\n"
16581  " p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n"
16582  " device coordinate in x. \n"
16583  "\n"
16584  " p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n"
16585  " device coordinate in x. \n"
16586  "\n"
16587  " p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n"
16588  " device coordinate in y. \n"
16589  "\n"
16590  " p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n"
16591  " device coordinate in y. \n"
16592  "\n"
16593  ""},
16594  { (char *)"plgvpw", _wrap_plgvpw, METH_VARARGS, (char *)"\n"
16595  "Get viewport limits in world coordinates \n"
16596  "\n"
16597  "DESCRIPTION:\n"
16598  "\n"
16599  " Get viewport limits in world coordinates. \n"
16600  "\n"
16601  " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16602  " Perl/PDL: Not available? \n"
16603  "\n"
16604  "\n"
16605  " This function is used in example 31. \n"
16606  "\n"
16607  "\n"
16608  "\n"
16609  "SYNOPSIS:\n"
16610  "\n"
16611  "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16612  "\n"
16613  "ARGUMENTS:\n"
16614  "\n"
16615  " p_xmin (PLFLT *, output) : Lower viewport limit of the world\n"
16616  " coordinate in x. \n"
16617  "\n"
16618  " p_xmax (PLFLT *, output) : Upper viewport limit of the world\n"
16619  " coordinate in x. \n"
16620  "\n"
16621  " p_ymin (PLFLT *, output) : Lower viewport limit of the world\n"
16622  " coordinate in y. \n"
16623  "\n"
16624  " p_ymax (PLFLT *, output) : Upper viewport limit of the world\n"
16625  " coordinate in y. \n"
16626  "\n"
16627  ""},
16628  { (char *)"plgxax", _wrap_plgxax, METH_VARARGS, (char *)"\n"
16629  "Get x axis parameters \n"
16630  "\n"
16631  "DESCRIPTION:\n"
16632  "\n"
16633  " Returns current values of the digmax and digits flags for the x axis. \n"
16634  " digits is updated after the plot is drawn, so this routine should only\n"
16635  " be called after the call to plbox (or plbox3) is complete. See the\n"
16636  " PLplot documentation for more information. \n"
16637  "\n"
16638  " Redacted form: plgxax(digmax, digits)\n"
16639  "\n"
16640  " This function is used in example 31. \n"
16641  "\n"
16642  "\n"
16643  "\n"
16644  "SYNOPSIS:\n"
16645  "\n"
16646  "plgxax(digmax, digits)\n"
16647  "\n"
16648  "ARGUMENTS:\n"
16649  "\n"
16650  " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16651  " number of digits for the x axis. If nonzero, the printed label\n"
16652  " has been switched to a floating point representation when the\n"
16653  " number of digits exceeds digmax. \n"
16654  "\n"
16655  " digits (PLINT *, output) : Pointer to variable with the actual\n"
16656  " number of digits for the numeric labels (x axis) from the last\n"
16657  " plot. \n"
16658  "\n"
16659  ""},
16660  { (char *)"plgyax", _wrap_plgyax, METH_VARARGS, (char *)"\n"
16661  "Get y axis parameters \n"
16662  "\n"
16663  "DESCRIPTION:\n"
16664  "\n"
16665  " Identical to plgxax, except that arguments are flags for y axis. See\n"
16666  " the description of plgxax for more detail. \n"
16667  "\n"
16668  " Redacted form: plgyax(digmax, digits)\n"
16669  "\n"
16670  " This function is used in example 31. \n"
16671  "\n"
16672  "\n"
16673  "\n"
16674  "SYNOPSIS:\n"
16675  "\n"
16676  "plgyax(digmax, digits)\n"
16677  "\n"
16678  "ARGUMENTS:\n"
16679  "\n"
16680  " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16681  " number of digits for the y axis. If nonzero, the printed label\n"
16682  " has been switched to a floating point representation when the\n"
16683  " number of digits exceeds digmax. \n"
16684  "\n"
16685  " digits (PLINT *, output) : Pointer to variable with the actual\n"
16686  " number of digits for the numeric labels (y axis) from the last\n"
16687  " plot. \n"
16688  "\n"
16689  ""},
16690  { (char *)"plgzax", _wrap_plgzax, METH_VARARGS, (char *)"\n"
16691  "Get z axis parameters \n"
16692  "\n"
16693  "DESCRIPTION:\n"
16694  "\n"
16695  " Identical to plgxax, except that arguments are flags for z axis. See\n"
16696  " the description of plgxax for more detail. \n"
16697  "\n"
16698  " Redacted form: plgzax(digmax, digits)\n"
16699  "\n"
16700  " This function is used in example 31. \n"
16701  "\n"
16702  "\n"
16703  "\n"
16704  "SYNOPSIS:\n"
16705  "\n"
16706  "plgzax(digmax, digits)\n"
16707  "\n"
16708  "ARGUMENTS:\n"
16709  "\n"
16710  " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16711  " number of digits for the z axis. If nonzero, the printed label\n"
16712  " has been switched to a floating point representation when the\n"
16713  " number of digits exceeds digmax. \n"
16714  "\n"
16715  " digits (PLINT *, output) : Pointer to variable with the actual\n"
16716  " number of digits for the numeric labels (z axis) from the last\n"
16717  " plot. \n"
16718  "\n"
16719  ""},
16720  { (char *)"plhist", _wrap_plhist, METH_VARARGS, (char *)"\n"
16721  "Plot a histogram from unbinned data \n"
16722  "\n"
16723  "DESCRIPTION:\n"
16724  "\n"
16725  " Plots a histogram from n data points stored in the array data. This\n"
16726  " routine bins the data into nbin bins equally spaced between datmin and\n"
16727  " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
16728  " opt allows, among other things, the histogram either to be plotted in\n"
16729  " an existing window or causes plhist to call plenv with suitable limits\n"
16730  " before plotting the histogram. \n"
16731  "\n"
16732  " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
16733  "\n"
16734  " This function is used in example 5. \n"
16735  "\n"
16736  "\n"
16737  "\n"
16738  "SYNOPSIS:\n"
16739  "\n"
16740  "plhist(n, data, datmin, datmax, nbin, opt)\n"
16741  "\n"
16742  "ARGUMENTS:\n"
16743  "\n"
16744  " n (PLINT, input) : Number of data points. \n"
16745  "\n"
16746  " data (PLFLT *, input) : Pointer to array with values of the n data\n"
16747  " points. \n"
16748  "\n"
16749  " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n"
16750  "\n"
16751  " datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n"
16752  "\n"
16753  " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
16754  " divide the interval xmin to xmax. \n"
16755  "\n"
16756  " opt (PLINT, input) : Is a combination of several flags:\n"
16757  " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
16758  " the histogram data, the outer bins are expanded to fill up the\n"
16759  " entire x-axis, data outside the given extremes are assigned to the\n"
16760  " outer bins and bins of zero height are simply drawn. \n"
16761  " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
16762  " to fit the histogram data, without this flag, plenv is called\n"
16763  " to set the world coordinates. \n"
16764  " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
16765  " extremes are not taken into account. This option should\n"
16766  " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
16767  " properly present the data. \n"
16768  " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
16769  " size as the ones inside. \n"
16770  " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
16771  " (there is a gap for such bins). \n"
16772  "\n"
16773  ""},
16774  { (char *)"plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, (char *)"\n"
16775  "Convert HLS color to RGB \n"
16776  "\n"
16777  "DESCRIPTION:\n"
16778  "\n"
16779  " Convert HLS color coordinates to RGB. \n"
16780  "\n"
16781  " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16782  " Perl/PDL: Not available? Implemented as plhls? \n"
16783  "\n"
16784  "\n"
16785  " This function is used in example 2. \n"
16786  "\n"
16787  "\n"
16788  "\n"
16789  "SYNOPSIS:\n"
16790  "\n"
16791  "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16792  "\n"
16793  "ARGUMENTS:\n"
16794  "\n"
16795  " h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n"
16796  "\n"
16797  " l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n"
16798  " of the colour cone (0.0-1.0) \n"
16799  "\n"
16800  " s (PLFLT, input) : Saturation, expressed as a fraction of the\n"
16801  " radius of the colour cone (0.0-1.0) \n"
16802  "\n"
16803  " p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n"
16804  " colour \n"
16805  "\n"
16806  " p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n"
16807  " colour \n"
16808  "\n"
16809  " p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n"
16810  " colour \n"
16811  "\n"
16812  ""},
16813  { (char *)"plinit", _wrap_plinit, METH_VARARGS, (char *)"\n"
16814  "Initialize PLplot \n"
16815  "\n"
16816  "DESCRIPTION:\n"
16817  "\n"
16818  " Initializing the plotting package. The program prompts for the device\n"
16819  " keyword or number of the desired output device. Hitting a RETURN in\n"
16820  " response to the prompt is the same as selecting the first device. \n"
16821  " plinit will issue no prompt if either the device was specified\n"
16822  " previously (via command line flag, the plsetopt function, or the\n"
16823  " plsdev function), or if only one device is enabled when PLplot is\n"
16824  " installed. If subpages have been specified, the output device is\n"
16825  " divided into nx by ny subpages, each of which may be used\n"
16826  " independently. If plinit is called again during a program, the\n"
16827  " previously opened file will be closed. The subroutine pladv is used\n"
16828  " to advance from one subpage to the next. \n"
16829  "\n"
16830  " Redacted form: plinit()\n"
16831  "\n"
16832  " This function is used in all of the examples. \n"
16833  "\n"
16834  "\n"
16835  "\n"
16836  "SYNOPSIS:\n"
16837  "\n"
16838  "plinit()\n"
16839  "\n"
16840  ""},
16841  { (char *)"pljoin", _wrap_pljoin, METH_VARARGS, (char *)"\n"
16842  "Draw a line between two points \n"
16843  "\n"
16844  "DESCRIPTION:\n"
16845  "\n"
16846  " Joins the point (\n"
16847  " x1, \n"
16848  " y1) to (\n"
16849  " x2, \n"
16850  " y2). \n"
16851  "\n"
16852  " Redacted form: pljoin(x1,y1,x2,y2)\n"
16853  "\n"
16854  " This function is used in examples 3,14. \n"
16855  "\n"
16856  "\n"
16857  "\n"
16858  "SYNOPSIS:\n"
16859  "\n"
16860  "pljoin(x1, y1, x2, y2)\n"
16861  "\n"
16862  "ARGUMENTS:\n"
16863  "\n"
16864  " x1 (PLFLT, input) : x coordinate of first point. \n"
16865  "\n"
16866  " y1 (PLFLT, input) : y coordinate of first point. \n"
16867  "\n"
16868  " x2 (PLFLT, input) : x coordinate of second point. \n"
16869  "\n"
16870  " y2 (PLFLT, input) : y coordinate of second point. \n"
16871  "\n"
16872  ""},
16873  { (char *)"pllab", _wrap_pllab, METH_VARARGS, (char *)"\n"
16874  "Simple routine to write labels \n"
16875  "\n"
16876  "DESCRIPTION:\n"
16877  "\n"
16878  " Routine for writing simple labels. Use plmtex for more complex labels. \n"
16879  "\n"
16880  " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
16881  "\n"
16882  " This function is used in examples 1,5,9,12,14-16,20-22,29. \n"
16883  "\n"
16884  "\n"
16885  "\n"
16886  "SYNOPSIS:\n"
16887  "\n"
16888  "pllab(xlabel, ylabel, tlabel)\n"
16889  "\n"
16890  "ARGUMENTS:\n"
16891  "\n"
16892  " xlabel (const char *, input) : Label for horizontal axis. \n"
16893  "\n"
16894  " ylabel (const char *, input) : Label for vertical axis. \n"
16895  "\n"
16896  " tlabel (const char *, input) : Title of graph. \n"
16897  "\n"
16898  ""},
16899  { (char *)"pllegend", _wrap_pllegend, METH_VARARGS, (char *)"\n"
16900  "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n"
16901  "\n"
16902  "DESCRIPTION:\n"
16903  "\n"
16904  " Routine for creating a discrete plot legend with a plotted filled box,\n"
16905  " line, and/or line of symbols for each annotated legend entry. The\n"
16906  " arguments of pllegend provide control over the location and size of\n"
16907  " the legend as well as the location and characteristics of the elements\n"
16908  " (most of which are optional) within that legend. The resulting legend\n"
16909  " is clipped at the boundaries of the current subpage. (N.B. the adopted\n"
16910  " coordinate system used for some of the parameters is defined in the\n"
16911  " documentation of the position parameter.) \n"
16912  "\n"
16913  " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
16914  " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
16915  " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
16916  " test_justification, text_colors, text, box_colors, box_patterns,\n"
16917  " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
16918  " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
16919  "\n"
16920  " This function is used in examples 4 and 26. \n"
16921  "\n"
16922  "\n"
16923  "\n"
16924  "SYNOPSIS:\n"
16925  "\n"
16926  "pllegend(p_legend_width, p_legend_height, opt, position, x, y, plot_width, bg_color, bb_color, bb_style, nrow, ncolumn, nlegend, opt_array, text_offset, text_scale, text_spacing, test_justification, text_colors, text, box_colors, box_patterns, box_scales, box_line_widths, line_colors, line_styles, line_widths, symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
16927  "\n"
16928  "ARGUMENTS:\n"
16929  "\n"
16930  " p_legend_width (PLFLT *, output) : Pointer to a location which\n"
16931  " contains (after the call) the legend width in adopted coordinates.\n"
16932  " This quantity is calculated from plot_width, text_offset, ncolumn\n"
16933  " (possibly modified inside the routine depending on nlegend and\n"
16934  " nrow), and the length (calculated internally) of the longest text\n"
16935  " string. \n"
16936  "\n"
16937  " p_legend_height (PLFLT *, output) : Pointer to a location which\n"
16938  " contains (after the call) the legend height in adopted\n"
16939  " coordinates. This quantity is calculated from text_scale,\n"
16940  " text_spacing, and nrow (possibly modified inside the routine\n"
16941  " depending on nlegend and nrow). \n"
16942  "\n"
16943  " opt (PLINT, input) : opt contains bits controlling the overall\n"
16944  " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
16945  " on the left of the legend and the plotted area on the right.\n"
16946  " Otherwise, put the text area on the right of the legend and the\n"
16947  " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
16948  " plot a (semi-transparent) background for the legend. If the\n"
16949  " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
16950  " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
16951  " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
16952  " plot the resulting array of legend entries in row-major order.\n"
16953  " Otherwise, plot the legend entries in column-major order. \n"
16954  "\n"
16955  " position (PLINT, input) : position contains bits controlling the\n"
16956  " overall position of the legend and the definition of the adopted\n"
16957  " coordinates used for positions. The combination of the\n"
16958  " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP,\n"
16959  " PL_POSITION_BOTTOM, PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE\n"
16960  " bits specifies one of the 16 possible standard positions (the 4\n"
16961  " corners and 4 side centers for both the inside and outside cases)\n"
16962  " of the legend relative to the adopted coordinate system. The\n"
16963  " adopted coordinates are normalized viewport coordinates if the\n"
16964  " PL_POSITION_VIEWPORT bit is set or normalized subpage coordinates\n"
16965  " if the PL_POSITION_SUBPAGE bit is set. Default position bits: If\n"
16966  " none of PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, or\n"
16967  " PL_POSITION_BOTTOM are set, then use the combination of\n"
16968  " PL_POSITION_RIGHT and PL_POSITION_TOP. If neither of\n"
16969  " PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set, use\n"
16970  " PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
16971  " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n"
16972  "\n"
16973  " x (PLFLT, input) : X offset of the legend position in adopted\n"
16974  " coordinates from the specified standard position of the legend.\n"
16975  " For positive x, the direction of motion away from the standard\n"
16976  " position is inward/outward from the standard corner positions or\n"
16977  " standard left or right positions if the\n"
16978  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
16979  " For the standard top or bottom positions, the direction of motion\n"
16980  " is toward positive X. \n"
16981  "\n"
16982  " y (PLFLT, input) : Y offset of the legend position in adopted\n"
16983  " coordinates from the specified standard position of the legend.\n"
16984  " For positive y, the direction of motion away from the standard\n"
16985  " position is inward/outward from the standard corner positions or\n"
16986  " standard top or bottom positions if the\n"
16987  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
16988  " For the standard left or right positions, the direction of motion\n"
16989  " is toward positive Y. \n"
16990  "\n"
16991  " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
16992  " of the plot area (where the colored boxes, lines, and/or lines of\n"
16993  " symbols are drawn) of the legend. \n"
16994  "\n"
16995  " bg_color (PLINT, input) : The cmap0 index of the background color\n"
16996  " for the legend (PL_LEGEND_BACKGROUND). \n"
16997  "\n"
16998  " bb_color (PLINT, input) : The cmap0 index of the color of the\n"
16999  " bounding-box line for the legend (PL_LEGEND_BOUNDING_BOX). \n"
17000  "\n"
17001  " bb_style (PLINT, input) : The cmap0 index of the background color\n"
17002  " for the legend (PL_LEGEND_BACKGROUND). \n"
17003  "\n"
17004  " nrow (PLINT, input) : The cmap0 index of the background color for\n"
17005  " the legend (PL_LEGEND_BACKGROUND). \n"
17006  "\n"
17007  " ncolumn (PLINT, input) : The cmap0 index of the background color\n"
17008  " for the legend (PL_LEGEND_BACKGROUND). \n"
17009  "\n"
17010  " nlegend (PLINT, input) : Number of legend entries. N.B. The total\n"
17011  " vertical height of the legend in adopted coordinates is calculated\n"
17012  " internally from nlegend, text_scale (see below), and text_spacing\n"
17013  " (see below). \n"
17014  "\n"
17015  " opt_array (const PLINT *, input) : Array of nlegend values of\n"
17016  " options to control each individual plotted area corresponding to a\n"
17017  " legend entry. If the \n"
17018  " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
17019  " area. If the \n"
17020  " PL_LEGEND_COLOR_BOX, \n"
17021  " PL_LEGEND_LINE, and/or \n"
17022  " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
17023  " entry is plotted with a colored box; a line; and/or a line of\n"
17024  " symbols. \n"
17025  "\n"
17026  " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
17027  " area in units of character width. N.B. The total horizontal\n"
17028  " width of the legend in adopted coordinates is calculated\n"
17029  " internally from \n"
17030  " plot_width (see above), \n"
17031  " text_offset, and length (calculated internally) of the longest text\n"
17032  " string. \n"
17033  "\n"
17034  " text_scale (PLFLT, input) : Character height scale for text\n"
17035  " annotations. N.B. The total vertical height of the legend in\n"
17036  " adopted coordinates is calculated internally from \n"
17037  " nlegend (see above), \n"
17038  " text_scale, and \n"
17039  " text_spacing (see below). \n"
17040  "\n"
17041  " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
17042  " character height from one legend entry to the next. N.B. The\n"
17043  " total vertical height of the legend in adopted coordinates is\n"
17044  " calculated internally from \n"
17045  " nlegend (see above), \n"
17046  " text_scale (see above), and \n"
17047  " text_spacing. \n"
17048  "\n"
17049  " text_justification (PLFLT, input) : Justification parameter used\n"
17050  " for text justification. The most common values of\n"
17051  " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
17052  " is left justified, centred, or right justified within the text\n"
17053  " area, but other values are allowed as well. \n"
17054  "\n"
17055  " text_colors (const PLINT *, input) : Array of nlegend text colors\n"
17056  " (cmap0 indices). \n"
17057  "\n"
17058  " text (const char **, input) : Array of nlegend text string\n"
17059  " annotations. \n"
17060  "\n"
17061  " box_colors (const PLINT *, input) : Array of nlegend colors (cmap0\n"
17062  " indices) for the discrete colored boxes (\n"
17063  " PL_LEGEND_COLOR_BOX). \n"
17064  "\n"
17065  " box_patterns (const PLINT *, input) : Array of nlegend patterns\n"
17066  " (plpsty indices) for the discrete colored boxes (\n"
17067  " PL_LEGEND_COLOR_BOX). \n"
17068  "\n"
17069  " box_scales (const PLFLT *, input) : Array of nlegend scales (units\n"
17070  " of fraction of character height) for the height of the discrete\n"
17071  " colored boxes (\n"
17072  " PL_LEGEND_COLOR_BOX). \n"
17073  "\n"
17074  " box_line_widths (const PLFLT *, input) : Array of nlegend line\n"
17075  " widths for the patterns specified by box_patterns (\n"
17076  " PL_LEGEND_COLOR_BOX). \n"
17077  "\n"
17078  " line_colors (const PLINT *, input) : Array of nlegend line colors\n"
17079  " (cmap0 indices) (\n"
17080  " PL_LEGEND_LINE). \n"
17081  "\n"
17082  " line_styles (const PLINT *, input) : Array of nlegend line styles\n"
17083  " (plsty indices) (\n"
17084  " PL_LEGEND_LINE). \n"
17085  "\n"
17086  " line_widths (const PLFLT *, input) : Array of nlegend line widths (\n"
17087  " PL_LEGEND_LINE). \n"
17088  "\n"
17089  " symbol_colors (const PLINT *, input) : Array of nlegend symbol\n"
17090  " colors (cmap0 indices) (\n"
17091  " PL_LEGEND_SYMBOL). \n"
17092  "\n"
17093  " symbol_scales (const PLFLT *, input) : Array of nlegend scale\n"
17094  " values for the symbol height (\n"
17095  " PL_LEGEND_SYMBOL). \n"
17096  "\n"
17097  " symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n"
17098  " symbols to be drawn across the width of the plotted area (\n"
17099  " PL_LEGEND_SYMBOL). \n"
17100  "\n"
17101  " symbols (const char **, input) : Array of nlegend symbols (plpoin\n"
17102  " indices) (\n"
17103  " PL_LEGEND_SYMBOL). \n"
17104  "\n"
17105  ""},
17106  { (char *)"plcolorbar", _wrap_plcolorbar, METH_VARARGS, NULL},
17107  { (char *)"pllightsource", _wrap_pllightsource, METH_VARARGS, (char *)"\n"
17108  "Sets the 3D position of the light source \n"
17109  "\n"
17110  "DESCRIPTION:\n"
17111  "\n"
17112  " Sets the 3D position of the light source for use with plsurf3d. \n"
17113  "\n"
17114  " Redacted form: pllightsource(x, y, z)\n"
17115  "\n"
17116  " This function is used in example 8. \n"
17117  "\n"
17118  "\n"
17119  "\n"
17120  "SYNOPSIS:\n"
17121  "\n"
17122  "pllightsource(x, y, z)\n"
17123  "\n"
17124  "ARGUMENTS:\n"
17125  "\n"
17126  " x (PLFLT, input) : X-coordinate of the light source. \n"
17127  "\n"
17128  " y (PLFLT, input) : Y-coordinate of the light source. \n"
17129  "\n"
17130  " z (PLFLT, input) : Z-coordinate of the light source. \n"
17131  "\n"
17132  ""},
17133  { (char *)"plline", _wrap_plline, METH_VARARGS, (char *)"\n"
17134  "Draw a line \n"
17135  "\n"
17136  "DESCRIPTION:\n"
17137  "\n"
17138  " Draws line defined by n points in x and y. \n"
17139  "\n"
17140  " Redacted form: plline(x, y)\n"
17141  "\n"
17142  " This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n"
17143  "\n"
17144  "\n"
17145  "\n"
17146  "SYNOPSIS:\n"
17147  "\n"
17148  "plline(n, x, y)\n"
17149  "\n"
17150  "ARGUMENTS:\n"
17151  "\n"
17152  " n (PLINT, input) : Number of points defining line. \n"
17153  "\n"
17154  " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
17155  "\n"
17156  " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
17157  "\n"
17158  ""},
17159  { (char *)"plline3", _wrap_plline3, METH_VARARGS, (char *)"\n"
17160  "Draw a line in 3 space \n"
17161  "\n"
17162  "DESCRIPTION:\n"
17163  "\n"
17164  " Draws line in 3 space defined by n points in x, y, and z. You must\n"
17165  " first set up the viewport, the 2d viewing window (in world\n"
17166  " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
17167  " more info. \n"
17168  "\n"
17169  " Redacted form: plline3(x, y, z)\n"
17170  "\n"
17171  " This function is used in example 18. \n"
17172  "\n"
17173  "\n"
17174  "\n"
17175  "SYNOPSIS:\n"
17176  "\n"
17177  "plline3(n, x, y, z)\n"
17178  "\n"
17179  "ARGUMENTS:\n"
17180  "\n"
17181  " n (PLINT, input) : Number of points defining line. \n"
17182  "\n"
17183  " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
17184  "\n"
17185  " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
17186  "\n"
17187  " z (PLFLT *, input) : Pointer to array with z coordinates of points. \n"
17188  "\n"
17189  ""},
17190  { (char *)"pllsty", _wrap_pllsty, METH_VARARGS, (char *)"\n"
17191  "Select line style \n"
17192  "\n"
17193  "DESCRIPTION:\n"
17194  "\n"
17195  " This sets the line style according to one of eight predefined patterns\n"
17196  " (also see plstyl). \n"
17197  "\n"
17198  " Redacted form: pllsty(n)\n"
17199  "\n"
17200  " This function is used in examples 9,12,22,25. \n"
17201  "\n"
17202  "\n"
17203  "\n"
17204  "SYNOPSIS:\n"
17205  "\n"
17206  "pllsty(n)\n"
17207  "\n"
17208  "ARGUMENTS:\n"
17209  "\n"
17210  " n (PLINT, input) : Integer value between 1 and 8. Line style 1 is a\n"
17211  " continuous line, line style 2 is a line with short dashes and\n"
17212  " gaps, line style 3 is a line with long dashes and gaps, line style\n"
17213  " 4 has long dashes and short gaps and so on. \n"
17214  "\n"
17215  ""},
17216  { (char *)"plmesh", _wrap_plmesh, METH_VARARGS, (char *)"\n"
17217  "Plot surface mesh \n"
17218  "\n"
17219  "DESCRIPTION:\n"
17220  "\n"
17221  " Plots a surface mesh within the environment set up by plw3d. The\n"
17222  " surface is defined by the two-dimensional array z[\n"
17223  " nx][\n"
17224  " ny], the point z[i][j] being the value of the function at (\n"
17225  " x[i], \n"
17226  " y[j]). Note that the points in arrays x and y do not need to be\n"
17227  " equally spaced, but must be stored in ascending order. The parameter\n"
17228  " opt controls the way in which the surface is displayed. For further\n"
17229  " details see the PLplot documentation. \n"
17230  "\n"
17231  " Redacted form: plmesh(x, y, z, opt)\n"
17232  "\n"
17233  " This function is used in example 11. \n"
17234  "\n"
17235  "\n"
17236  "\n"
17237  "SYNOPSIS:\n"
17238  "\n"
17239  "plmesh(x, y, z, nx, ny, opt)\n"
17240  "\n"
17241  "ARGUMENTS:\n"
17242  "\n"
17243  " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17244  " the function is evaluated. \n"
17245  "\n"
17246  " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17247  " the function is evaluated. \n"
17248  "\n"
17249  " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17250  " with set of function values. \n"
17251  "\n"
17252  " nx (PLINT, input) : Number of x values at which function is\n"
17253  " evaluated. \n"
17254  "\n"
17255  " ny (PLINT, input) : Number of y values at which function is\n"
17256  " evaluated. \n"
17257  "\n"
17258  " opt (PLINT, input) : Determines the way in which the surface is\n"
17259  " represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
17260  " function of x for each value of y[j]. \n"
17261  " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17262  " for each value of x[i]. \n"
17263  " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17264  " at which function is defined. \n"
17265  "\n"
17266  ""},
17267  { (char *)"plmeshc", _wrap_plmeshc, METH_VARARGS, (char *)"\n"
17268  "Magnitude colored plot surface mesh with contour. \n"
17269  "\n"
17270  "DESCRIPTION:\n"
17271  "\n"
17272  " Identical to plmesh but with extra functionalities: the surface mesh\n"
17273  " can be colored accordingly to the current z value being plotted, a\n"
17274  " contour plot can be drawn at the base XY plane, and a curtain can be\n"
17275  " drawn between the plotted function border and the base XY plane. \n"
17276  "\n"
17277  " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
17278  "\n"
17279  " This function is used in example 11. \n"
17280  "\n"
17281  "\n"
17282  "\n"
17283  "SYNOPSIS:\n"
17284  "\n"
17285  "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17286  "\n"
17287  "ARGUMENTS:\n"
17288  "\n"
17289  " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17290  " the function is evaluated. \n"
17291  "\n"
17292  " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17293  " the function is evaluated. \n"
17294  "\n"
17295  " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17296  " with set of function values. \n"
17297  "\n"
17298  " nx (PLINT, input) : Number of x values at which function is\n"
17299  " evaluated. \n"
17300  "\n"
17301  " ny (PLINT, input) : Number of y values at which function is\n"
17302  " evaluated. \n"
17303  "\n"
17304  " opt (PLINT, input) : Determines the way in which the surface is\n"
17305  " represented. To specify more than one option just add the options,\n"
17306  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX: Lines are drawn\n"
17307  " showing z as a function of x for each value of y[j]. \n"
17308  " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17309  " for each value of x[i]. \n"
17310  " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17311  " at which function is defined. \n"
17312  " opt=MAG_COLOR: Each line in the mesh is colored according to\n"
17313  " the z value being plotted. The color is used from the current\n"
17314  " colormap 1. \n"
17315  " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
17316  " using parameters \n"
17317  " nlevel and \n"
17318  " clevel. \n"
17319  " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
17320  " the borders of the plotted function. \n"
17321  "\n"
17322  "\n"
17323  " clevel (PLFLT *, input) : Pointer to the array that defines the\n"
17324  " contour level spacing. \n"
17325  "\n"
17326  " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
17327  "\n"
17328  ""},
17329  { (char *)"plmkstrm", _wrap_plmkstrm, METH_VARARGS, (char *)"\n"
17330  "Creates a new stream and makes it the default \n"
17331  "\n"
17332  "DESCRIPTION:\n"
17333  "\n"
17334  " Creates a new stream and makes it the default. Differs from using\n"
17335  " plsstrm, in that a free stream number is found, and returned.\n"
17336  " Unfortunately, I have to start at stream 1 and work upward, since\n"
17337  " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
17338  " that no initial, library-opening call is required. So stream 0 must\n"
17339  " be preallocated, and there is no simple way of determining whether it\n"
17340  " is already in use or not. \n"
17341  "\n"
17342  " Redacted form: plmkstrm(p_strm)\n"
17343  "\n"
17344  " This function is used in examples 1,20. \n"
17345  "\n"
17346  "\n"
17347  "\n"
17348  "SYNOPSIS:\n"
17349  "\n"
17350  "plmkstrm(p_strm)\n"
17351  "\n"
17352  "ARGUMENTS:\n"
17353  "\n"
17354  " p_strm (PLINT *, output) : Pointer to stream number of the created\n"
17355  " stream. \n"
17356  "\n"
17357  ""},
17358  { (char *)"plmtex", _wrap_plmtex, METH_VARARGS, (char *)"\n"
17359  "Write text relative to viewport boundaries \n"
17360  "\n"
17361  "DESCRIPTION:\n"
17362  "\n"
17363  " Writes text at a specified position relative to the viewport\n"
17364  " boundaries. Text may be written inside or outside the viewport, but\n"
17365  " is clipped at the subpage boundaries. The reference point of a string\n"
17366  " lies along a line passing through the string at half the height of a\n"
17367  " capital letter. The position of the reference point along this line\n"
17368  " is determined by just, and the position of the reference point\n"
17369  " relative to the viewport is set by disp and pos. \n"
17370  "\n"
17371  " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
17372  " Perl/PDL: plmtex(disp, pos, just, side, text)\n"
17373  "\n"
17374  "\n"
17375  " This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n"
17376  "\n"
17377  "\n"
17378  "\n"
17379  "SYNOPSIS:\n"
17380  "\n"
17381  "plmtex(side, disp, pos, just, text)\n"
17382  "\n"
17383  "ARGUMENTS:\n"
17384  "\n"
17385  " side (const char *, input) : Specifies the side of the viewport\n"
17386  " along which the text is to be written. The string must be one of:\n"
17387  " b: Bottom of viewport, text written parallel to edge. \n"
17388  " bv: Bottom of viewport, text written at right angles to edge. \n"
17389  " l: Left of viewport, text written parallel to edge. \n"
17390  " lv: Left of viewport, text written at right angles to edge. \n"
17391  " r: Right of viewport, text written parallel to edge. \n"
17392  " rv: Right of viewport, text written at right angles to edge. \n"
17393  " t: Top of viewport, text written parallel to edge. \n"
17394  " tv: Top of viewport, text written at right angles to edge. \n"
17395  "\n"
17396  "\n"
17397  " disp (PLFLT, input) : Position of the reference point of string,\n"
17398  " measured outwards from the specified viewport edge in units of the\n"
17399  " current character height. Use negative disp to write within the\n"
17400  " viewport. \n"
17401  "\n"
17402  " pos (PLFLT, input) : Position of the reference point of string\n"
17403  " along the specified edge, expressed as a fraction of the length of\n"
17404  " the edge. \n"
17405  "\n"
17406  " just (PLFLT, input) : Specifies the position of the string relative\n"
17407  " to its reference point. If just=0., the reference point is at the\n"
17408  " left and if just=1., it is at the right of the string. Other\n"
17409  " values of just give intermediate justifications. \n"
17410  "\n"
17411  " text (const char *, input) : The string to be written out. \n"
17412  "\n"
17413  ""},
17414  { (char *)"plmtex3", _wrap_plmtex3, METH_VARARGS, (char *)"\n"
17415  "Write text relative to viewport boundaries in 3D plots. \n"
17416  "\n"
17417  "DESCRIPTION:\n"
17418  "\n"
17419  " Writes text at a specified position relative to the viewport\n"
17420  " boundaries. Text may be written inside or outside the viewport, but\n"
17421  " is clipped at the subpage boundaries. The reference point of a string\n"
17422  " lies along a line passing through the string at half the height of a\n"
17423  " capital letter. The position of the reference point along this line\n"
17424  " is determined by just, and the position of the reference point\n"
17425  " relative to the viewport is set by disp and pos. \n"
17426  "\n"
17427  " Redacted form: plmtex3(side, disp, pos, just, text)\n"
17428  "\n"
17429  " This function is used in example 28. \n"
17430  "\n"
17431  "\n"
17432  "\n"
17433  "SYNOPSIS:\n"
17434  "\n"
17435  "plmtex3(side, disp, pos, just, text)\n"
17436  "\n"
17437  "ARGUMENTS:\n"
17438  "\n"
17439  " side (const char *, input) : Specifies the side of the viewport\n"
17440  " along which the text is to be written. The string should contain\n"
17441  " one or more of the following characters: [xyz][ps][v]. Only one\n"
17442  " label is drawn at a time, i.e. xyp will only label the X axis, not\n"
17443  " both the X and Y axes. x: Label the X axis. \n"
17444  " y: Label the Y axis. \n"
17445  " z: Label the Z axis. \n"
17446  " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
17447  " For X it is the axis that starts at y-min. For Y it is the\n"
17448  " axis that starts at x-min. \n"
17449  " s: Label the secondary axis. \n"
17450  " v: Draw the text perpendicular to the axis. \n"
17451  "\n"
17452  "\n"
17453  " disp (PLFLT, input) : Position of the reference point of string,\n"
17454  " measured outwards from the specified viewport edge in units of the\n"
17455  " current character height. Use negative disp to write within the\n"
17456  " viewport. \n"
17457  "\n"
17458  " pos (PLFLT, input) : Position of the reference point of string\n"
17459  " along the specified edge, expressed as a fraction of the length of\n"
17460  " the edge. \n"
17461  "\n"
17462  " just (PLFLT, input) : Specifies the position of the string relative\n"
17463  " to its reference point. If just=0., the reference point is at the\n"
17464  " left and if just=1., it is at the right of the string. Other\n"
17465  " values of just give intermediate justifications. \n"
17466  "\n"
17467  " text (const char *, input) : The string to be written out. \n"
17468  "\n"
17469  ""},
17470  { (char *)"plot3d", _wrap_plot3d, METH_VARARGS, (char *)"\n"
17471  "Plot 3-d surface plot \n"
17472  "\n"
17473  "DESCRIPTION:\n"
17474  "\n"
17475  " Plots a three dimensional surface plot within the environment set up\n"
17476  " by plw3d. The surface is defined by the two-dimensional array z[\n"
17477  " nx][\n"
17478  " ny], the point z[i][j] being the value of the function at (\n"
17479  " x[i], \n"
17480  " y[j]). Note that the points in arrays x and y do not need to be\n"
17481  " equally spaced, but must be stored in ascending order. The parameter\n"
17482  " opt controls the way in which the surface is displayed. For further\n"
17483  " details see the PLplot documentation. The only difference between\n"
17484  " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
17485  " while plot3d only draws the surface as viewed from the top. \n"
17486  "\n"
17487  " Redacted form: plot3d(x, y, z, opt, side)\n"
17488  "\n"
17489  " This function is used in examples 11,21. \n"
17490  "\n"
17491  "\n"
17492  "\n"
17493  "SYNOPSIS:\n"
17494  "\n"
17495  "plot3d(x, y, z, nx, ny, opt, side)\n"
17496  "\n"
17497  "ARGUMENTS:\n"
17498  "\n"
17499  " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17500  " the function is evaluated. \n"
17501  "\n"
17502  " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17503  " the function is evaluated. \n"
17504  "\n"
17505  " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17506  " with set of function values. \n"
17507  "\n"
17508  " nx (PLINT, input) : Number of x values at which function is\n"
17509  " evaluated. \n"
17510  "\n"
17511  " ny (PLINT, input) : Number of y values at which function is\n"
17512  " evaluated. \n"
17513  "\n"
17514  " opt (PLINT, input) : Determines the way in which the surface is\n"
17515  " represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
17516  " function of x for each value of y[j]. \n"
17517  " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17518  " for each value of x[i]. \n"
17519  " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17520  " at which function is defined. \n"
17521  "\n"
17522  "\n"
17523  " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
17524  " should be draw on the figure. If side is true sides are drawn,\n"
17525  " otherwise no sides are drawn. \n"
17526  "\n"
17527  ""},
17528  { (char *)"plot3dc", _wrap_plot3dc, METH_VARARGS, (char *)"\n"
17529  "Magnitude colored plot surface with contour. \n"
17530  "\n"
17531  "DESCRIPTION:\n"
17532  "\n"
17533  " Identical to plot3d but with extra functionalities: the surface mesh\n"
17534  " can be colored accordingly to the current z value being plotted, a\n"
17535  " contour plot can be drawn at the base XY plane, and a curtain can be\n"
17536  " drawn between the plotted function border and the base XY plane. The\n"
17537  " arguments are identical to plmeshc. The only difference between\n"
17538  " plmeshc and plot3dc is that plmeshc draws the bottom side of the\n"
17539  " surface, while plot3dc only draws the surface as viewed from the top. \n"
17540  "\n"
17541  " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
17542  " Perl/PDL: Not available? \n"
17543  "\n"
17544  "\n"
17545  " This function is used in example 21. \n"
17546  "\n"
17547  "\n"
17548  "\n"
17549  "SYNOPSIS:\n"
17550  "\n"
17551  "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17552  "\n"
17553  ""},
17554  { (char *)"plot3dcl", _wrap_plot3dcl, METH_VARARGS, NULL},
17555  { (char *)"plsurf3d", _wrap_plsurf3d, METH_VARARGS, (char *)"\n"
17556  "Plot shaded 3-d surface plot \n"
17557  "\n"
17558  "DESCRIPTION:\n"
17559  "\n"
17560  " Plots a three dimensional shaded surface plot within the environment\n"
17561  " set up by plw3d. The surface is defined by the two-dimensional array\n"
17562  " z[\n"
17563  " nx][\n"
17564  " ny], the point z[i][j] being the value of the function at (\n"
17565  " x[i], \n"
17566  " y[j]). Note that the points in arrays x and y do not need to be\n"
17567  " equally spaced, but must be stored in ascending order. For further\n"
17568  " details see the PLplot documentation. \n"
17569  "\n"
17570  " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
17571  "\n"
17572  " This function is not used in any examples. \n"
17573  "\n"
17574  "\n"
17575  "\n"
17576  "SYNOPSIS:\n"
17577  "\n"
17578  "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17579  "\n"
17580  "ARGUMENTS:\n"
17581  "\n"
17582  " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17583  " the function is evaluated. \n"
17584  "\n"
17585  " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17586  " the function is evaluated. \n"
17587  "\n"
17588  " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17589  " with set of function values. \n"
17590  "\n"
17591  " nx (PLINT, input) : Number of x values at which function is\n"
17592  " evaluated. \n"
17593  "\n"
17594  " ny (PLINT, input) : Number of y values at which function is\n"
17595  " evaluated. \n"
17596  "\n"
17597  " opt (PLINT, input) : Determines the way in which the surface is\n"
17598  " represented. To specify more than one option just add the options,\n"
17599  " e.g. FACETED + SURF_CONT opt=FACETED: Network of lines is drawn\n"
17600  " connecting points at which function is defined. \n"
17601  " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
17602  " using parameters \n"
17603  " nlevel and \n"
17604  " clevel. \n"
17605  " opt=SURF_CONT: A contour plot is drawn at the surface plane\n"
17606  " using parameters \n"
17607  " nlevel and \n"
17608  " clevel. \n"
17609  " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
17610  " the borders of the plotted function. \n"
17611  " opt=MAG_COLOR: the surface is colored according to the value\n"
17612  " of Z; if MAG_COLOR is not used, then the default the surface\n"
17613  " is colored according to the intensity of the reflected light\n"
17614  " in the surface from a light source whose position is set using\n"
17615  " pllightsource. \n"
17616  "\n"
17617  "\n"
17618  " clevel (PLFLT *, input) : Pointer to the array that defines the\n"
17619  " contour level spacing. \n"
17620  "\n"
17621  " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
17622  "\n"
17623  ""},
17624  { (char *)"plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, NULL},
17625  { (char *)"plparseopts", _wrap_plparseopts, METH_VARARGS, (char *)"\n"
17626  "Parse command-line arguments \n"
17627  "\n"
17628  "DESCRIPTION:\n"
17629  "\n"
17630  " Parse command-line arguments. \n"
17631  "\n"
17632  " plparseopts removes all recognized flags (decreasing argc\n"
17633  " accordingly), so that invalid input may be readily detected. It can\n"
17634  " also be used to process user command line flags. The user can merge\n"
17635  " an option table of type PLOptionTable into the internal option table\n"
17636  " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
17637  " the external table(s) be parsed by calling plClearOpts before\n"
17638  " plMergeOpts. \n"
17639  "\n"
17640  " The default action taken by plparseopts is as follows: \n"
17641  " Returns with an error if an unrecognized option or badly formed\n"
17642  " option-value pair are encountered. \n"
17643  " Returns immediately (return code 0) when the first non-option command\n"
17644  " line argument is found. \n"
17645  " Returns with the return code of the option handler, if one was called.\n"
17646  " \n"
17647  " Deletes command line arguments from argv list as they are found, and\n"
17648  " decrements argc accordingly. \n"
17649  " Does not show \"invisible\" options in usage or help messages. \n"
17650  " Assumes the program name is contained in argv[0]. \n"
17651  "\n"
17652  " These behaviors may be controlled through the \n"
17653  " mode argument. \n"
17654  "\n"
17655  " Redacted form: General: plparseopts(argv, mode)\n"
17656  " Perl/PDL: Not available? \n"
17657  "\n"
17658  "\n"
17659  " This function is used in all of the examples. \n"
17660  "\n"
17661  "\n"
17662  "\n"
17663  "SYNOPSIS:\n"
17664  "\n"
17665  "int plparseopts(p_argc, argv, mode)\n"
17666  "\n"
17667  "ARGUMENTS:\n"
17668  "\n"
17669  " p_argc (int *, input) : pointer to number of arguments. \n"
17670  "\n"
17671  " argv (char **, input) : Pointer to character array containing\n"
17672  " *p_argc command-line arguments. \n"
17673  "\n"
17674  " mode (PLINT, input) : Parsing mode with the following\n"
17675  " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
17676  " and all error messages enabled, including program exit when an\n"
17677  " error occurs. Anything on the command line that isn't recognized\n"
17678  " as a valid option or option argument is flagged as an error. \n"
17679  " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
17680  " of errors. \n"
17681  " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
17682  " arguments. \n"
17683  " PL_PARSE_SHOWALL (8) -- Show invisible options \n"
17684  " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
17685  " pointer to the program name. \n"
17686  " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n"
17687  " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
17688  " unrecognized arguments. \n"
17689  "\n"
17690  ""},
17691  { (char *)"plpat", _wrap_plpat, METH_VARARGS, (char *)"\n"
17692  "Set area fill pattern \n"
17693  "\n"
17694  "DESCRIPTION:\n"
17695  "\n"
17696  " Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n"
17697  " parallel lines with specified inclinations and spacings. The\n"
17698  " arguments to this routine are the number of sets to use (1 or 2)\n"
17699  " followed by two pointers to integer arrays (of 1 or 2 elements)\n"
17700  " specifying the inclinations in tenths of a degree and the spacing in\n"
17701  " micrometers. (also see plpsty) \n"
17702  "\n"
17703  " Redacted form: General: plpat(inc, del)\n"
17704  " Perl/PDL: plpat(nlin, inc, del)\n"
17705  "\n"
17706  "\n"
17707  " This function is used in example 15. \n"
17708  "\n"
17709  "\n"
17710  "\n"
17711  "SYNOPSIS:\n"
17712  "\n"
17713  "plpat(nlin, inc, del)\n"
17714  "\n"
17715  "ARGUMENTS:\n"
17716  "\n"
17717  " nlin (PLINT, input) : Number of sets of lines making up the\n"
17718  " pattern, either 1 or 2. \n"
17719  "\n"
17720  " inc (PLINT *, input) : Pointer to array with nlin elements.\n"
17721  " Specifies the line inclination in tenths of a degree. (Should be\n"
17722  " between -900 and 900). \n"
17723  "\n"
17724  " del (PLINT *, input) : Pointer to array with nlin elements.\n"
17725  " Specifies the spacing in micrometers between the lines making up\n"
17726  " the pattern. \n"
17727  "\n"
17728  ""},
17729  { (char *)"plpoin", _wrap_plpoin, METH_VARARGS, (char *)"\n"
17730  "Plot a glyph at the specified points \n"
17731  "\n"
17732  "DESCRIPTION:\n"
17733  "\n"
17734  " Plot a glyph at the specified points. (This function is largely\n"
17735  " superseded by plstring which gives access to many[!] more glyphs.)\n"
17736  " code=-1 means try to just draw a point. Right now it's just a move\n"
17737  " and a draw at the same place. Not ideal, since a sufficiently\n"
17738  " intelligent output device may optimize it away, or there may be faster\n"
17739  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
17740  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
17741  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
17742  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
17743  " code <= 127 the corresponding printable ASCII character is plotted. \n"
17744  "\n"
17745  " Redacted form: plpoin(x, y, code)\n"
17746  "\n"
17747  " This function is used in examples 1,6,14,29. \n"
17748  "\n"
17749  "\n"
17750  "\n"
17751  "SYNOPSIS:\n"
17752  "\n"
17753  "plpoin(n, x, y, code)\n"
17754  "\n"
17755  "ARGUMENTS:\n"
17756  "\n"
17757  " n (PLINT, input) : Number of points in the x and y arrays. \n"
17758  "\n"
17759  " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
17760  " points. \n"
17761  "\n"
17762  " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
17763  " points. \n"
17764  "\n"
17765  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
17766  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
17767  " each of the n points. \n"
17768  "\n"
17769  ""},
17770  { (char *)"plpoin3", _wrap_plpoin3, METH_VARARGS, (char *)"\n"
17771  "Plot a glyph at the specified 3D points \n"
17772  "\n"
17773  "DESCRIPTION:\n"
17774  "\n"
17775  " Plot a glyph at the specified 3D points. (This function is largely\n"
17776  " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
17777  " Set up the call to this function similar to what is done for plline3.\n"
17778  " code=-1 means try to just draw a point. Right now it's just a move\n"
17779  " and a draw at the same place. Not ideal, since a sufficiently\n"
17780  " intelligent output device may optimize it away, or there may be faster\n"
17781  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
17782  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
17783  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
17784  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
17785  " code <= 127 the corresponding printable ASCII character is plotted. \n"
17786  "\n"
17787  " Redacted form: plpoin3(x, y, z, code)\n"
17788  "\n"
17789  " This function is not used in any example. \n"
17790  "\n"
17791  "\n"
17792  "\n"
17793  "SYNOPSIS:\n"
17794  "\n"
17795  "plpoin3(n, x, y, z, code)\n"
17796  "\n"
17797  "ARGUMENTS:\n"
17798  "\n"
17799  " n (PLINT, input) : Number of points in the x and y arrays. \n"
17800  "\n"
17801  " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
17802  " points. \n"
17803  "\n"
17804  " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
17805  " points. \n"
17806  "\n"
17807  " z (PLFLT *, input) : Pointer to an array with Z coordinates of\n"
17808  " points. \n"
17809  "\n"
17810  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
17811  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
17812  " each of the n points. \n"
17813  "\n"
17814  ""},
17815  { (char *)"plpoly3", _wrap_plpoly3, METH_VARARGS, (char *)"\n"
17816  "Draw a polygon in 3 space \n"
17817  "\n"
17818  "DESCRIPTION:\n"
17819  "\n"
17820  " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
17821  " like plline3, but differs from that function in that plpoly3 attempts\n"
17822  " to determine if the polygon is viewable depending on the order of the\n"
17823  " points within the arrays and the value of ifcc. If the back of\n"
17824  " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
17825  " you want, then use plline3 instead. \n"
17826  "\n"
17827  " The points are assumed to be in a plane, and the directionality of the\n"
17828  " plane is determined from the first three points. Additional points do\n"
17829  " not have to lie on the plane defined by the first three, but if they\n"
17830  " do not, then the determination of visibility obviously can't be 100%\n"
17831  " accurate... So if you're 3 space polygons are too far from planar,\n"
17832  " consider breaking them into smaller polygons. 3 points define a plane\n"
17833  " :-). \n"
17834  "\n"
17835  " Bugs: If one of the first two segments is of zero length, or if they\n"
17836  " are co-linear, the calculation of visibility has a 50/50 chance of\n"
17837  " being correct. Avoid such situations :-). See x18c.c for an example\n"
17838  " of this problem. (Search for 20.1). \n"
17839  "\n"
17840  " Redacted form: plpoly3(x, y, z, code)\n"
17841  "\n"
17842  " This function is used in example 18. \n"
17843  "\n"
17844  "\n"
17845  "\n"
17846  "SYNOPSIS:\n"
17847  "\n"
17848  "plpoly3(n, x, y, z, draw, ifcc)\n"
17849  "\n"
17850  "ARGUMENTS:\n"
17851  "\n"
17852  " n (PLINT, input) : Number of points defining line. \n"
17853  "\n"
17854  " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
17855  "\n"
17856  " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
17857  "\n"
17858  " z (PLFLT *, input) : Pointer to array with z coordinates of points. \n"
17859  "\n"
17860  " draw (PLBOOL *, input) : Pointer to array which controls drawing\n"
17861  " the segments of the polygon. If draw[i] is true, then the polygon\n"
17862  " segment from index [i] to [i+1] is drawn, otherwise, not. \n"
17863  "\n"
17864  " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
17865  " polygon is determined by assuming the points are laid out in a\n"
17866  " counter-clockwise order. Otherwise, the directionality of the\n"
17867  " polygon is determined by assuming the points are laid out in a\n"
17868  " clockwise order. \n"
17869  "\n"
17870  ""},
17871  { (char *)"plprec", _wrap_plprec, METH_VARARGS, (char *)"\n"
17872  "Set precision in numeric labels \n"
17873  "\n"
17874  "DESCRIPTION:\n"
17875  "\n"
17876  " Sets the number of places after the decimal point in numeric labels. \n"
17877  "\n"
17878  " Redacted form: plprec(set, prec)\n"
17879  "\n"
17880  " This function is used in example 29. \n"
17881  "\n"
17882  "\n"
17883  "\n"
17884  "SYNOPSIS:\n"
17885  "\n"
17886  "plprec(set, prec)\n"
17887  "\n"
17888  "ARGUMENTS:\n"
17889  "\n"
17890  " set (PLINT, input) : If set is equal to 0 then PLplot automatically\n"
17891  " determines the number of places to use after the decimal point in\n"
17892  " numeric labels (like those used to label axes). If set is 1 then\n"
17893  " prec sets the number of places. \n"
17894  "\n"
17895  " prec (PLINT, input) : The number of characters to draw after the\n"
17896  " decimal point in numeric labels. \n"
17897  "\n"
17898  ""},
17899  { (char *)"plpsty", _wrap_plpsty, METH_VARARGS, (char *)"\n"
17900  "Select area fill pattern \n"
17901  "\n"
17902  "DESCRIPTION:\n"
17903  "\n"
17904  " Select one of eight predefined area fill patterns to use (also see\n"
17905  " plpat). Setting the fill style to 0 gives a solid fill. \n"
17906  "\n"
17907  " Redacted form: plpsty(n)\n"
17908  "\n"
17909  " This function is used in examples 12,13,15,16,25. \n"
17910  "\n"
17911  "\n"
17912  "\n"
17913  "SYNOPSIS:\n"
17914  "\n"
17915  "plpsty(n)\n"
17916  "\n"
17917  "ARGUMENTS:\n"
17918  "\n"
17919  " n (PLINT, input) : The desired pattern. Pattern 1 consists of\n"
17920  " horizontal lines, pattern 2 consists of vertical lines, pattern 3\n"
17921  " consists of lines at 45 degrees angle (upward), and so on. \n"
17922  "\n"
17923  ""},
17924  { (char *)"plptex", _wrap_plptex, METH_VARARGS, (char *)"\n"
17925  "Write text inside the viewport \n"
17926  "\n"
17927  "DESCRIPTION:\n"
17928  "\n"
17929  " Writes text at a specified position and inclination within the\n"
17930  " viewport. Text is clipped at the viewport boundaries. The reference\n"
17931  " point of a string lies along a line passing through the string at half\n"
17932  " the height of a capital letter. The position of the reference point\n"
17933  " along this line is determined by just, the reference point is placed\n"
17934  " at world coordinates (\n"
17935  " x, \n"
17936  " y) within the viewport. The inclination of the string is specified in\n"
17937  " terms of differences of world coordinates making it easy to write text\n"
17938  " parallel to a line in a graph. \n"
17939  "\n"
17940  " Redacted form: plptex(x, y, dx, dy, just, text)\n"
17941  "\n"
17942  " This function is used in example 2-4,10,12-14,20,23,24,26. \n"
17943  "\n"
17944  "\n"
17945  "\n"
17946  "SYNOPSIS:\n"
17947  "\n"
17948  "plptex(x, y, dx, dy, just, text)\n"
17949  "\n"
17950  "ARGUMENTS:\n"
17951  "\n"
17952  " x (PLFLT, input) : x coordinate of reference point of string. \n"
17953  "\n"
17954  " y (PLFLT, input) : y coordinate of reference point of string. \n"
17955  "\n"
17956  " dx (PLFLT, input) : Together with dy, this specifies the\n"
17957  " inclination of the string. The baseline of the string is parallel\n"
17958  " to a line joining (\n"
17959  " x, \n"
17960  " y) to (\n"
17961  " x+\n"
17962  " dx, \n"
17963  " y+\n"
17964  " dy). \n"
17965  "\n"
17966  " dy (PLFLT, input) : Together with dx, this specifies the\n"
17967  " inclination of the string. \n"
17968  "\n"
17969  " just (PLFLT, input) : Specifies the position of the string relative\n"
17970  " to its reference point. If just=0., the reference point is at the\n"
17971  " left and if just=1., it is at the right of the string. Other\n"
17972  " values of just give intermediate justifications. \n"
17973  "\n"
17974  " text (const char *, input) : The string to be written out. \n"
17975  "\n"
17976  ""},
17977  { (char *)"plptex3", _wrap_plptex3, METH_VARARGS, (char *)"\n"
17978  "Write text inside the viewport of a 3D plot. \n"
17979  "\n"
17980  "DESCRIPTION:\n"
17981  "\n"
17982  " Writes text at a specified position and inclination and with a\n"
17983  " specified shear within the viewport. Text is clipped at the viewport\n"
17984  " boundaries. The reference point of a string lies along a line passing\n"
17985  " through the string at half the height of a capital letter. The\n"
17986  " position of the reference point along this line is determined by just,\n"
17987  " and the reference point is placed at world coordinates (\n"
17988  " x, \n"
17989  " y, \n"
17990  " z) within the viewport. The inclination and shear of the string is\n"
17991  " specified in terms of differences of world coordinates making it easy\n"
17992  " to write text parallel to a line in a graph. \n"
17993  "\n"
17994  " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
17995  "\n"
17996  " This function is used in example 28. \n"
17997  "\n"
17998  "\n"
17999  "\n"
18000  "SYNOPSIS:\n"
18001  "\n"
18002  "plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
18003  "\n"
18004  "ARGUMENTS:\n"
18005  "\n"
18006  " x (PLFLT, input) : x coordinate of reference point of string. \n"
18007  "\n"
18008  " y (PLFLT, input) : y coordinate of reference point of string. \n"
18009  "\n"
18010  " z (PLFLT, input) : z coordinate of reference point of string. \n"
18011  "\n"
18012  " dx (PLFLT, input) : Together with dy and \n"
18013  " dz, this specifies the inclination of the string. The baseline of\n"
18014  " the string is parallel to a line joining (\n"
18015  " x, \n"
18016  " y, \n"
18017  " z) to (\n"
18018  " x+\n"
18019  " dx, \n"
18020  " y+\n"
18021  " dy, \n"
18022  " z+\n"
18023  " dz). \n"
18024  "\n"
18025  " dy (PLFLT, input) : Together with dx and \n"
18026  " dz, this specifies the inclination of the string. \n"
18027  "\n"
18028  " dz (PLFLT, input) : Together with dx and \n"
18029  " dy, this specifies the inclination of the string. \n"
18030  "\n"
18031  " sx (PLFLT, input) : Together with sy and \n"
18032  " sz, this specifies the shear of the string. The string is sheared so\n"
18033  " that the characters are vertically parallel to a line joining (\n"
18034  " x, \n"
18035  " y, \n"
18036  " z) to (\n"
18037  " x+\n"
18038  " sx, \n"
18039  " y+\n"
18040  " sy, \n"
18041  " z+\n"
18042  " sz). If sx = \n"
18043  " sy = \n"
18044  " sz = 0.) then the text is not sheared. \n"
18045  "\n"
18046  " sy (PLFLT, input) : Together with sx and \n"
18047  " sz, this specifies shear of the string. \n"
18048  "\n"
18049  " sz (PLFLT, input) : Together with sx and \n"
18050  " sy, this specifies shear of the string. \n"
18051  "\n"
18052  " just (PLFLT, input) : Specifies the position of the string relative\n"
18053  " to its reference point. If just=0., the reference point is at the\n"
18054  " left and if just=1., it is at the right of the string. Other\n"
18055  " values of just give intermediate justifications. \n"
18056  "\n"
18057  " text (const char *, input) : The string to be written out. \n"
18058  "\n"
18059  ""},
18060  { (char *)"plrandd", _wrap_plrandd, METH_VARARGS, (char *)"\n"
18061  "Random number generator returning a real random number in the range [0,1]. \n"
18062  "\n"
18063  "DESCRIPTION:\n"
18064  "\n"
18065  " Random number generator returning a real random number in the range\n"
18066  " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
18067  " / compilers provide their own random number generator, and so this is\n"
18068  " provided purely for convenience and to give a consistent random number\n"
18069  " generator across all languages supported by PLplot. This is\n"
18070  " particularly useful for comparing results from the test suite of\n"
18071  " examples. \n"
18072  "\n"
18073  " Redacted form: plrandd()\n"
18074  "\n"
18075  " This function is used in examples 17,21. \n"
18076  "\n"
18077  "\n"
18078  "\n"
18079  "SYNOPSIS:\n"
18080  "\n"
18081  "plrandd()\n"
18082  "\n"
18083  ""},
18084  { (char *)"plreplot", _wrap_plreplot, METH_VARARGS, (char *)"\n"
18085  "Replays contents of plot buffer to current device/file \n"
18086  "\n"
18087  "DESCRIPTION:\n"
18088  "\n"
18089  " Replays contents of plot buffer to current device/file. \n"
18090  "\n"
18091  " Redacted form: plreplot()\n"
18092  "\n"
18093  " This function is used in example 1,20. \n"
18094  "\n"
18095  "\n"
18096  "\n"
18097  "SYNOPSIS:\n"
18098  "\n"
18099  "plreplot()\n"
18100  "\n"
18101  ""},
18102  { (char *)"plrgbhls", _wrap_plrgbhls, METH_VARARGS, (char *)"\n"
18103  "Convert RGB color to HLS \n"
18104  "\n"
18105  "DESCRIPTION:\n"
18106  "\n"
18107  " Convert RGB color coordinates to HLS \n"
18108  "\n"
18109  " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18110  " Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n"
18111  "\n"
18112  "\n"
18113  " This function is used in example 2. \n"
18114  "\n"
18115  "\n"
18116  "\n"
18117  "SYNOPSIS:\n"
18118  "\n"
18119  "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18120  "\n"
18121  "ARGUMENTS:\n"
18122  "\n"
18123  " r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n"
18124  "\n"
18125  " g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n"
18126  "\n"
18127  " b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n"
18128  "\n"
18129  " p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n"
18130  " cone (0.0-360.0) \n"
18131  "\n"
18132  " p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n"
18133  " fraction of the axis of the colour cone (0.0-1.0) \n"
18134  "\n"
18135  " p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n"
18136  " fraction of the radius of the colour cone (0.0-1.0) \n"
18137  "\n"
18138  ""},
18139  { (char *)"plschr", _wrap_plschr, METH_VARARGS, (char *)"\n"
18140  "Set character size \n"
18141  "\n"
18142  "DESCRIPTION:\n"
18143  "\n"
18144  " This sets up the size of all subsequent characters drawn. The actual\n"
18145  " height of a character is the product of the default character size and\n"
18146  " a scaling factor. \n"
18147  "\n"
18148  " Redacted form: plschr(def, scale)\n"
18149  "\n"
18150  " This function is used in example 2,13,23,24. \n"
18151  "\n"
18152  "\n"
18153  "\n"
18154  "SYNOPSIS:\n"
18155  "\n"
18156  "plschr(def, scale)\n"
18157  "\n"
18158  "ARGUMENTS:\n"
18159  "\n"
18160  " def (PLFLT, input) : The default height of a character in\n"
18161  " millimeters, should be set to zero if the default height is to\n"
18162  " remain unchanged. \n"
18163  "\n"
18164  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
18165  " actual character height. \n"
18166  "\n"
18167  ""},
18168  { (char *)"plscmap0", _wrap_plscmap0, METH_VARARGS, (char *)"\n"
18169  "Set color map0 colors by 8-bit RGB values \n"
18170  "\n"
18171  "DESCRIPTION:\n"
18172  "\n"
18173  " Set color map0 colors using 8-bit RGB values (see the PLplot\n"
18174  " documentation). This sets the entire color map -- only as many colors\n"
18175  " as specified will be allocated. \n"
18176  "\n"
18177  " Redacted form: plscmap0(r, g, b, ncol0)\n"
18178  "\n"
18179  " This function is used in examples 2,24. \n"
18180  "\n"
18181  "\n"
18182  "\n"
18183  "SYNOPSIS:\n"
18184  "\n"
18185  "plscmap0(r, g, b, ncol0)\n"
18186  "\n"
18187  "ARGUMENTS:\n"
18188  "\n"
18189  " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18190  " integers (0-255) representing the degree of red in the color. \n"
18191  "\n"
18192  " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18193  " integers (0-255) representing the degree of green in the color. \n"
18194  "\n"
18195  " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18196  " integers (0-255) representing the degree of blue in the color. \n"
18197  "\n"
18198  " ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
18199  "\n"
18200  ""},
18201  { (char *)"plscmap0a", _wrap_plscmap0a, METH_VARARGS, (char *)"\n"
18202  "Set color map0 colors by 8-bit RGB values and double alpha value. \n"
18203  "\n"
18204  "DESCRIPTION:\n"
18205  "\n"
18206  " Set color map0 colors using 8-bit RGB values (see the PLplot\n"
18207  " documentation) and floating point alpha value. This sets the entire\n"
18208  " color map -- only as many colors as specified will be allocated. \n"
18209  "\n"
18210  " This function is used in examples 30. \n"
18211  "\n"
18212  "\n"
18213  "\n"
18214  "SYNOPSIS:\n"
18215  "\n"
18216  "plscmap0a(r, g, b, a, ncol0)\n"
18217  "\n"
18218  "ARGUMENTS:\n"
18219  "\n"
18220  " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18221  " integers (0-255) representing the degree of red in the color. \n"
18222  "\n"
18223  " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18224  " integers (0-255) representing the degree of green in the color. \n"
18225  "\n"
18226  " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18227  " integers (0-255) representing the degree of blue in the color. \n"
18228  "\n"
18229  " a (PLFLT *, input) : Pointer to array with set of PLFLT values (0.0\n"
18230  " - 1.0) representing the transparency of the color. \n"
18231  "\n"
18232  " ncol0 (PLINT, input) : Number of items in the r, g, b, and a\n"
18233  " arrays. \n"
18234  "\n"
18235  ""},
18236  { (char *)"plscmap0n", _wrap_plscmap0n, METH_VARARGS, (char *)"\n"
18237  "Set number of colors in color map0 \n"
18238  "\n"
18239  "DESCRIPTION:\n"
18240  "\n"
18241  " Set number of colors in color map0 (see the PLplot documentation).\n"
18242  " Allocate (or reallocate) color map0, and fill with default values for\n"
18243  " those colors not previously allocated. The first 16 default colors are\n"
18244  " given in the plcol0 documentation. For larger indices the default\n"
18245  " color is red. \n"
18246  "\n"
18247  " The drivers are not guaranteed to support more than 16 colors. \n"
18248  "\n"
18249  " Redacted form: plscmap0n(ncol0)\n"
18250  "\n"
18251  " This function is used in examples 15,16,24. \n"
18252  "\n"
18253  "\n"
18254  "\n"
18255  "SYNOPSIS:\n"
18256  "\n"
18257  "plscmap0n(ncol0)\n"
18258  "\n"
18259  "ARGUMENTS:\n"
18260  "\n"
18261  " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
18262  " the map0 palette. If this number is zero or less, then the value\n"
18263  " from the previous call to plscmap0n is used and if there is no\n"
18264  " previous call, then a default value is used. \n"
18265  "\n"
18266  ""},
18267  { (char *)"plscmap1", _wrap_plscmap1, METH_VARARGS, (char *)"\n"
18268  "Set color map1 colors using 8-bit RGB values \n"
18269  "\n"
18270  "DESCRIPTION:\n"
18271  "\n"
18272  " Set color map1 colors using 8-bit RGB values (see the PLplot\n"
18273  " documentation). This also sets the number of colors. \n"
18274  "\n"
18275  " Redacted form: plscmap1(r, g, b, ncol1)\n"
18276  "\n"
18277  " This function is used in example 31. \n"
18278  "\n"
18279  "\n"
18280  "\n"
18281  "SYNOPSIS:\n"
18282  "\n"
18283  "plscmap1(r, g, b, ncol1)\n"
18284  "\n"
18285  "ARGUMENTS:\n"
18286  "\n"
18287  " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18288  " integers (0-255) representing the degree of red in the color. \n"
18289  "\n"
18290  " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18291  " integers (0-255) representing the degree of green in the color. \n"
18292  "\n"
18293  " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18294  " integers (0-255) representing the degree of blue in the color. \n"
18295  "\n"
18296  " ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
18297  "\n"
18298  ""},
18299  { (char *)"plscmap1a", _wrap_plscmap1a, METH_VARARGS, (char *)"\n"
18300  "Set color map1 colors using 8-bit RGB values and double alpha values. \n"
18301  "\n"
18302  "DESCRIPTION:\n"
18303  "\n"
18304  " Set color map1 colors using 8-bit RGB values (see the PLplot\n"
18305  " documentation) and double alpha values. This also sets the number of\n"
18306  " colors.\n"
18307  "\n"
18308  " This function is used in example 31. \n"
18309  "\n"
18310  "\n"
18311  "\n"
18312  "SYNOPSIS:\n"
18313  "\n"
18314  "plscmap1a(r, g, b, a, ncol1)\n"
18315  "\n"
18316  "ARGUMENTS:\n"
18317  "\n"
18318  " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18319  " integers (0-255) representing the degree of red in the color. \n"
18320  "\n"
18321  " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18322  " integers (0-255) representing the degree of green in the color. \n"
18323  "\n"
18324  " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18325  " integers (0-255) representing the degree of blue in the color. \n"
18326  "\n"
18327  " a (PLFLT *, input) : Pointer to array with set of double values\n"
18328  " (0.0-1.0) representing the alpha value of the color. \n"
18329  "\n"
18330  " ncol1 (PLINT, input) : Number of items in the r, g, b, and a\n"
18331  " arrays. \n"
18332  "\n"
18333  ""},
18334  { (char *)"plscmap1l", _wrap_plscmap1l, METH_VARARGS, (char *)"\n"
18335  "Set color map1 colors using a piece-wise linear relationship \n"
18336  "\n"
18337  "DESCRIPTION:\n"
18338  "\n"
18339  " Set color map1 colors using a piece-wise linear relationship between\n"
18340  " position in the color map (from 0 to 1) and position in HLS or RGB\n"
18341  " color space (see the PLplot documentation). May be called at any\n"
18342  " time. \n"
18343  "\n"
18344  " The idea here is to specify a number of control points that define the\n"
18345  " mapping between palette 1 input positions (intensities) and HLS (or\n"
18346  " RGB). Between these points, linear interpolation is used which gives\n"
18347  " a smooth variation of color with input position. Any number of\n"
18348  " control points may be specified, located at arbitrary positions,\n"
18349  " although typically 2 - 4 are enough. Another way of stating this is\n"
18350  " that we are traversing a given number of lines through HLS (or RGB)\n"
18351  " space as we move through color map1 entries. The control points at\n"
18352  " the minimum and maximum position (0 and 1) must always be specified. \n"
18353  " By adding more control points you can get more variation. One good\n"
18354  " technique for plotting functions that vary about some expected average\n"
18355  " is to use an additional 2 control points in the center (position ~=\n"
18356  " 0.5) that are the same lightness as the background (typically white\n"
18357  " for paper output, black for crt), and same hue as the boundary control\n"
18358  " points. This allows the highs and lows to be very easily\n"
18359  " distinguished. \n"
18360  "\n"
18361  " Each control point must specify the position in color map1 as well as\n"
18362  " three coordinates in HLS or RGB space. The first point must\n"
18363  " correspond to position = 0, and the last to position = 1. \n"
18364  "\n"
18365  " The default behaviour is for the hue to be linearly interpolated \n"
18366  " between the control points. Since the hue lies in the range [0, 360]\n"
18367  " this corresponds to interpolation around the \"front\" of the color\n"
18368  " wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n"
18369  " alternative interpolation is used between control points i and i+1. If\n"
18370  " hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and\n"
18371  " hue[i+1] - 360, otherwise between hue[i] and hue[i+1] + 360. You can\n"
18372  " consider this as interpolation around the \"back\" or \"reverse\" of the\n"
18373  " color wheel. Specifying alt_hue_path=NULL is equivalent to setting\n"
18374  " alt_hue_path[] = false for every control point. \n"
18375  "\n"
18376  " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
18377  " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
18378  " 240]truegreen-yellow-red-magenta-blue[240\n"
18379  " 120]trueblue-magenta-red-yellow-green\n"
18380  "\n"
18381  " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
18382  " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
18383  " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
18384  "\n"
18385  " Redacted form: plscmap1l(itype, pos, coord1, coord2, coord3,\n"
18386  " alt_hue_path)\n"
18387  "\n"
18388  " This function is used in examples 8,11,12,15,20,21. \n"
18389  "\n"
18390  "\n"
18391  "\n"
18392  "SYNOPSIS:\n"
18393  "\n"
18394  "plscmap1l(itype, npts, pos, coord1, coord2, coord3, alt_hue_path)\n"
18395  "\n"
18396  "ARGUMENTS:\n"
18397  "\n"
18398  " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
18399  "\n"
18400  " npts (PLINT, input) : number of control points \n"
18401  "\n"
18402  " pos (PLFLT *, input) : position for each control point (between 0.0\n"
18403  " and 1.0, in ascending order) \n"
18404  "\n"
18405  " coord1 (PLFLT *, input) : first coordinate (H or R) for each\n"
18406  " control point \n"
18407  "\n"
18408  " coord2 (PLFLT *, input) : second coordinate (L or G) for each\n"
18409  " control point \n"
18410  "\n"
18411  " coord3 (PLFLT *, input) : third coordinate (S or B) for each\n"
18412  " control point \n"
18413  "\n"
18414  " alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n"
18415  " flag for each control point. (alt_hue_path[i] refers to the\n"
18416  " interpolation interval between the i and i + 1 control points). \n"
18417  "\n"
18418  ""},
18419  { (char *)"plscmap1la", _wrap_plscmap1la, METH_VARARGS, (char *)"\n"
18420  "Set color map1 colors using a piece-wise linear relationship \n"
18421  "\n"
18422  "DESCRIPTION:\n"
18423  "\n"
18424  " This is a version of plscmap1l that supports alpha transparency. It\n"
18425  " sets color map1 colors using a piece-wise linear relationship between\n"
18426  " position in the color map (from 0 to 1) and position in HLS or RGB\n"
18427  " color space (see the PLplot documentation) with alpha value (0.0 -\n"
18428  " 1.0). It may be called at any time. \n"
18429  "\n"
18430  " This function is used in example 30. \n"
18431  "\n"
18432  "\n"
18433  "\n"
18434  "SYNOPSIS:\n"
18435  "\n"
18436  "plscmap1la(itype, npts, pos, coord1, coord2, coord3, coord4, alt_hue_path)\n"
18437  "\n"
18438  "ARGUMENTS:\n"
18439  "\n"
18440  " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
18441  "\n"
18442  " npts (PLINT, input) : number of control points \n"
18443  "\n"
18444  " pos (PLFLT *, input) : position for each control point (between 0.0\n"
18445  " and 1.0, in ascending order) \n"
18446  "\n"
18447  " coord1 (PLFLT *, input) : first coordinate (H or R) for each\n"
18448  " control point \n"
18449  "\n"
18450  " coord2 (PLFLT *, input) : second coordinate (L or G) for each\n"
18451  " control point \n"
18452  "\n"
18453  " coord3 (PLFLT *, input) : third coordinate (S or B) for each\n"
18454  " control point \n"
18455  "\n"
18456  " coord4 (PLFLT *, input) : fourth coordinate, the alpha value for\n"
18457  " each control point \n"
18458  "\n"
18459  " alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n"
18460  " flag for each control point. (alt_hue_path[i] refers to the\n"
18461  " interpolation interval between the i and i + 1 control points). \n"
18462  "\n"
18463  ""},
18464  { (char *)"plscmap1n", _wrap_plscmap1n, METH_VARARGS, (char *)"\n"
18465  "Set number of colors in color map1 \n"
18466  "\n"
18467  "DESCRIPTION:\n"
18468  "\n"
18469  " Set number of colors in color map1, (re-)allocate color map1, and set\n"
18470  " default values if this is the first allocation (see the PLplot\n"
18471  " documentation). \n"
18472  "\n"
18473  " Redacted form: plscmap1n(ncol1)\n"
18474  "\n"
18475  " This function is used in examples 8,11,20,21. \n"
18476  "\n"
18477  "\n"
18478  "\n"
18479  "SYNOPSIS:\n"
18480  "\n"
18481  "plscmap1n(ncol1)\n"
18482  "\n"
18483  "ARGUMENTS:\n"
18484  "\n"
18485  " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
18486  " the map1 palette. If this number is zero or less, then the value\n"
18487  " from the previous call to plscmap1n is used and if there is no\n"
18488  " previous call, then a default value is used. \n"
18489  "\n"
18490  ""},
18491  { (char *)"plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, NULL},
18492  { (char *)"plgcmap1_range", _wrap_plgcmap1_range, METH_VARARGS, NULL},
18493  { (char *)"plscol0", _wrap_plscol0, METH_VARARGS, (char *)"\n"
18494  "Set a given color from color map0 by 8 bit RGB value \n"
18495  "\n"
18496  "ESCRIPTION:\n"
18497  "\n"
18498  " Set a given color by 8-bit RGB value for color map0 (see the PLplot\n"
18499  " documentation). Overwrites the previous color value for the given\n"
18500  " index and, thus, does not result in any additional allocation of space\n"
18501  " for colors. \n"
18502  "\n"
18503  " Redacted form: plscol0(icol0, r, g, b)\n"
18504  "\n"
18505  " This function is not used in any examples. \n"
18506  "\n"
18507  "\n"
18508  "\n"
18509  "YNOPSIS:\n"
18510  "\n"
18511  "lscol0(icol0, r, g, b)\n"
18512  "\n"
18513  "RGUMENTS:\n"
18514  "\n"
18515  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
18516  " number of colors (which is set by default, by plscmap0n, or even\n"
18517  " by plscmap0). \n"
18518  "\n"
18519  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18520  " degree of red in the color. \n"
18521  "\n"
18522  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18523  " degree of green in the color. \n"
18524  "\n"
18525  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18526  " degree of blue in the color. \n"
18527  "\n"
18528  ""},
18529  { (char *)"plscol0a", _wrap_plscol0a, METH_VARARGS, (char *)"\n"
18530  "Set a given color from color map0 by 8 bit RGB value and double alpha value. \n"
18531  "\n"
18532  "ESCRIPTION:\n"
18533  "\n"
18534  " Set a given color by 8-bit RGB value and double alpha value for color \n"
18535  " map0 (see the PLplot documentation). Overwrites the previous color\n"
18536  " value for the given index and, thus, does not result in any\n"
18537  " additional allocation of space for colors. \n"
18538  "\n"
18539  " This function is used in example 30. \n"
18540  "\n"
18541  "\n"
18542  "\n"
18543  "YNOPSIS:\n"
18544  "\n"
18545  "lscol0a(icol0, r, g, b, a)\n"
18546  "\n"
18547  "RGUMENTS:\n"
18548  "\n"
18549  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
18550  " number of colors (which is set by default, by plscmap0n, or even\n"
18551  " by plscmap0). \n"
18552  "\n"
18553  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18554  " degree of red in the color. \n"
18555  "\n"
18556  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18557  " degree of green in the color. \n"
18558  "\n"
18559  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18560  " degree of blue in the color. \n"
18561  "\n"
18562  " a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n"
18563  " value of the color. \n"
18564  "\n"
18565  ""},
18566  { (char *)"plscolbg", _wrap_plscolbg, METH_VARARGS, (char *)"\n"
18567  "Set the background color by 8-bit RGB value \n"
18568  "\n"
18569  "DESCRIPTION:\n"
18570  "\n"
18571  " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
18572  " (see the PLplot documentation). \n"
18573  "\n"
18574  " Redacted form: plscolbg(r, g, b)\n"
18575  "\n"
18576  " This function is used in examples 15,31. \n"
18577  "\n"
18578  "\n"
18579  "\n"
18580  "SYNOPSIS:\n"
18581  "\n"
18582  "plscolbg(r, g, b)\n"
18583  "\n"
18584  "ARGUMENTS:\n"
18585  "\n"
18586  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18587  " degree of red in the color. \n"
18588  "\n"
18589  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18590  " degree of green in the color. \n"
18591  "\n"
18592  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18593  " degree of blue in the color. \n"
18594  "\n"
18595  ""},
18596  { (char *)"plscolbga", _wrap_plscolbga, METH_VARARGS, (char *)"\n"
18597  "Set the background color by 8-bit RGB value and double alpha value. \n"
18598  "\n"
18599  "DESCRIPTION:\n"
18600  "\n"
18601  " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
18602  " (see the PLplot documentation) and double alpha value. \n"
18603  "\n"
18604  " This function is used in example 31. \n"
18605  "\n"
18606  "\n"
18607  "\n"
18608  "SYNOPSIS:\n"
18609  "\n"
18610  "plscolbga(r, g, b, a)\n"
18611  "\n"
18612  "ARGUMENTS:\n"
18613  "\n"
18614  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18615  " degree of red in the color. \n"
18616  "\n"
18617  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18618  " degree of green in the color. \n"
18619  "\n"
18620  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18621  " degree of blue in the color. \n"
18622  "\n"
18623  " a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n"
18624  " value of the color. \n"
18625  "\n"
18626  ""},
18627  { (char *)"plscolor", _wrap_plscolor, METH_VARARGS, (char *)"\n"
18628  "Used to globally turn color output on/off \n"
18629  "\n"
18630  "DESCRIPTION:\n"
18631  "\n"
18632  " Used to globally turn color output on/off for those drivers/devices\n"
18633  " that support it. \n"
18634  "\n"
18635  " Redacted form: plscolor(color)\n"
18636  "\n"
18637  " This function is used in example 31. \n"
18638  "\n"
18639  "\n"
18640  "\n"
18641  "SYNOPSIS:\n"
18642  "\n"
18643  "plscolor(color)\n"
18644  "\n"
18645  "ARGUMENTS:\n"
18646  "\n"
18647  " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
18648  " turned off. If non-zero, color is turned on. \n"
18649  "\n"
18650  ""},
18651  { (char *)"plscompression", _wrap_plscompression, METH_VARARGS, (char *)"\n"
18652  "Set device-compression level \n"
18653  "\n"
18654  "DESCRIPTION:\n"
18655  "\n"
18656  " Set device-compression level. Only used for drivers that provide\n"
18657  " compression. This function, if used, should be invoked before a call\n"
18658  " to plinit. \n"
18659  "\n"
18660  " Redacted form: plscompression(compression)\n"
18661  "\n"
18662  " This function is used in example 31. \n"
18663  "\n"
18664  "\n"
18665  "\n"
18666  "SYNOPSIS:\n"
18667  "\n"
18668  "plscompression(compression)\n"
18669  "\n"
18670  "ARGUMENTS:\n"
18671  "\n"
18672  " compression (PLINT, input) : The desired compression level. This is\n"
18673  " a device-dependent value. Currently only the jpeg and png devices\n"
18674  " use these values. For jpeg value is the jpeg quality which should\n"
18675  " normally be in the range 0-95. Higher values denote higher quality\n"
18676  " and hence larger image sizes. For png values are in the range -1\n"
18677  " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
18678  " A value of -1 denotes the default zlib compression level. Values\n"
18679  " in the range 10-99 are divided by 10 and then used as the zlib\n"
18680  " compression level. Higher compression levels correspond to greater\n"
18681  " compression and small file sizes at the expense of more\n"
18682  " computation. \n"
18683  "\n"
18684  ""},
18685  { (char *)"plsdev", _wrap_plsdev, METH_VARARGS, (char *)"\n"
18686  "Set the device (keyword) name \n"
18687  "\n"
18688  "DESCRIPTION:\n"
18689  "\n"
18690  " Set the device (keyword) name. \n"
18691  "\n"
18692  " Redacted form: plsdev(devname)\n"
18693  "\n"
18694  " This function is used in examples 1,14,20. \n"
18695  "\n"
18696  "\n"
18697  "\n"
18698  "SYNOPSIS:\n"
18699  "\n"
18700  "plsdev(devname)\n"
18701  "\n"
18702  "ARGUMENTS:\n"
18703  "\n"
18704  " devname (const char *, input) : Pointer to device (keyword) name\n"
18705  " string. \n"
18706  "\n"
18707  ""},
18708  { (char *)"plsdidev", _wrap_plsdidev, METH_VARARGS, (char *)"\n"
18709  "Set parameters that define current device-space window \n"
18710  "\n"
18711  "DESCRIPTION:\n"
18712  "\n"
18713  " Set relative margin width, aspect ratio, and relative justification\n"
18714  " that define current device-space window. If you want to just use the\n"
18715  " previous value for any of these, just pass in the magic value\n"
18716  " PL_NOTSET. It is unlikely that one should ever need to change the\n"
18717  " aspect ratio but it's in there for completeness. If plsdidev is not\n"
18718  " called the default values of mar, jx, and jy are all 0. aspect is set\n"
18719  " to a device-specific value. \n"
18720  "\n"
18721  " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
18722  "\n"
18723  " This function is used in example 31. \n"
18724  "\n"
18725  "\n"
18726  "\n"
18727  "SYNOPSIS:\n"
18728  "\n"
18729  "plsdidev(mar, aspect, jx, jy)\n"
18730  "\n"
18731  "ARGUMENTS:\n"
18732  "\n"
18733  " mar (PLFLT, input) : Relative margin width. \n"
18734  "\n"
18735  " aspect (PLFLT, input) : Aspect ratio. \n"
18736  "\n"
18737  " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
18738  " the range -0.5 to 0.5. \n"
18739  "\n"
18740  " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
18741  " the range -0.5 to 0.5. \n"
18742  "\n"
18743  ""},
18744  { (char *)"plsdimap", _wrap_plsdimap, METH_VARARGS, (char *)"\n"
18745  "Set up transformation from metafile coordinates \n"
18746  "\n"
18747  "DESCRIPTION:\n"
18748  "\n"
18749  " Set up transformation from metafile coordinates. The size of the plot\n"
18750  " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
18751  " general-purpose facility just yet (not sure why the user would need\n"
18752  " it, for one). \n"
18753  "\n"
18754  " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
18755  " dimypmm)\n"
18756  "\n"
18757  " This function is not used in any examples. \n"
18758  "\n"
18759  "\n"
18760  "\n"
18761  "SYNOPSIS:\n"
18762  "\n"
18763  "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
18764  "\n"
18765  "ARGUMENTS:\n"
18766  "\n"
18767  " dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n"
18768  "\n"
18769  " dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n"
18770  "\n"
18771  " dimymin (PLINT, input) : NEEDS DOCUMENTATION \n"
18772  "\n"
18773  " dimymax (PLINT, input) : NEEDS DOCUMENTATION \n"
18774  "\n"
18775  " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
18776  "\n"
18777  " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
18778  "\n"
18779  ""},
18780  { (char *)"plsdiori", _wrap_plsdiori, METH_VARARGS, (char *)"\n"
18781  "Set plot orientation \n"
18782  "\n"
18783  "DESCRIPTION:\n"
18784  "\n"
18785  " Set plot orientation parameter which is multiplied by 90 degrees to\n"
18786  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
18787  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
18788  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
18789  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
18790  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
18791  " not called the default value of rot is 0. \n"
18792  "\n"
18793  " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
18794  " probably want to change the aspect ratio to a value suitable for the\n"
18795  " plot orientation using a call to plsdidev or the command-line options\n"
18796  " -a or -freeaspect. For more documentation of those options see the\n"
18797  " PLplot documentation. Such command-line options can be set internally\n"
18798  " using plsetopt or set directly using the command line and parsed using\n"
18799  " a call to plparseopts. \n"
18800  "\n"
18801  " Redacted form: plsdiori(rot)\n"
18802  "\n"
18803  " This function is not used in any examples. \n"
18804  "\n"
18805  "\n"
18806  "\n"
18807  "SYNOPSIS:\n"
18808  "\n"
18809  "plsdiori(rot)\n"
18810  "\n"
18811  "ARGUMENTS:\n"
18812  "\n"
18813  " rot (PLFLT, input) : Plot orientation parameter. \n"
18814  "\n"
18815  ""},
18816  { (char *)"plsdiplt", _wrap_plsdiplt, METH_VARARGS, (char *)"\n"
18817  "Set parameters that define current plot-space window \n"
18818  "\n"
18819  "DESCRIPTION:\n"
18820  "\n"
18821  " Set relative minima and maxima that define the current plot-space\n"
18822  " window. If plsdiplt is not called the default values of xmin, ymin,\n"
18823  " xmax, and ymax are 0., 0., 1., and 1. \n"
18824  "\n"
18825  " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
18826  "\n"
18827  " This function is used in example 31. \n"
18828  "\n"
18829  "\n"
18830  "\n"
18831  "SYNOPSIS:\n"
18832  "\n"
18833  "plsdiplt(xmin, ymin, xmax, ymax)\n"
18834  "\n"
18835  "ARGUMENTS:\n"
18836  "\n"
18837  " xmin (PLFLT, input) : Relative minimum in x. \n"
18838  "\n"
18839  " ymin (PLFLT, input) : Relative minimum in y. \n"
18840  "\n"
18841  " xmax (PLFLT, input) : Relative maximum in x. \n"
18842  "\n"
18843  " ymax (PLFLT, input) : Relative maximum in y. \n"
18844  "\n"
18845  ""},
18846  { (char *)"plsdiplz", _wrap_plsdiplz, METH_VARARGS, (char *)"\n"
18847  "Set parameters incrementally (zoom mode) that define current plot-space window \n"
18848  "\n"
18849  "DESCRIPTION:\n"
18850  "\n"
18851  " Set relative minima and maxima incrementally (zoom mode) that define\n"
18852  " the current plot-space window. This function has the same effect as\n"
18853  " plsdiplt if that function has not been previously called. Otherwise,\n"
18854  " this function implements zoom mode using the transformation min_used =\n"
18855  " old_min + old_length*min and max_used = old_min + old_length*max for\n"
18856  " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
18857  " repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n"
18858  "\n"
18859  " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
18860  "\n"
18861  " This function is used in example 31. \n"
18862  "\n"
18863  "\n"
18864  "\n"
18865  "SYNOPSIS:\n"
18866  "\n"
18867  "plsdiplz(xmin, ymin, xmax, ymax)\n"
18868  "\n"
18869  "ARGUMENTS:\n"
18870  "\n"
18871  " xmin (PLFLT, input) : Relative (incremental) minimum in x. \n"
18872  "\n"
18873  " ymin (PLFLT, input) : Relative (incremental) minimum in y. \n"
18874  "\n"
18875  " xmax (PLFLT, input) : Relative (incremental) maximum in x. \n"
18876  "\n"
18877  " ymax (PLFLT, input) : Relative (incremental) maximum in y. \n"
18878  "\n"
18879  ""},
18880  { (char *)"plseed", _wrap_plseed, METH_VARARGS, (char *)"\n"
18881  "Set seed for internal random number generator. \n"
18882  "\n"
18883  "DESCRIPTION:\n"
18884  "\n"
18885  " Set the seed for the internal random number generator. See plrandd for\n"
18886  " further details. \n"
18887  "\n"
18888  " Redacted form: plseed(seed)\n"
18889  "\n"
18890  " This function is used in example 21. \n"
18891  "\n"
18892  "\n"
18893  "\n"
18894  "SYNOPSIS:\n"
18895  "\n"
18896  "plseed(seed)\n"
18897  "\n"
18898  "ARGUMENTS:\n"
18899  "\n"
18900  " seed (unsigned int, input) : Seed for random number generator. \n"
18901  "\n"
18902  ""},
18903  { (char *)"plsesc", _wrap_plsesc, METH_VARARGS, (char *)"\n"
18904  "Set the escape character for text strings \n"
18905  "\n"
18906  "DESCRIPTION:\n"
18907  "\n"
18908  " Set the escape character for text strings. From C (in contrast to\n"
18909  " Fortran 77, see plsescfortran77) you pass esc as a character. Only\n"
18910  " selected characters are allowed to prevent the user from shooting\n"
18911  " himself in the foot (For example, a \\ isn't allowed since it conflicts\n"
18912  " with C's use of backslash as a character escape). Here are the\n"
18913  " allowed escape characters and their corresponding decimal ASCII\n"
18914  " values: !, ASCII 33 \n"
18915  " #, ASCII 35 \n"
18916  " $, ASCII 36 \n"
18917  " %, ASCII 37 \n"
18918  " &, ASCII 38 \n"
18919  " *, ASCII 42 \n"
18920  " @, ASCII 64 \n"
18921  " ^, ASCII 94 \n"
18922  " ~, ASCII 126 \n"
18923  "\n"
18924  "\n"
18925  " Redacted form: General: plsesc(esc)\n"
18926  " Perl/PDL: Not available? \n"
18927  "\n"
18928  "\n"
18929  " This function is used in example 29. \n"
18930  "\n"
18931  "\n"
18932  "\n"
18933  "SYNOPSIS:\n"
18934  "\n"
18935  "plsesc(esc)\n"
18936  "\n"
18937  "ARGUMENTS:\n"
18938  "\n"
18939  " esc (char, input) : Escape character. \n"
18940  "\n"
18941  ""},
18942  { (char *)"plsetopt", _wrap_plsetopt, METH_VARARGS, (char *)"\n"
18943  "Set any command-line option \n"
18944  "\n"
18945  "DESCRIPTION:\n"
18946  "\n"
18947  " Set any command-line option internally from a program before it\n"
18948  " invokes plinit. opt is the name of the command-line option and optarg\n"
18949  " is the corresponding command-line option argument. \n"
18950  "\n"
18951  " This function returns 0 on success. \n"
18952  "\n"
18953  " Redacted form: plsetopt(opt, optarg)\n"
18954  "\n"
18955  " This function is used in example 14. \n"
18956  "\n"
18957  "\n"
18958  "\n"
18959  "SYNOPSIS:\n"
18960  "\n"
18961  "int plsetopt(opt, optarg)\n"
18962  "\n"
18963  "ARGUMENTS:\n"
18964  "\n"
18965  " opt (const char *, input) : Pointer to string containing the\n"
18966  " command-line option. \n"
18967  "\n"
18968  " optarg (const char *, input) : Pointer to string containing the\n"
18969  " argument of the command-line option. \n"
18970  "\n"
18971  ""},
18972  { (char *)"plsfam", _wrap_plsfam, METH_VARARGS, (char *)"\n"
18973  "Set family file parameters \n"
18974  "\n"
18975  "DESCRIPTION:\n"
18976  "\n"
18977  " Sets variables dealing with output file familying. Does nothing if\n"
18978  " familying not supported by the driver. This routine, if used, must be\n"
18979  " called before initializing PLplot. See the PLplot documentation for\n"
18980  " more information. \n"
18981  "\n"
18982  " Redacted form: plsfam(fam, num, bmax)\n"
18983  "\n"
18984  " This function is used in examples 14,31. \n"
18985  "\n"
18986  "\n"
18987  "\n"
18988  "SYNOPSIS:\n"
18989  "\n"
18990  "plsfam(fam, num, bmax)\n"
18991  "\n"
18992  "ARGUMENTS:\n"
18993  "\n"
18994  " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
18995  " is enabled. \n"
18996  "\n"
18997  " num (PLINT, input) : Current family file number. \n"
18998  "\n"
18999  " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
19000  " file. \n"
19001  "\n"
19002  ""},
19003  { (char *)"plsfci", _wrap_plsfci, METH_VARARGS, (char *)"\n"
19004  "Set FCI (font characterization integer) \n"
19005  "\n"
19006  "DESCRIPTION:\n"
19007  "\n"
19008  " Sets font characteristics to be used at the start of the next string\n"
19009  " using the FCI approach. See the PLplot documentation for more\n"
19010  " information. \n"
19011  "\n"
19012  " Redacted form: General: plsfci(fci)\n"
19013  " Perl/PDL: Not available? \n"
19014  "\n"
19015  "\n"
19016  " This function is used in example 23. \n"
19017  "\n"
19018  "\n"
19019  "\n"
19020  "SYNOPSIS:\n"
19021  "\n"
19022  "plsfci(fci)\n"
19023  "\n"
19024  "ARGUMENTS:\n"
19025  "\n"
19026  " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
19027  " of FCI. \n"
19028  "\n"
19029  ""},
19030  { (char *)"plsfnam", _wrap_plsfnam, METH_VARARGS, (char *)"\n"
19031  "Set output file name \n"
19032  "\n"
19033  "DESCRIPTION:\n"
19034  "\n"
19035  " Sets the current output file name, if applicable. If the file name\n"
19036  " has not been specified and is required by the driver, the user will be\n"
19037  " prompted for it. If using the X-windows output driver, this sets the\n"
19038  " display name. This routine, if used, must be called before\n"
19039  " initializing PLplot. \n"
19040  "\n"
19041  " Redacted form: plsfnam(fnam)\n"
19042  "\n"
19043  " This function is used in examples 1,20. \n"
19044  "\n"
19045  "\n"
19046  "\n"
19047  "SYNOPSIS:\n"
19048  "\n"
19049  "plsfnam(fnam)\n"
19050  "\n"
19051  "ARGUMENTS:\n"
19052  "\n"
19053  " fnam (const char *, input) : Pointer to file name string. \n"
19054  "\n"
19055  ""},
19056  { (char *)"plsfont", _wrap_plsfont, METH_VARARGS, (char *)"\n"
19057  "Set family, style and weight of the current font \n"
19058  "\n"
19059  "DESCRIPTION:\n"
19060  "\n"
19061  " Sets the current font. See the PLplot documentation for more\n"
19062  " information on font selection. \n"
19063  "\n"
19064  " Redacted form: plsfont(family, style, weight)\n"
19065  "\n"
19066  " This function is used in example 23. \n"
19067  "\n"
19068  "\n"
19069  "\n"
19070  "SYNOPSIS:\n"
19071  "\n"
19072  "plsfont(family, style, weight)\n"
19073  "\n"
19074  "ARGUMENTS:\n"
19075  "\n"
19076  " family (PLINT, input) : Font family to select for the current font.\n"
19077  " The available values are given by the PL_FCI_* constants in\n"
19078  " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF, \n"
19079  " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
19080  " signifies that the font family should not be altered. \n"
19081  "\n"
19082  " style (PLINT, input) : Font style to select for the current font.\n"
19083  " The available values are given by the PL_FCI_* constants in\n"
19084  " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
19085  " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
19086  " should not be altered. \n"
19087  "\n"
19088  " weight (PLINT, input) : Font weight to select for the current font.\n"
19089  " The available values are given by the PL_FCI_* constants in\n"
19090  " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
19091  " negative value signifies that the font weight should not be\n"
19092  " altered. \n"
19093  "\n"
19094  ""},
19095  { (char *)"plshades", _wrap_plshades, METH_VARARGS, (char *)"\n"
19096  "Shade regions on the basis of value \n"
19097  "\n"
19098  "DESCRIPTION:\n"
19099  "\n"
19100  " Shade regions on the basis of value. This is the high-level routine\n"
19101  " for making continuous color shaded plots with cmap1 while plshade (or\n"
19102  " plshade1) are used for individual shaded regions using either cmap0 or\n"
19103  " cmap1. examples/c/x16c.c shows a number of examples for using this\n"
19104  " function. See the following discussion of the arguments and the PLplot\n"
19105  " documentation for more information. \n"
19106  "\n"
19107  " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
19108  " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
19109  " pltr_data)\n"
19110  " Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n"
19111  " fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n"
19112  " pltr_data)\n"
19113  "\n"
19114  "\n"
19115  " This function is used in examples 16,21. \n"
19116  "\n"
19117  "\n"
19118  "\n"
19119  "SYNOPSIS:\n"
19120  "\n"
19121  "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
19122  "\n"
19123  "ARGUMENTS:\n"
19124  "\n"
19125  " a (PLFLT **, input) : Contains ** pointer to array to be plotted.\n"
19126  " The array must have been declared as PLFLT a[nx][ny]. \n"
19127  "\n"
19128  " nx (PLINT, input) : First dimension of array \"a\". \n"
19129  "\n"
19130  " ny (PLINT, input) : Second dimension of array \"a\". \n"
19131  "\n"
19132  " defined (PLINT (*) (PLFLT, PLFLT), input) : User function\n"
19133  " specifying regions excluded from the shading plot. This function\n"
19134  " accepts x and y coordinates as input arguments and must return 0\n"
19135  " if the point is in the excluded region or 1 otherwise. This\n"
19136  " argument can be NULL if all the values are valid. \n"
19137  "\n"
19138  " xmin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19139  " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19140  " at (xmax,ymin) and so on. \n"
19141  "\n"
19142  " xmax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19143  " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19144  " at (xmax,ymin) and so on. \n"
19145  "\n"
19146  " ymin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19147  " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19148  " at (xmax,ymin) and so on. \n"
19149  "\n"
19150  " ymax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19151  " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19152  " at (xmax,ymin) and so on. \n"
19153  "\n"
19154  " clevel (PLFLT *, input) : Pointer to array containing the data\n"
19155  " levels corresponding to the edges of each shaded region that will\n"
19156  " be plotted by this function. To work properly the levels should\n"
19157  " be monotonic. \n"
19158  "\n"
19159  " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
19160  " of shade edge values in clevel). \n"
19161  "\n"
19162  " fill_width (PLFLT, input) : Defines line width used by the fill\n"
19163  " pattern. \n"
19164  "\n"
19165  " cont_color (PLINT, input) : Defines pen color used for contours\n"
19166  " defining edges of shaded regions. The pen color is only temporary\n"
19167  " set for the contour drawing. Set this value to zero or less if no\n"
19168  " shade edge contours are wanted. \n"
19169  "\n"
19170  " cont_width (PLFLT, input) : Defines line width used for contours\n"
19171  " defining edges of shaded regions. This value may not be honored\n"
19172  " by all drivers. The pen width is only temporary set for the\n"
19173  " contour drawing. Set this value to zero or less if no shade edge\n"
19174  " contours are wanted. \n"
19175  "\n"
19176  " fill (void (*) (PLINT, PLFLT *, PLFLT *), input) : Routine used to\n"
19177  " fill the region. Use plfill. Future version of PLplot may have\n"
19178  " other fill routines. \n"
19179  "\n"
19180  " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
19181  " map to rectangles after coordinate transformation with pltrl. \n"
19182  " Otherwise, set rectangular to false. If rectangular is set to\n"
19183  " true, plshade tries to save time by filling large rectangles. \n"
19184  " This optimization fails if the coordinate transformation distorts\n"
19185  " the shape of rectangles. For example a plot in polar coordinates\n"
19186  " has to have rectangular set to false. \n"
19187  "\n"
19188  " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
19189  " Pointer to function that defines transformation between indices\n"
19190  " in array z and the world coordinates (C only). Transformation\n"
19191  " functions are provided in the PLplot library: pltr0 for identity\n"
19192  " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
19193  " defined by one- and two-dimensional arrays. In addition,\n"
19194  " user-supplied routines for the transformation can be used as well.\n"
19195  " Examples of all of these approaches are given in the PLplot\n"
19196  " documentation. The transformation function should have the form\n"
19197  " given by any of pltr0, pltr1, or pltr2. \n"
19198  "\n"
19199  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
19200  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
19201  " externally supplied. \n"
19202  "\n"
19203  ""},
19204  { (char *)"plshade", _wrap_plshade, METH_VARARGS, (char *)"\n"
19205  "Shade individual region on the basis of value \n"
19206  "\n"
19207  "ESCRIPTION:\n"
19208  "\n"
19209  " Shade individual region on the basis of value. Use plshades if you\n"
19210  " want to shade a number of regions using continuous colors. plshade is\n"
19211  " identical to plshade1 except for the type of the first parameter. See\n"
19212  " plshade1 for further discussion. \n"
19213  "\n"
19214  " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
19215  " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
19216  " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
19217  " Perl/PDL: Not available? \n"
19218  "\n"
19219  "\n"
19220  " This function is used in example 15. \n"
19221  "\n"
19222  "\n"
19223  "\n"
19224  "YNOPSIS:\n"
19225  "\n"
19226  "lshade(a, nx, ny, defined, xmin, xmax, ymin, ymax, shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color, min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
19227  "\n"
19228  "RGUMENTS:\n"
19229  "\n"
19230  " a (PLFLT **, input) : \n"
19231  "\n"
19232  " nx (PLINT, input) : \n"
19233  "\n"
19234  " ny (PLINT, input) : \n"
19235  "\n"
19236  " defined (PLINT (*) (PLFLT, PLFLT), input) : \n"
19237  "\n"
19238  " xmin (PLFLT, input) : \n"
19239  "\n"
19240  " xmax (PLFLT, input) : \n"
19241  "\n"
19242  " ymin (PLFLT, input) : \n"
19243  "\n"
19244  " ymax (PLFLT, input) : \n"
19245  "\n"
19246  " shade_min (PLFLT, input) : \n"
19247  "\n"
19248  " shade_max (PLFLT, input) : \n"
19249  "\n"
19250  " sh_cmap (PLINT, input) : \n"
19251  "\n"
19252  " sh_color (PLFLT, input) : \n"
19253  "\n"
19254  " sh_width (PLFLT, input) : \n"
19255  "\n"
19256  " min_color (PLINT, input) : \n"
19257  "\n"
19258  " min_width (PLFLT, input) : \n"
19259  "\n"
19260  " max_color (PLINT, input) : \n"
19261  "\n"
19262  " max_width (PLFLT, input) : \n"
19263  "\n"
19264  " fill (void (*) (PLINT, PLFLT *, PLFLT *), input) : \n"
19265  "\n"
19266  " rectangular (PLBOOL, input) : \n"
19267  "\n"
19268  " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
19269  "\n"
19270  " pltr_data (PLPointer, input) : \n"
19271  "\n"
19272  ""},
19273  { (char *)"plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, (char *)"\n"
19274  "Assign a function to use for generating custom axis labels \n"
19275  "\n"
19276  "DESCRIPTION:\n"
19277  "\n"
19278  " This function allows a user to provide their own function to provide\n"
19279  " axis label text. The user function is given the numeric value for a\n"
19280  " point on an axis and returns a string label to correspond with that\n"
19281  " value. Custom axis labels can be enabled by passing appropriate\n"
19282  " arguments to plenv, plbox, plbox3 and similar functions. \n"
19283  "\n"
19284  " This function is used in example 19. \n"
19285  "\n"
19286  "\n"
19287  "\n"
19288  "SYNOPSIS:\n"
19289  "\n"
19290  "plslabelfunc(label_func, label_data)\n"
19291  "\n"
19292  "ARGUMENTS:\n"
19293  "\n"
19294  " label_func (void (*) (PLINT, PLFLT, char *, PLINT, void *), input) : \n"
19295  " This is the custom label function. In order to reset to the\n"
19296  " default labeling, set this to NULL. The labeling function\n"
19297  " parameters are, in order: axis: This indicates which axis a\n"
19298  " label is being requested for. The value will be one of PL_X_AXIS,\n"
19299  " PL_Y_AXIS or PL_Z_AXIS. \n"
19300  "\n"
19301  " value: This is the value along the axis which is being labeled. \n"
19302  "\n"
19303  " label_text: The string representation of the label value. \n"
19304  "\n"
19305  " length: The maximum length in characters allowed for label_text. \n"
19306  "\n"
19307  "\n"
19308  " label_data (void *, input) : This parameter may be used to pass\n"
19309  " data to the label_func function. \n"
19310  "\n"
19311  ""},
19312  { (char *)"plsmaj", _wrap_plsmaj, METH_VARARGS, (char *)"\n"
19313  "Set length of major ticks \n"
19314  "\n"
19315  "DESCRIPTION:\n"
19316  "\n"
19317  " This sets up the length of the major ticks. The actual length is the\n"
19318  " product of the default length and a scaling factor as for character\n"
19319  " height. \n"
19320  "\n"
19321  " Redacted form: plsmaj(def, scale)\n"
19322  "\n"
19323  " This function is used in example 29. \n"
19324  "\n"
19325  "\n"
19326  "\n"
19327  "SYNOPSIS:\n"
19328  "\n"
19329  "plsmaj(def, scale)\n"
19330  "\n"
19331  "ARGUMENTS:\n"
19332  "\n"
19333  " def (PLFLT, input) : The default length of a major tick in\n"
19334  " millimeters, should be set to zero if the default length is to\n"
19335  " remain unchanged. \n"
19336  "\n"
19337  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19338  " actual tick length. \n"
19339  "\n"
19340  ""},
19341  { (char *)"plsmem", _wrap_plsmem, METH_VARARGS, (char *)"\n"
19342  "Set the memory area to be plotted (RGB) \n"
19343  "\n"
19344  "DESCRIPTION:\n"
19345  "\n"
19346  " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
19347  " the dev member of the stream structure. Also set the number of pixels\n"
19348  " in the memory passed in \n"
19349  " plotmem, which is a block of memory \n"
19350  " maxy by \n"
19351  " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB) \n"
19352  "\n"
19353  " This memory will have to be freed by the user! \n"
19354  "\n"
19355  " Redacted form: plsmem(maxx, maxy, plotmem)\n"
19356  "\n"
19357  " This function is not used in any examples. \n"
19358  "\n"
19359  "\n"
19360  "\n"
19361  "SYNOPSIS:\n"
19362  "\n"
19363  "plsmem(maxx, maxy, plotmem)\n"
19364  "\n"
19365  "ARGUMENTS:\n"
19366  "\n"
19367  " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
19368  "\n"
19369  " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
19370  "\n"
19371  " plotmem (void *, input) : Pointer to the beginning of the\n"
19372  " user-supplied memory area. \n"
19373  "\n"
19374  ""},
19375  { (char *)"plsmema", _wrap_plsmema, METH_VARARGS, (char *)"\n"
19376  "Set the memory area to be plotted (RGBA) \n"
19377  "\n"
19378  "DESCRIPTION:\n"
19379  "\n"
19380  " Set the memory area to be plotted (with the memcairo driver) as the\n"
19381  " dev member of the stream structure. Also set the number of pixels in\n"
19382  " the memory passed in \n"
19383  " plotmem, which is a block of memory \n"
19384  " maxy by \n"
19385  " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA) \n"
19386  "\n"
19387  " This memory will have to be freed by the user! \n"
19388  "\n"
19389  " Redacted form: plsmema(maxx, maxy, plotmem)\n"
19390  "\n"
19391  " This function is not used in any examples. \n"
19392  "\n"
19393  "\n"
19394  "\n"
19395  "SYNOPSIS:\n"
19396  "\n"
19397  "plsmema(maxx, maxy, plotmem)\n"
19398  "\n"
19399  "ARGUMENTS:\n"
19400  "\n"
19401  " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
19402  "\n"
19403  " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
19404  "\n"
19405  " plotmem (void *, input) : Pointer to the beginning of the\n"
19406  " user-supplied memory area. \n"
19407  "\n"
19408  ""},
19409  { (char *)"plsmin", _wrap_plsmin, METH_VARARGS, (char *)"\n"
19410  "Set length of minor ticks \n"
19411  "\n"
19412  "DESCRIPTION:\n"
19413  "\n"
19414  " This sets up the length of the minor ticks and the length of the\n"
19415  " terminals on error bars. The actual length is the product of the\n"
19416  " default length and a scaling factor as for character height. \n"
19417  "\n"
19418  " Redacted form: plsmin(def, scale)\n"
19419  "\n"
19420  " This function is used in example 29. \n"
19421  "\n"
19422  "\n"
19423  "\n"
19424  "SYNOPSIS:\n"
19425  "\n"
19426  "plsmin(def, scale)\n"
19427  "\n"
19428  "ARGUMENTS:\n"
19429  "\n"
19430  " def (PLFLT, input) : The default length of a minor tick in\n"
19431  " millimeters, should be set to zero if the default length is to\n"
19432  " remain unchanged. \n"
19433  "\n"
19434  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19435  " actual tick length. \n"
19436  "\n"
19437  ""},
19438  { (char *)"plsori", _wrap_plsori, METH_VARARGS, (char *)"\n"
19439  "Set orientation \n"
19440  "\n"
19441  "DESCRIPTION:\n"
19442  "\n"
19443  " Set integer plot orientation parameter. This function is identical to\n"
19444  " plsdiori except for the type of the argument, and should be used in\n"
19445  " the same way. See the PLplot documentation for details. \n"
19446  "\n"
19447  " Redacted form: plsori(ori)\n"
19448  "\n"
19449  " This function is used in example 3. \n"
19450  "\n"
19451  "\n"
19452  "\n"
19453  "SYNOPSIS:\n"
19454  "\n"
19455  "plsori(ori)\n"
19456  "\n"
19457  "ARGUMENTS:\n"
19458  "\n"
19459  " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
19460  " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
19461  " angle. \n"
19462  "\n"
19463  ""},
19464  { (char *)"plspage", _wrap_plspage, METH_VARARGS, (char *)"\n"
19465  "Set page parameters \n"
19466  "\n"
19467  "DESCRIPTION:\n"
19468  "\n"
19469  " Sets the page configuration (optional). If an individual parameter is\n"
19470  " zero then that parameter value is not updated. Not all parameters are\n"
19471  " recognized by all drivers and the interpretation is device-dependent.\n"
19472  " The X-window driver uses the length and offset parameters to determine\n"
19473  " the window size and location. The length and offset values are\n"
19474  " expressed in units that are specific to the current driver. For\n"
19475  " instance: screen drivers will usually interpret them as number of\n"
19476  " pixels, whereas printer drivers will usually use mm. This routine, if\n"
19477  " used, must be called before initializing PLplot. \n"
19478  "\n"
19479  " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
19480  "\n"
19481  " This function is used in examples 14 and 31. \n"
19482  "\n"
19483  "\n"
19484  "\n"
19485  "SYNOPSIS:\n"
19486  "\n"
19487  "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
19488  "\n"
19489  "ARGUMENTS:\n"
19490  "\n"
19491  " xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n"
19492  "\n"
19493  " yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n"
19494  "\n"
19495  " xleng (PLINT , input) : Page length, x. \n"
19496  "\n"
19497  " yleng (PLINT, input) : Page length, y. \n"
19498  "\n"
19499  " xoff (PLINT, input) : Page offset, x. \n"
19500  "\n"
19501  " yoff (PLINT, input) : Page offset, y. \n"
19502  "\n"
19503  ""},
19504  { (char *)"plspal0", _wrap_plspal0, METH_VARARGS, (char *)"\n"
19505  "Set the colors for color table 0 from a cmap0 file \n"
19506  "\n"
19507  "DESCRIPTION:\n"
19508  "\n"
19509  " Set the colors for color table 0 from a cmap0 file \n"
19510  "\n"
19511  " Redacted form: plspal0(filename)\n"
19512  "\n"
19513  " This function is in example 16. \n"
19514  "\n"
19515  "\n"
19516  "\n"
19517  "SYNOPSIS:\n"
19518  "\n"
19519  "plspal0(filename)\n"
19520  "\n"
19521  "ARGUMENTS:\n"
19522  "\n"
19523  " filename (const char *, input) : The name of the cmap0 file, or a\n"
19524  " empty to string to specify the default cmap0 file. \n"
19525  "\n"
19526  ""},
19527  { (char *)"plspal1", _wrap_plspal1, METH_VARARGS, (char *)"\n"
19528  "Set the colors for color table 1 from a cmap1 file \n"
19529  "\n"
19530  "DESCRIPTION:\n"
19531  "\n"
19532  " Set the colors for color table 1 from a cmap1 file \n"
19533  "\n"
19534  " Redacted form: plspal1(filename)\n"
19535  "\n"
19536  " This function is in example 16. \n"
19537  "\n"
19538  "\n"
19539  "\n"
19540  "SYNOPSIS:\n"
19541  "\n"
19542  "plspal1(filename)\n"
19543  "\n"
19544  "ARGUMENTS:\n"
19545  "\n"
19546  " filename (const char *, input) : The name of the cmap1 file, or a\n"
19547  " empty to string to specify the default cmap1 file. \n"
19548  "\n"
19549  ""},
19550  { (char *)"plspause", _wrap_plspause, METH_VARARGS, (char *)"\n"
19551  "Set the pause (on end-of-page) status \n"
19552  "\n"
19553  "DESCRIPTION:\n"
19554  "\n"
19555  " Set the pause (on end-of-page) status. \n"
19556  "\n"
19557  " Redacted form: plspause(pause)\n"
19558  "\n"
19559  " This function is in examples 14,20. \n"
19560  "\n"
19561  "\n"
19562  "\n"
19563  "SYNOPSIS:\n"
19564  "\n"
19565  "plspause(pause)\n"
19566  "\n"
19567  "ARGUMENTS:\n"
19568  "\n"
19569  " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
19570  " end-of-page for those drivers which support this. Otherwise there\n"
19571  " is no pause. \n"
19572  "\n"
19573  ""},
19574  { (char *)"plsstrm", _wrap_plsstrm, METH_VARARGS, (char *)"\n"
19575  "Set current output stream \n"
19576  "\n"
19577  "DESCRIPTION:\n"
19578  "\n"
19579  " Sets the number of the current output stream. The stream number\n"
19580  " defaults to 0 unless changed by this routine. The first use of this\n"
19581  " routine must be followed by a call initializing PLplot (e.g. plstar). \n"
19582  "\n"
19583  " Redacted form: plsstrm(strm)\n"
19584  "\n"
19585  " This function is examples 1,14,20. \n"
19586  "\n"
19587  "\n"
19588  "\n"
19589  "SYNOPSIS:\n"
19590  "\n"
19591  "plsstrm(strm)\n"
19592  "\n"
19593  "ARGUMENTS:\n"
19594  "\n"
19595  " strm (PLINT, input) : The current stream number. \n"
19596  "\n"
19597  ""},
19598  { (char *)"plssub", _wrap_plssub, METH_VARARGS, (char *)"\n"
19599  "Set the number of subpages in x and y \n"
19600  "\n"
19601  "DESCRIPTION:\n"
19602  "\n"
19603  " Set the number of subpages in x and y. \n"
19604  "\n"
19605  " Redacted form: plssub(nx, ny)\n"
19606  "\n"
19607  " This function is examples 1,2,14,21,25,27. \n"
19608  "\n"
19609  "\n"
19610  "\n"
19611  "SYNOPSIS:\n"
19612  "\n"
19613  "plssub(nx, ny)\n"
19614  "\n"
19615  "ARGUMENTS:\n"
19616  "\n"
19617  " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
19618  " of window columns). \n"
19619  "\n"
19620  " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
19621  " of window rows). \n"
19622  "\n"
19623  ""},
19624  { (char *)"plssym", _wrap_plssym, METH_VARARGS, (char *)"\n"
19625  "Set symbol size \n"
19626  "\n"
19627  "DESCRIPTION:\n"
19628  "\n"
19629  " This sets up the size of all subsequent symbols drawn by plpoin and\n"
19630  " plsym. The actual height of a symbol is the product of the default\n"
19631  " symbol size and a scaling factor as for the character height. \n"
19632  "\n"
19633  " Redacted form: plssym(def, scale)\n"
19634  "\n"
19635  " This function is used in example 29. \n"
19636  "\n"
19637  "\n"
19638  "\n"
19639  "SYNOPSIS:\n"
19640  "\n"
19641  "plssym(def, scale)\n"
19642  "\n"
19643  "ARGUMENTS:\n"
19644  "\n"
19645  " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
19646  " should be set to zero if the default height is to remain\n"
19647  " unchanged. \n"
19648  "\n"
19649  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19650  " actual symbol height. \n"
19651  "\n"
19652  ""},
19653  { (char *)"plstar", _wrap_plstar, METH_VARARGS, (char *)"\n"
19654  "Initialization \n"
19655  "\n"
19656  "DESCRIPTION:\n"
19657  "\n"
19658  " Initializing the plotting package. The program prompts for the device\n"
19659  " keyword or number of the desired output device. Hitting a RETURN in\n"
19660  " response to the prompt is the same as selecting the first device. If\n"
19661  " only one device is enabled when PLplot is installed, plstar will issue\n"
19662  " no prompt. The output device is divided into nx by ny subpages, each\n"
19663  " of which may be used independently. The subroutine pladv is used to\n"
19664  " advance from one subpage to the next. \n"
19665  "\n"
19666  " Redacted form: plstar(nx, ny)\n"
19667  "\n"
19668  " This function is used in example 1. \n"
19669  "\n"
19670  "\n"
19671  "\n"
19672  "SYNOPSIS:\n"
19673  "\n"
19674  "plstar(nx, ny)\n"
19675  "\n"
19676  "ARGUMENTS:\n"
19677  "\n"
19678  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
19679  " horizontal direction. \n"
19680  "\n"
19681  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
19682  " vertical direction. \n"
19683  "\n"
19684  ""},
19685  { (char *)"plstart", _wrap_plstart, METH_VARARGS, (char *)"\n"
19686  "Initialization \n"
19687  "\n"
19688  "DESCRIPTION:\n"
19689  "\n"
19690  " Alternative to plstar for initializing the plotting package. The\n"
19691  " device name keyword for the desired output device must be supplied as\n"
19692  " an argument. The device keywords are the same as those printed out by\n"
19693  " plstar. If the requested device is not available, or if the input\n"
19694  " string is empty or begins with ``?'', the prompted startup of plstar\n"
19695  " is used. This routine also divides the output device into nx by ny\n"
19696  " subpages, each of which may be used independently. The subroutine\n"
19697  " pladv is used to advance from one subpage to the next. \n"
19698  "\n"
19699  " Redacted form: General: plstart(device, nx, ny)\n"
19700  " Perl/PDL: plstart(nx, ny, device)\n"
19701  "\n"
19702  "\n"
19703  " This function is not used in any examples. \n"
19704  "\n"
19705  "\n"
19706  "\n"
19707  "SYNOPSIS:\n"
19708  "\n"
19709  "plstart(device, nx, ny)\n"
19710  "\n"
19711  "ARGUMENTS:\n"
19712  "\n"
19713  " device (const char *, input) : Device name (keyword) of the\n"
19714  " required output device. If NULL or if the first character is a\n"
19715  " ``?'', the normal (prompted) startup is used. \n"
19716  "\n"
19717  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
19718  " horizontal direction. \n"
19719  "\n"
19720  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
19721  " vertical direction. \n"
19722  "\n"
19723  ""},
19724  { (char *)"plstransform", _wrap_plstransform, METH_VARARGS, (char *)"\n"
19725  "Set a global coordinate transform function \n"
19726  "\n"
19727  "DESCRIPTION:\n"
19728  "\n"
19729  " This function can be used to define a coordinate transformation which\n"
19730  " affects all elements drawn within the current plot window. The\n"
19731  " transformation function is similar to that provided for the plmap and\n"
19732  " plmeridians functions. The data parameter may be used to pass extra\n"
19733  " data to transform_fun. \n"
19734  "\n"
19735  " Redacted form: General: plstransform(transform_fun, data)\n"
19736  "\n"
19737  "\n"
19738  " This function is used in example 19. \n"
19739  "\n"
19740  "\n"
19741  "\n"
19742  "SYNOPSIS:\n"
19743  "\n"
19744  "plstransform(transform_fun, data)\n"
19745  "\n"
19746  "ARGUMENTS:\n"
19747  "\n"
19748  " transform_fun (void (*) (PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer) ,\n"
19749  " input) : Pointer to a function that defines a transformation\n"
19750  " from the input (x, y) coordinate to a new plot world coordiante. \n"
19751  "\n"
19752  " data (PLPointer, input) : Optional extra data for \n"
19753  " transform_fun. \n"
19754  "\n"
19755  ""},
19756  { (char *)"plstring", _wrap_plstring, METH_VARARGS, (char *)"\n"
19757  "Plot a glyph at the specified points \n"
19758  "\n"
19759  "DESCRIPTION:\n"
19760  "\n"
19761  " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
19762  " because many[!] more glyphs are accessible with plstring.) The glyph\n"
19763  " is specified with a PLplot user string. Note that the user string is\n"
19764  " not actually limited to one glyph so it is possible (but not normally\n"
19765  " useful) to plot more than one glyph at the specified points with this\n"
19766  " function. As with plmtex and plptex, the user string can contain FCI\n"
19767  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
19768  " else PLplot escapes for Hershey or unicode text to determine the\n"
19769  " glyph. \n"
19770  "\n"
19771  " Redacted form: plstring(x, y, string)\n"
19772  "\n"
19773  " This function is used in examples 4, 21 and 26. \n"
19774  "\n"
19775  "\n"
19776  "\n"
19777  "SYNOPSIS:\n"
19778  "\n"
19779  "plstring(n, x, y, string)\n"
19780  "\n"
19781  "ARGUMENTS:\n"
19782  "\n"
19783  " n (PLINT, input) : Number of points in the x and y arrays. \n"
19784  "\n"
19785  " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
19786  " points. \n"
19787  "\n"
19788  " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
19789  " points. \n"
19790  "\n"
19791  " string (const char *, input) : PLplot user string corresponding to\n"
19792  " the glyph to be plotted at each of the n points. \n"
19793  "\n"
19794  ""},
19795  { (char *)"plstring3", _wrap_plstring3, METH_VARARGS, (char *)"\n"
19796  "Plot a glyph at the specified 3D points \n"
19797  "\n"
19798  "DESCRIPTION:\n"
19799  "\n"
19800  " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
19801  " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
19802  " this function similar to what is done for plline3. The glyph is\n"
19803  " specified with a PLplot user string. Note that the user string is not\n"
19804  " actually limited to one glyph so it is possible (but not normally\n"
19805  " useful) to plot more than one glyph at the specified points with this\n"
19806  " function. As with plmtex and plptex, the user string can contain FCI\n"
19807  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
19808  " else PLplot escapes for Hershey or unicode text to determine the\n"
19809  " glyph. \n"
19810  "\n"
19811  " Redacted form: plstring3(x, y, z, string)\n"
19812  "\n"
19813  " This function is used in example 18. \n"
19814  "\n"
19815  "\n"
19816  "\n"
19817  "SYNOPSIS:\n"
19818  "\n"
19819  "plstring3(n, x, y, z, string)\n"
19820  "\n"
19821  "ARGUMENTS:\n"
19822  "\n"
19823  " n (PLINT, input) : Number of points in the x, y, and z arrays. \n"
19824  "\n"
19825  " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
19826  " points. \n"
19827  "\n"
19828  " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
19829  " points. \n"
19830  "\n"
19831  " z (PLFLT *, input) : Pointer to an array with Z coordinates of\n"
19832  " points. \n"
19833  "\n"
19834  " string (const char *, input) : PLplot user string corresponding to\n"
19835  " the glyph to be plotted at each of the n points. \n"
19836  "\n"
19837  ""},
19838  { (char *)"plstripa", _wrap_plstripa, METH_VARARGS, (char *)"\n"
19839  "Add a point to a stripchart \n"
19840  "\n"
19841  "DESCRIPTION:\n"
19842  "\n"
19843  " Add a point to a given pen of a given stripchart. There is no need for\n"
19844  " all pens to have the same number of points or to be equally sampled in\n"
19845  " the x coordinate. Allocates memory and rescales as necessary. \n"
19846  "\n"
19847  " Redacted form: plstripa(id, p, x, y)\n"
19848  "\n"
19849  " This function is used in example 17. \n"
19850  "\n"
19851  "\n"
19852  "\n"
19853  "SYNOPSIS:\n"
19854  "\n"
19855  "plstripa(id, p, x, y)\n"
19856  "\n"
19857  "ARGUMENTS:\n"
19858  "\n"
19859  " id (PLINT, input) : Identification number (set up in plstripc) of\n"
19860  " the stripchart. \n"
19861  "\n"
19862  " p (PLINT, input) : Pen number (ranges from 0 to 3). \n"
19863  "\n"
19864  " x (PLFLT, input) : X coordinate of point to plot. \n"
19865  "\n"
19866  " y (PLFLT, input) : Y coordinate of point to plot. \n"
19867  "\n"
19868  ""},
19869  { (char *)"plstripc", _wrap_plstripc, METH_VARARGS, (char *)"\n"
19870  "Create a 4-pen stripchart \n"
19871  "\n"
19872  "DESCRIPTION:\n"
19873  "\n"
19874  " Create a 4-pen stripchart, to be used afterwards by plstripa\n"
19875  "\n"
19876  " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
19877  " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
19878  " styline, legline, labx, laby, labz)\n"
19879  " Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n"
19880  " ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n"
19881  " ypsec, legline, labx, laby, labtop)\n"
19882  "\n"
19883  "\n"
19884  " This function is used in example 17. \n"
19885  "\n"
19886  "\n"
19887  "\n"
19888  "SYNOPSIS:\n"
19889  "\n"
19890  "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
19891  "\n"
19892  "ARGUMENTS:\n"
19893  "\n"
19894  " id (PLINT *, output) : Identification number of stripchart to use\n"
19895  " on plstripa and plstripd. \n"
19896  "\n"
19897  " xspec (char *, input) : X-axis specification as in plbox. \n"
19898  "\n"
19899  " yspec (char *, input) : Y-axis specification as in plbox. \n"
19900  "\n"
19901  " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
19902  " change as data are added. \n"
19903  "\n"
19904  " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
19905  " change as data are added. \n"
19906  "\n"
19907  " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
19908  " is multiplied by the factor (1 + \n"
19909  " xjump). \n"
19910  "\n"
19911  " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
19912  " change as data are added. \n"
19913  "\n"
19914  " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
19915  " change as data are added. \n"
19916  "\n"
19917  " xlpos (PLFLT, input) : X legend box position (range from 0 to 1). \n"
19918  "\n"
19919  " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1). \n"
19920  "\n"
19921  " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
19922  " true, otherwise not. \n"
19923  "\n"
19924  " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
19925  " otherwise slide display. \n"
19926  "\n"
19927  " colbox (PLINT, input) : Plot box color index (cmap0). \n"
19928  "\n"
19929  " collab (PLINT, input) : Legend color index (cmap0). \n"
19930  "\n"
19931  " colline (PLINT *, input) : Pointer to array with color indices\n"
19932  " (cmap0) for the 4 pens. \n"
19933  "\n"
19934  " styline (PLINT *, input) : Pointer to array with line styles for\n"
19935  " the 4 pens. \n"
19936  "\n"
19937  " legline (char **, input) : Pointer to character array containing\n"
19938  " legends for the 4 pens. \n"
19939  "\n"
19940  " labx (char *, input) : X-axis label. \n"
19941  "\n"
19942  " laby (char *, input) : Y-axis label. \n"
19943  "\n"
19944  " labtop (char *, input) : Plot title. \n"
19945  "\n"
19946  ""},
19947  { (char *)"plstripd", _wrap_plstripd, METH_VARARGS, (char *)"\n"
19948  "Deletes and releases memory used by a stripchart \n"
19949  "\n"
19950  "DESCRIPTION:\n"
19951  "\n"
19952  " Deletes and releases memory used by a stripchart. \n"
19953  "\n"
19954  " Redacted form: plstripd(id)\n"
19955  "\n"
19956  " This function is used in example 17. \n"
19957  "\n"
19958  "\n"
19959  "\n"
19960  "SYNOPSIS:\n"
19961  "\n"
19962  "plstripd(id)\n"
19963  "\n"
19964  "ARGUMENTS:\n"
19965  "\n"
19966  " id (PLINT, input) : Identification number of stripchart to delete. \n"
19967  "\n"
19968  ""},
19969  { (char *)"plstyl", _wrap_plstyl, METH_VARARGS, (char *)"\n"
19970  "Set line style \n"
19971  "\n"
19972  "DESCRIPTION:\n"
19973  "\n"
19974  " This sets up the line style for all lines subsequently drawn. A line\n"
19975  " consists of segments in which the pen is alternately down and up. The\n"
19976  " lengths of these segments are passed in the arrays mark and space\n"
19977  " respectively. The number of mark-space pairs is specified by nels. \n"
19978  " In order to return the line style to the default continuous line,\n"
19979  " plstyl should be called with nels=0.(see also pllsty) \n"
19980  "\n"
19981  " Redacted form: plstyl(mark, space)\n"
19982  "\n"
19983  " This function is used in examples 1,9,14. \n"
19984  "\n"
19985  "\n"
19986  "\n"
19987  "SYNOPSIS:\n"
19988  "\n"
19989  "plstyl(nels, mark, space)\n"
19990  "\n"
19991  "ARGUMENTS:\n"
19992  "\n"
19993  " nels (PLINT, input) : The number of mark and space elements in a\n"
19994  " line. Thus a simple broken line can be obtained by setting\n"
19995  " nels=1. A continuous line is specified by setting nels=0. \n"
19996  "\n"
19997  " mark (PLINT *, input) : Pointer to array with the lengths of the\n"
19998  " segments during which the pen is down, measured in micrometers. \n"
19999  "\n"
20000  " space (PLINT *, input) : Pointer to array with the lengths of the\n"
20001  " segments during which the pen is up, measured in micrometers. \n"
20002  "\n"
20003  ""},
20004  { (char *)"plsvect", _wrap_plsvect, METH_VARARGS, (char *)"\n"
20005  "Set arrow style for vector plots \n"
20006  "\n"
20007  "DESCRIPTION:\n"
20008  "\n"
20009  " Set the style for the arrow used by plvect to plot vectors. \n"
20010  "\n"
20011  " Redacted form: plsvect(arrowx, arrowy, fill)\n"
20012  "\n"
20013  " This function is used in example 22. \n"
20014  "\n"
20015  "\n"
20016  "\n"
20017  "SYNOPSIS:\n"
20018  "\n"
20019  "plsvect(arrowx, arrowy, npts, fill)\n"
20020  "\n"
20021  "ARGUMENTS:\n"
20022  "\n"
20023  " arrowx, arrowy (PLFLT *,input) : Pointers to a pair of arrays\n"
20024  " containing the x and y points which make up the arrow. The arrow\n"
20025  " is plotted by joining these points to form a polygon. The scaling\n"
20026  " assumes that the x and y points in the arrow lie in the range -0.5\n"
20027  " <= x,y <= 0.5. \n"
20028  "\n"
20029  " npts (PLINT,input) : Number of points in the arrays arrowx and\n"
20030  " arrowy. \n"
20031  "\n"
20032  " fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n"
20033  " fill is false then the arrow is open. \n"
20034  "\n"
20035  ""},
20036  { (char *)"plsvpa", _wrap_plsvpa, METH_VARARGS, (char *)"\n"
20037  "Specify viewport in absolute coordinates \n"
20038  "\n"
20039  "DESCRIPTION:\n"
20040  "\n"
20041  " Alternate routine to plvpor for setting up the viewport. This routine\n"
20042  " should be used only if the viewport is required to have a definite\n"
20043  " size in millimeters. The routine plgspa is useful for finding out the\n"
20044  " size of the current subpage. \n"
20045  "\n"
20046  " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
20047  "\n"
20048  " This function is used in example 10. \n"
20049  "\n"
20050  "\n"
20051  "\n"
20052  "SYNOPSIS:\n"
20053  "\n"
20054  "plsvpa(xmin, xmax, ymin, ymax)\n"
20055  "\n"
20056  "ARGUMENTS:\n"
20057  "\n"
20058  " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
20059  " viewport from the left-hand edge of the subpage in millimeters. \n"
20060  "\n"
20061  " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
20062  " viewport from the left-hand edge of the subpage in millimeters. \n"
20063  "\n"
20064  " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
20065  " viewport from the bottom edge of the subpage in millimeters. \n"
20066  "\n"
20067  " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
20068  " from the bottom edge of the subpage in millimeters. \n"
20069  "\n"
20070  ""},
20071  { (char *)"plsxax", _wrap_plsxax, METH_VARARGS, (char *)"\n"
20072  "Set x axis parameters \n"
20073  "\n"
20074  "DESCRIPTION:\n"
20075  "\n"
20076  " Sets values of the digmax and digits flags for the x axis. See the\n"
20077  " PLplot documentation for more information. \n"
20078  "\n"
20079  " Redacted form: plsxax(digmax, digits)\n"
20080  "\n"
20081  " This function is used in example 31. \n"
20082  "\n"
20083  "\n"
20084  "\n"
20085  "SYNOPSIS:\n"
20086  "\n"
20087  "plsxax(digmax, digits)\n"
20088  "\n"
20089  "ARGUMENTS:\n"
20090  "\n"
20091  " digmax (PLINT, input) : Variable to set the maximum number of\n"
20092  " digits for the x axis. If nonzero, the printed label will be\n"
20093  " switched to a floating point representation when the number of\n"
20094  " digits exceeds digmax. \n"
20095  "\n"
20096  " digits (PLINT, input) : Field digits value. Currently, changing\n"
20097  " its value here has no effect since it is set only by plbox or\n"
20098  " plbox3. However, the user may obtain its value after a call to\n"
20099  " either of these functions by calling plgxax. \n"
20100  "\n"
20101  ""},
20102  { (char *)"plsyax", _wrap_plsyax, METH_VARARGS, (char *)"\n"
20103  "Set y axis parameters \n"
20104  "\n"
20105  "DESCRIPTION:\n"
20106  "\n"
20107  " Identical to plsxax, except that arguments are flags for y axis. See\n"
20108  " the description of plsxax for more detail. \n"
20109  "\n"
20110  " Redacted form: plsyax(digmax, digits)\n"
20111  "\n"
20112  " This function is used in examples 1,14,31. \n"
20113  "\n"
20114  "\n"
20115  "\n"
20116  "SYNOPSIS:\n"
20117  "\n"
20118  "plsyax(digmax, digits)\n"
20119  "\n"
20120  "ARGUMENTS:\n"
20121  "\n"
20122  " digmax (PLINT, input) : Variable to set the maximum number of\n"
20123  " digits for the y axis. If nonzero, the printed label will be\n"
20124  " switched to a floating point representation when the number of\n"
20125  " digits exceeds digmax. \n"
20126  "\n"
20127  " digits (PLINT, input) : Field digits value. Currently, changing\n"
20128  " its value here has no effect since it is set only by plbox or\n"
20129  " plbox3. However, the user may obtain its value after a call to\n"
20130  " either of these functions by calling plgyax. \n"
20131  "\n"
20132  ""},
20133  { (char *)"plsym", _wrap_plsym, METH_VARARGS, (char *)"\n"
20134  "Plot a glyph at the specified points \n"
20135  "\n"
20136  "DESCRIPTION:\n"
20137  "\n"
20138  " Plot a glyph at the specified points. (This function is largely\n"
20139  " superseded by plstring which gives access to many[!] more glyphs.) \n"
20140  "\n"
20141  " Redacted form: plsym(x, y, code)\n"
20142  "\n"
20143  " This function is used in example 7. \n"
20144  "\n"
20145  "\n"
20146  "\n"
20147  "SYNOPSIS:\n"
20148  "\n"
20149  "plsym(n, x, y, code)\n"
20150  "\n"
20151  "ARGUMENTS:\n"
20152  "\n"
20153  " n (PLINT, input) : Number of points in the x and y arrays. \n"
20154  "\n"
20155  " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
20156  " points. \n"
20157  "\n"
20158  " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
20159  " points. \n"
20160  "\n"
20161  " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
20162  " to be plotted at each of the n points. \n"
20163  "\n"
20164  ""},
20165  { (char *)"plszax", _wrap_plszax, METH_VARARGS, (char *)"\n"
20166  "Set z axis parameters \n"
20167  "\n"
20168  "DESCRIPTION:\n"
20169  "\n"
20170  " Identical to plsxax, except that arguments are flags for z axis. See\n"
20171  " the description of plsxax for more detail. \n"
20172  "\n"
20173  " Redacted form: plszax(digmax, digits)\n"
20174  "\n"
20175  " This function is used in example 31. \n"
20176  "\n"
20177  "\n"
20178  "\n"
20179  "SYNOPSIS:\n"
20180  "\n"
20181  "plszax(digmax, digits)\n"
20182  "\n"
20183  "ARGUMENTS:\n"
20184  "\n"
20185  " digmax (PLINT, input) : Variable to set the maximum number of\n"
20186  " digits for the z axis. If nonzero, the printed label will be\n"
20187  " switched to a floating point representation when the number of\n"
20188  " digits exceeds digmax. \n"
20189  "\n"
20190  " digits (PLINT, input) : Field digits value. Currently, changing\n"
20191  " its value here has no effect since it is set only by plbox or\n"
20192  " plbox3. However, the user may obtain its value after a call to\n"
20193  " either of these functions by calling plgzax. \n"
20194  "\n"
20195  ""},
20196  { (char *)"pltext", _wrap_pltext, METH_VARARGS, (char *)"\n"
20197  "Switch to text screen \n"
20198  "\n"
20199  "DESCRIPTION:\n"
20200  "\n"
20201  " Sets an interactive device to text mode, used in conjunction with\n"
20202  " plgra to allow graphics and text to be interspersed. On a device\n"
20203  " which supports separate text and graphics windows, this command causes\n"
20204  " control to be switched to the text window. This can be useful for\n"
20205  " printing diagnostic messages or getting user input, which would\n"
20206  " otherwise interfere with the plots. The program must switch back to\n"
20207  " the graphics window before issuing plot commands, as the text (or\n"
20208  " console) device will probably become quite confused otherwise. If\n"
20209  " already in text mode, this command is ignored. It is also ignored on\n"
20210  " devices which only support a single window or use a different method\n"
20211  " for shifting focus (see also plgra). \n"
20212  "\n"
20213  " Redacted form: pltext()\n"
20214  "\n"
20215  " This function is used in example 1. \n"
20216  "\n"
20217  "\n"
20218  "\n"
20219  "SYNOPSIS:\n"
20220  "\n"
20221  "pltext()\n"
20222  "\n"
20223  ""},
20224  { (char *)"pltimefmt", _wrap_pltimefmt, METH_VARARGS, (char *)"\n"
20225  "Set format for date / time labels \n"
20226  "\n"
20227  "DESCRIPTION:\n"
20228  "\n"
20229  " Sets the format for date / time labels. To enable date / time format\n"
20230  " labels see the options to plbox and plenv. \n"
20231  "\n"
20232  " Redacted form: pltimefmt(fmt)\n"
20233  "\n"
20234  " This function is used in example 29. \n"
20235  "\n"
20236  "\n"
20237  "\n"
20238  "SYNOPSIS:\n"
20239  "\n"
20240  "pltimefmt(fmt)\n"
20241  "\n"
20242  "ARGUMENTS:\n"
20243  "\n"
20244  " fmt (const char *, fmt) : This string is passed directly to the\n"
20245  " system strftime. See the system documentation for a full list of\n"
20246  " conversion specifications for your system. All conversion\n"
20247  " specifications take the form of a '%' character followed by\n"
20248  " further conversion specification character. All other text is\n"
20249  " printed as-is. Common options include: %c: The preferred date and\n"
20250  " time representation for the current locale. \n"
20251  " %d: The day of the month as a decimal number. \n"
20252  " %H: The hour as a decimal number using a 24-hour clock. \n"
20253  " %j: The day of the year as a decimal number. \n"
20254  " %m: The month as a decimal number. \n"
20255  " %M: The minute as a decimal number. \n"
20256  " %S: The second as a decimal number. \n"
20257  " %y: The year as a decimal number without a century. \n"
20258  " %Y: The year as a decimal number including a century. \n"
20259  "\n"
20260  ""},
20261  { (char *)"plvasp", _wrap_plvasp, METH_VARARGS, (char *)"\n"
20262  "Specify viewport using aspect ratio only \n"
20263  "\n"
20264  "DESCRIPTION:\n"
20265  "\n"
20266  " Sets the viewport so that the ratio of the length of the y axis to\n"
20267  " that of the x axis is equal to aspect. \n"
20268  "\n"
20269  " Redacted form: plvasp(aspect)\n"
20270  "\n"
20271  " This function is used in example 13. \n"
20272  "\n"
20273  "\n"
20274  "\n"
20275  "SYNOPSIS:\n"
20276  "\n"
20277  "plvasp(aspect)\n"
20278  "\n"
20279  "ARGUMENTS:\n"
20280  "\n"
20281  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
20282  " axis. \n"
20283  "\n"
20284  ""},
20285  { (char *)"plvect", _wrap_plvect, METH_VARARGS, (char *)"\n"
20286  "Vector plot \n"
20287  "\n"
20288  "DESCRIPTION:\n"
20289  "\n"
20290  " Draws a vector plot of the vector (\n"
20291  " u[\n"
20292  " nx][\n"
20293  " ny],\n"
20294  " v[\n"
20295  " nx][\n"
20296  " ny]). The scaling factor for the vectors is given by scale. A\n"
20297  " transformation routine pointed to by pltr with a pointer pltr_data for\n"
20298  " additional data required by the transformation routine is used to map\n"
20299  " indices within the array to the world coordinates. The style of the\n"
20300  " vector arrow may be set using plsvect. \n"
20301  "\n"
20302  " Redacted form: plvect(u, v, scale, pltr, pltr_data)\n"
20303  "\n"
20304  " This function is used in example 22. \n"
20305  "\n"
20306  "\n"
20307  "\n"
20308  "SYNOPSIS:\n"
20309  "\n"
20310  "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
20311  "\n"
20312  "ARGUMENTS:\n"
20313  "\n"
20314  " u, v (PLFLT **, input) : Pointers to a pair of vectored\n"
20315  " two-dimensional arrays containing the x and y components of the\n"
20316  " vector data to be plotted. \n"
20317  "\n"
20318  " nx, ny (PLINT, input) : Physical dimensions of the arrays u and v. \n"
20319  "\n"
20320  " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
20321  " the vectors for plotting. If scale = 0 then the scaling factor is\n"
20322  " automatically calculated for the data. If scale < 0 then the\n"
20323  " scaling factor is automatically calculated for the data and then\n"
20324  " multiplied by -\n"
20325  " scale. If scale > 0 then the scaling factor is set to scale. \n"
20326  "\n"
20327  " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
20328  " Pointer to function that defines transformation between indices\n"
20329  " in array z and the world coordinates (C only). Transformation\n"
20330  " functions are provided in the PLplot library: pltr0 for identity\n"
20331  " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
20332  " defined by one- and two-dimensional arrays. In addition,\n"
20333  " user-supplied routines for the transformation can be used as well.\n"
20334  " Examples of all of these approaches are given in the PLplot\n"
20335  " documentation. The transformation function should have the form\n"
20336  " given by any of pltr0, pltr1, or pltr2. \n"
20337  "\n"
20338  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20339  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20340  " externally supplied. \n"
20341  "\n"
20342  ""},
20343  { (char *)"plvpas", _wrap_plvpas, METH_VARARGS, (char *)"\n"
20344  "Specify viewport using coordinates and aspect ratio \n"
20345  "\n"
20346  "DESCRIPTION:\n"
20347  "\n"
20348  " Device-independent routine for setting up the viewport. The viewport\n"
20349  " is chosen to be the largest with the given aspect ratio that fits\n"
20350  " within the specified region (in terms of normalized subpage\n"
20351  " coordinates). This routine is functionally equivalent to plvpor when\n"
20352  " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
20353  " routine reserves no extra space at the edges for labels. \n"
20354  "\n"
20355  " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
20356  "\n"
20357  " This function is used in example 9. \n"
20358  "\n"
20359  "\n"
20360  "\n"
20361  "SYNOPSIS:\n"
20362  "\n"
20363  "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
20364  "\n"
20365  "ARGUMENTS:\n"
20366  "\n"
20367  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
20368  " left-hand edge of the viewport. \n"
20369  "\n"
20370  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
20371  " right-hand edge of the viewport. \n"
20372  "\n"
20373  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
20374  " bottom edge of the viewport. \n"
20375  "\n"
20376  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
20377  " edge of the viewport. \n"
20378  "\n"
20379  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
20380  " axis. \n"
20381  "\n"
20382  ""},
20383  { (char *)"plvpor", _wrap_plvpor, METH_VARARGS, (char *)"\n"
20384  "Specify viewport using coordinates \n"
20385  "\n"
20386  "DESCRIPTION:\n"
20387  "\n"
20388  " Device-independent routine for setting up the viewport. This defines\n"
20389  " the viewport in terms of normalized subpage coordinates which run from\n"
20390  " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
20391  " current subpage. Use the alternate routine plsvpa in order to create\n"
20392  " a viewport of a definite size. \n"
20393  "\n"
20394  " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
20395  "\n"
20396  " This function is used in examples\n"
20397  " 2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n"
20398  "\n"
20399  "\n"
20400  "\n"
20401  "SYNOPSIS:\n"
20402  "\n"
20403  "plvpor(xmin, xmax, ymin, ymax)\n"
20404  "\n"
20405  "ARGUMENTS:\n"
20406  "\n"
20407  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
20408  " left-hand edge of the viewport. \n"
20409  "\n"
20410  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
20411  " right-hand edge of the viewport. \n"
20412  "\n"
20413  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
20414  " bottom edge of the viewport. \n"
20415  "\n"
20416  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
20417  " edge of the viewport. \n"
20418  "\n"
20419  ""},
20420  { (char *)"plvsta", _wrap_plvsta, METH_VARARGS, (char *)"\n"
20421  "Select standard viewport \n"
20422  "\n"
20423  "DESCRIPTION:\n"
20424  "\n"
20425  " Sets up a standard viewport, leaving a left-hand margin of seven\n"
20426  " character heights, and four character heights around the other three\n"
20427  " sides. \n"
20428  "\n"
20429  " Redacted form: plvsta()\n"
20430  "\n"
20431  " This function is used in examples 1,12,14,17,25,29. \n"
20432  "\n"
20433  "\n"
20434  "\n"
20435  "SYNOPSIS:\n"
20436  "\n"
20437  "plvsta()\n"
20438  "\n"
20439  ""},
20440  { (char *)"plw3d", _wrap_plw3d, METH_VARARGS, (char *)"\n"
20441  "Set up window for 3-d plotting \n"
20442  "\n"
20443  "DESCRIPTION:\n"
20444  "\n"
20445  " Sets up a window for a three-dimensional surface plot within the\n"
20446  " currently defined two-dimensional window. The enclosing box for the\n"
20447  " surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n"
20448  " user-coordinate space is mapped into a box of world coordinate size\n"
20449  " basex by basey by height so that xmin maps to -\n"
20450  " basex/2, xmax maps to basex/2, ymin maps to -\n"
20451  " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
20452  " The resulting world-coordinate box is then viewed by an observer at\n"
20453  " altitude alt and azimuth az. This routine must be called before\n"
20454  " plbox3 or plot3d. For a more complete description of\n"
20455  " three-dimensional plotting see the PLplot documentation. \n"
20456  "\n"
20457  " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
20458  " zmin, zmax, alt, az)\n"
20459  "\n"
20460  " This function is examples 8,11,18,21. \n"
20461  "\n"
20462  "\n"
20463  "\n"
20464  "SYNOPSIS:\n"
20465  "\n"
20466  "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
20467  "\n"
20468  "ARGUMENTS:\n"
20469  "\n"
20470  " basex (PLFLT, input) : The x coordinate size of the\n"
20471  " world-coordinate box. \n"
20472  "\n"
20473  " basey (PLFLT, input) : The y coordinate size of the\n"
20474  " world-coordinate box. \n"
20475  "\n"
20476  " height (PLFLT, input) : The z coordinate size of the\n"
20477  " world-coordinate box. \n"
20478  "\n"
20479  " xmin (PLFLT, input) : The minimum user x coordinate value. \n"
20480  "\n"
20481  " xmax (PLFLT, input) : The maximum user x coordinate value. \n"
20482  "\n"
20483  " ymin (PLFLT, input) : The minimum user y coordinate value. \n"
20484  "\n"
20485  " ymax (PLFLT, input) : The maximum user y coordinate value. \n"
20486  "\n"
20487  " zmin (PLFLT, input) : The minimum user z coordinate value. \n"
20488  "\n"
20489  " zmax (PLFLT, input) : The maximum user z coordinate value. \n"
20490  "\n"
20491  " alt (PLFLT, input) : The viewing altitude in degrees above the XY\n"
20492  " plane. \n"
20493  "\n"
20494  " az (PLFLT, input) : The viewing azimuth in degrees. When az=0, the\n"
20495  " observer is looking face onto the ZX plane, and as az is\n"
20496  " increased, the observer moves clockwise around the box when viewed\n"
20497  " from above the XY plane. \n"
20498  "\n"
20499  ""},
20500  { (char *)"plwidth", _wrap_plwidth, METH_VARARGS, (char *)"\n"
20501  "Set pen width \n"
20502  "\n"
20503  "DESCRIPTION:\n"
20504  "\n"
20505  " Sets the pen width. \n"
20506  "\n"
20507  " Redacted form: plwidth(width)\n"
20508  "\n"
20509  " This function is used in examples 1,2. \n"
20510  "\n"
20511  "\n"
20512  "\n"
20513  "SYNOPSIS:\n"
20514  "\n"
20515  "plwidth(width)\n"
20516  "\n"
20517  "ARGUMENTS:\n"
20518  "\n"
20519  " width (PLINT, input) : The desired pen width. If width is negative\n"
20520  " or the same as the previous value no action is taken. width = 0\n"
20521  " should be interpreted as as the minimum valid pen width for the\n"
20522  " device. The interpretation of positive width values is also\n"
20523  " device dependent. \n"
20524  "\n"
20525  ""},
20526  { (char *)"plwind", _wrap_plwind, METH_VARARGS, (char *)"\n"
20527  "Specify world coordinates of viewport boundaries \n"
20528  "\n"
20529  "DESCRIPTION:\n"
20530  "\n"
20531  " Sets up the world coordinates of the edges of the viewport. \n"
20532  "\n"
20533  " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
20534  "\n"
20535  " This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n"
20536  "\n"
20537  "\n"
20538  "\n"
20539  "SYNOPSIS:\n"
20540  "\n"
20541  "plwind(xmin, xmax, ymin, ymax)\n"
20542  "\n"
20543  "ARGUMENTS:\n"
20544  "\n"
20545  " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
20546  " of the viewport. \n"
20547  "\n"
20548  " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
20549  " of the viewport. \n"
20550  "\n"
20551  " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
20552  " the viewport. \n"
20553  "\n"
20554  " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
20555  " viewport. \n"
20556  "\n"
20557  ""},
20558  { (char *)"plxormod", _wrap_plxormod, METH_VARARGS, (char *)"\n"
20559  "Enter or leave xor mode \n"
20560  "\n"
20561  "DESCRIPTION:\n"
20562  "\n"
20563  " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
20564  " those drivers (e.g., the xwin driver) that support it. Enables\n"
20565  " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
20566  " is not capable of xor operation it returns a status of false. \n"
20567  "\n"
20568  " Redacted form: plxormod(mode, status)\n"
20569  "\n"
20570  " This function is used in examples 1,20. \n"
20571  "\n"
20572  "\n"
20573  "\n"
20574  "SYNOPSIS:\n"
20575  "\n"
20576  "plxormod(mode, status)\n"
20577  "\n"
20578  "ARGUMENTS:\n"
20579  "\n"
20580  " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
20581  " is false means leave xor mode. \n"
20582  "\n"
20583  " status (PLBOOL *, output) : Pointer to status. Returned modestatus\n"
20584  " of true (false) means driver is capable (incapable) of xor mode. \n"
20585  "\n"
20586  ""},
20587  { (char *)"plmap", _wrap_plmap, METH_VARARGS, (char *)"\n"
20588  "Plot continental outline in world coordinates. \n"
20589  "\n"
20590  "DESCRIPTION:\n"
20591  "\n"
20592  " Plots continental outlines in world coordinates. examples/c/x19c\n"
20593  " demonstrates how to use this function to create different\n"
20594  " projections. \n"
20595  "\n"
20596  " Redacted form: General: plmap(mapform, type, minlong, maxlong,\n"
20597  " minlat, maxlat)\n"
20598  " F95, Java, Perl/PDL, Python: Not implemented? \n"
20599  "\n"
20600  "\n"
20601  " This function is used in example 19. \n"
20602  "\n"
20603  "\n"
20604  "\n"
20605  "SYNOPSIS:\n"
20606  "\n"
20607  "plmap(mapform, type, minlong, maxlong, minlat, maxlat)\n"
20608  "\n"
20609  "ARGUMENTS:\n"
20610  "\n"
20611  " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
20612  " supplied function to transform the coordinate longitudes and\n"
20613  " latitudes to a plot coordinate system. By using this transform,\n"
20614  " we can change from a longitude, latitude coordinate to a polar\n"
20615  " stereographic project, for example. Initially, x[0]..[n-1] are\n"
20616  " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
20617  " After the call to mapform(), x[] and y[] should be replaced by\n"
20618  " the corresponding plot coordinates. If no transform is desired,\n"
20619  " mapform can be replaced by NULL. \n"
20620  "\n"
20621  " type (char *, input) : type is a character string. The value of\n"
20622  " this parameter determines the type of background. The possible\n"
20623  " values are: \"globe\" -- continental outlines \n"
20624  " \"usa\" -- USA and state boundaries \n"
20625  " \"cglobe\" -- continental outlines and countries \n"
20626  " \"usaglobe\" -- USA, state boundaries and continental outlines \n"
20627  "\n"
20628  "\n"
20629  " minlong (PLFLT, input) : The value of the longitude on the left\n"
20630  " side of the plot. The value of minlong must be less than the\n"
20631  " value of maxlong, and the quantity maxlong-minlong must be less\n"
20632  " than or equal to 360. \n"
20633  "\n"
20634  " maxlong (PLFLT, input) : The value of the longitude on the right\n"
20635  " side of the plot. \n"
20636  "\n"
20637  " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
20638  " background. One can always use -90.0 as the boundary outside the\n"
20639  " plot window will be automatically eliminated. However, the\n"
20640  " program will be faster if one can reduce the size of the\n"
20641  " background plotted. \n"
20642  "\n"
20643  " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
20644  " background. One can always use 90.0 as the boundary outside the\n"
20645  " plot window will be automatically eliminated. \n"
20646  "\n"
20647  ""},
20648  { (char *)"plmeridians", _wrap_plmeridians, METH_VARARGS, (char *)"\n"
20649  "Plot latitude and longitude lines. \n"
20650  "\n"
20651  "DESCRIPTION:\n"
20652  "\n"
20653  " Displays latitude and longitude on the current plot. The lines are\n"
20654  " plotted in the current color and line style. \n"
20655  "\n"
20656  " Redacted form: General: plmeridians(mapform, dlong, dlat, minlong,\n"
20657  " maxlong, minlat, maxlat)\n"
20658  " F95, Java, Perl/PDL, Python: Not implemented? \n"
20659  "\n"
20660  "\n"
20661  " This function is used in example 19. \n"
20662  "\n"
20663  "\n"
20664  "\n"
20665  "SYNOPSIS:\n"
20666  "\n"
20667  "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
20668  "\n"
20669  "ARGUMENTS:\n"
20670  "\n"
20671  " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
20672  " supplied function to transform the coordinate longitudes and\n"
20673  " latitudes to a plot coordinate system. By using this transform,\n"
20674  " we can change from a longitude, latitude coordinate to a polar\n"
20675  " stereographic project, for example. Initially, x[0]..[n-1] are\n"
20676  " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
20677  " After the call to mapform(), x[] and y[] should be replaced by\n"
20678  " the corresponding plot coordinates. If no transform is desired,\n"
20679  " mapform can be replaced by NULL. \n"
20680  "\n"
20681  " dlong (PLFLT, input) : The interval in degrees at which the\n"
20682  " longitude lines are to be plotted. \n"
20683  "\n"
20684  " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
20685  " lines are to be plotted. \n"
20686  "\n"
20687  " minlong (PLFLT, input) : The value of the longitude on the left\n"
20688  " side of the plot. The value of minlong must be less than the\n"
20689  " value of maxlong, and the quantity maxlong-minlong must be less\n"
20690  " than or equal to 360. \n"
20691  "\n"
20692  " maxlong (PLFLT, input) : The value of the longitude on the right\n"
20693  " side of the plot. \n"
20694  "\n"
20695  " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
20696  " background. One can always use -90.0 as the boundary outside the\n"
20697  " plot window will be automatically eliminated. However, the\n"
20698  " program will be faster if one can reduce the size of the\n"
20699  " background plotted. \n"
20700  "\n"
20701  " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
20702  " background. One can always use 90.0 as the boundary outside the\n"
20703  " plot window will be automatically eliminated. \n"
20704  "\n"
20705  ""},
20706  { (char *)"plimage", _wrap_plimage, METH_VARARGS, (char *)"\n"
20707  "Plot a 2D matrix using color map1 with automatic colour adjustment \n"
20708  "\n"
20709  "DESCRIPTION:\n"
20710  "\n"
20711  " Plot a 2D matrix using color palette 1. The color scale is\n"
20712  " automatically adjusted to use the maximum and minimum values in idata\n"
20713  " as valuemin and valuemax in a call to plimagefr. \n"
20714  "\n"
20715  " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
20716  " zmax, Dxmin, Dxmax, Dymin, Dymax) \n"
20717  "\n"
20718  "\n"
20719  " This function is used in example 20. \n"
20720  "\n"
20721  "\n"
20722  "\n"
20723  "SYNOPSIS:\n"
20724  "\n"
20725  "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
20726  "\n"
20727  "ARGUMENTS:\n"
20728  "\n"
20729  " idata (PLFLT**, input) : A 2D array of values (intensities) to\n"
20730  " plot. Should have dimensions idata[nx][ny]. \n"
20731  "\n"
20732  " nx, ny (PLINT, input) : Dimensions of idata \n"
20733  "\n"
20734  " xmin, xmax, ymin, ymax (PLFLT, input) : Plot coordinates to strecth\n"
20735  " the image data to. idata[0][0] corresponds to (xmin, ymin) and\n"
20736  " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
20737  "\n"
20738  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
20739  " (inclusive) will be plotted. \n"
20740  "\n"
20741  " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
20742  " points whose plot coordinates fall inside the window of (Dxmin,\n"
20743  " Dymin) to (Dxmax, Dymax). \n"
20744  "\n"
20745  ""},
20746  { (char *)"plimagefr", _wrap_plimagefr, METH_VARARGS, (char *)"\n"
20747  "Plot a 2D matrix using color map1 \n"
20748  "\n"
20749  "DESCRIPTION:\n"
20750  "\n"
20751  " Plot a 2D matrix using color map1. \n"
20752  "\n"
20753  " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax,\n"
20754  " zmin, zmax, valuemin, valuemax, pltr, pltr_data) \n"
20755  "\n"
20756  "\n"
20757  " This function is used in example 20. \n"
20758  "\n"
20759  "\n"
20760  "\n"
20761  "SYNOPSIS:\n"
20762  "\n"
20763  "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
20764  "\n"
20765  "ARGUMENTS:\n"
20766  "\n"
20767  " idata (PLFLT**, input) : A 2D array of values (intensities) to\n"
20768  " plot. Should have dimensions idata[nx][ny]. \n"
20769  "\n"
20770  " nx, ny (PLINT, input) : Dimensions of idata \n"
20771  "\n"
20772  " xmin, xmax, ymin, ymax (PLFLT, input) : Stretch image data to these\n"
20773  " Plot coordinates. idata[0][0] corresponds to (xmin, ymin) and\n"
20774  " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
20775  "\n"
20776  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
20777  " (inclusive) will be plotted. \n"
20778  "\n"
20779  " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
20780  " values to use for value to color mappings. A datum equal to or\n"
20781  " less than valuemin will be plotted with color 0.0, while a datum\n"
20782  " equal to or greater than valuemax will be plotted with color 1.0. \n"
20783  " Data between valuemin and valuemax map linearly to colors between\n"
20784  " 0.0 and 1.0. \n"
20785  "\n"
20786  " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
20787  " Pointer to function that defines a transformation between the\n"
20788  " data in the array idata and world coordinates. An input\n"
20789  " coordinate of (0, 0) corresponds to the \"top-left\" corner of idata\n"
20790  " while (nx, ny) corresponds to the \"bottom-right\" corner of idata. \n"
20791  " Some transformation functions are provided in the PLplot library:\n"
20792  " pltr0 for identity mapping, and pltr1 and pltr2 for arbitrary\n"
20793  " mappings respectively defined by one- and two-dimensional arrays. \n"
20794  " In addition, user-supplied routines for the transformation can be\n"
20795  " used as well. Examples of all of these approaches are given in\n"
20796  " the PLplot documentation. The transformation function should have\n"
20797  " the form given by any of pltr0, pltr1, or pltr2. \n"
20798  "\n"
20799  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20800  " information to pltr0, pltr1, pltr2, or whatever routine is\n"
20801  " externally supplied. \n"
20802  "\n"
20803  ""},
20804  { (char *)"plClearOpts", _wrap_plClearOpts, METH_VARARGS, NULL},
20805  { (char *)"plResetOpts", _wrap_plResetOpts, METH_VARARGS, NULL},
20806  { (char *)"plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
20807  { (char *)"plOptUsage", _wrap_plOptUsage, METH_VARARGS, NULL},
20808  { (char *)"plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_VARARGS, NULL},
20809  { (char *)"plGetCursor", _wrap_plGetCursor, METH_VARARGS, NULL},
20810  { NULL, NULL, 0, NULL }
20811 };
20812 
20813 
20814 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20815 
20816 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
20817 static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
20818 static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
20819 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
20820 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
20821 static swig_type_info _swigt__p_f_double_double__int = {"_p_f_double_double__int", "defined_func|int (*)(double,double)", 0, 0, (void*)0, 0};
20822 static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void = {"_p_f_double_double_p_double_p_double_p_void__void", "ct_func|pltr_func|void (*)(double,double,double *,double *,void *)", 0, 0, (void*)0, 0};
20823 static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void = {"_p_f_int_double_p_char_int_p_void__void", "void (*)(int,double,char *,int,void *)|label_func", 0, 0, (void*)0, 0};
20824 static swig_type_info _swigt__p_f_int_p_double_p_double__void = {"_p_f_int_p_double_p_double__void", "mapform_func|void (*)(int,double *,double *)", 0, 0, (void*)0, 0};
20825 static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void = {"_p_f_int_p_q_const__double_p_q_const__double__void", "void (*)(int,double const *,double const *)|fill_func", 0, 0, (void*)0, 0};
20826 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
20827 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
20828 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
20829 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
20830 
20835  &_swigt__p_char,
20842  &_swigt__p_int,
20846 };
20847 
20848 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
20849 static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
20850 static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
20851 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
20852 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
20858 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
20859 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
20860 static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
20861 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
20862 
20874  _swigc__p_int,
20878 };
20879 
20880 
20881 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
20882 
20884 {0, 0, 0, 0.0, 0, 0}};
20885 
20886 #ifdef __cplusplus
20887 }
20888 #endif
20889 /* -----------------------------------------------------------------------------
20890  * Type initialization:
20891  * This problem is tough by the requirement that no dynamic
20892  * memory is used. Also, since swig_type_info structures store pointers to
20893  * swig_cast_info structures and swig_cast_info structures store pointers back
20894  * to swig_type_info structures, we need some lookup code at initialization.
20895  * The idea is that swig generates all the structures that are needed.
20896  * The runtime then collects these partially filled structures.
20897  * The SWIG_InitializeModule function takes these initial arrays out of
20898  * swig_module, and does all the lookup, filling in the swig_module.types
20899  * array with the correct data and linking the correct swig_cast_info
20900  * structures together.
20901  *
20902  * The generated swig_type_info structures are assigned staticly to an initial
20903  * array. We just loop through that array, and handle each type individually.
20904  * First we lookup if this type has been already loaded, and if so, use the
20905  * loaded structure instead of the generated one. Then we have to fill in the
20906  * cast linked list. The cast data is initially stored in something like a
20907  * two-dimensional array. Each row corresponds to a type (there are the same
20908  * number of rows as there are in the swig_type_initial array). Each entry in
20909  * a column is one of the swig_cast_info structures for that type.
20910  * The cast_initial array is actually an array of arrays, because each row has
20911  * a variable number of columns. So to actually build the cast linked list,
20912  * we find the array of casts associated with the type, and loop through it
20913  * adding the casts to the list. The one last trick we need to do is making
20914  * sure the type pointer in the swig_cast_info struct is correct.
20915  *
20916  * First off, we lookup the cast->type name to see if it is already loaded.
20917  * There are three cases to handle:
20918  * 1) If the cast->type has already been loaded AND the type we are adding
20919  * casting info to has not been loaded (it is in this module), THEN we
20920  * replace the cast->type pointer with the type pointer that has already
20921  * been loaded.
20922  * 2) If BOTH types (the one we are adding casting info to, and the
20923  * cast->type) are loaded, THEN the cast info has already been loaded by
20924  * the previous module so we just ignore it.
20925  * 3) Finally, if cast->type has not already been loaded, then we add that
20926  * swig_cast_info to the linked list (because the cast->type) pointer will
20927  * be correct.
20928  * ----------------------------------------------------------------------------- */
20929 
20930 #ifdef __cplusplus
20931 extern "C" {
20932 #if 0
20933 } /* c-mode */
20934 #endif
20935 #endif
20936 
20937 #if 0
20938 #define SWIGRUNTIME_DEBUG
20939 #endif
20940 
20941 
20942 SWIGRUNTIME void
20943 SWIG_InitializeModule(void *clientdata) {
20944  size_t i;
20945  swig_module_info *module_head, *iter;
20946  int found, init;
20947 
20948  /* check to see if the circular list has been setup, if not, set it up */
20949  if (swig_module.next==0) {
20950  /* Initialize the swig_module */
20951  swig_module.type_initial = swig_type_initial;
20952  swig_module.cast_initial = swig_cast_initial;
20953  swig_module.next = &swig_module;
20954  init = 1;
20955  } else {
20956  init = 0;
20957  }
20958 
20959  /* Try and load any already created modules */
20960  module_head = SWIG_GetModule(clientdata);
20961  if (!module_head) {
20962  /* This is the first module loaded for this interpreter */
20963  /* so set the swig module into the interpreter */
20964  SWIG_SetModule(clientdata, &swig_module);
20965  module_head = &swig_module;
20966  } else {
20967  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
20968  found=0;
20969  iter=module_head;
20970  do {
20971  if (iter==&swig_module) {
20972  found=1;
20973  break;
20974  }
20975  iter=iter->next;
20976  } while (iter!= module_head);
20977 
20978  /* if the is found in the list, then all is done and we may leave */
20979  if (found) return;
20980  /* otherwise we must add out module into the list */
20981  swig_module.next = module_head->next;
20982  module_head->next = &swig_module;
20983  }
20984 
20985  /* When multiple interpeters are used, a module could have already been initialized in
20986  a different interpreter, but not yet have a pointer in this interpreter.
20987  In this case, we do not want to continue adding types... everything should be
20988  set up already */
20989  if (init == 0) return;
20990 
20991  /* Now work on filling in swig_module.types */
20992 #ifdef SWIGRUNTIME_DEBUG
20993  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
20994 #endif
20995  for (i = 0; i < swig_module.size; ++i) {
20996  swig_type_info *type = 0;
20997  swig_type_info *ret;
20998  swig_cast_info *cast;
20999 
21000 #ifdef SWIGRUNTIME_DEBUG
21001  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
21002 #endif
21003 
21004  /* if there is another module already loaded */
21005  if (swig_module.next != &swig_module) {
21006  type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
21007  }
21008  if (type) {
21009  /* Overwrite clientdata field */
21010 #ifdef SWIGRUNTIME_DEBUG
21011  printf("SWIG_InitializeModule: found type %s\n", type->name);
21012 #endif
21013  if (swig_module.type_initial[i]->clientdata) {
21014  type->clientdata = swig_module.type_initial[i]->clientdata;
21015 #ifdef SWIGRUNTIME_DEBUG
21016  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
21017 #endif
21018  }
21019  } else {
21020  type = swig_module.type_initial[i];
21021  }
21022 
21023  /* Insert casting types */
21024  cast = swig_module.cast_initial[i];
21025  while (cast->type) {
21026  /* Don't need to add information already in the list */
21027  ret = 0;
21028 #ifdef SWIGRUNTIME_DEBUG
21029  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
21030 #endif
21031  if (swig_module.next != &swig_module) {
21032  ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
21033 #ifdef SWIGRUNTIME_DEBUG
21034  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
21035 #endif
21036  }
21037  if (ret) {
21038  if (type == swig_module.type_initial[i]) {
21039 #ifdef SWIGRUNTIME_DEBUG
21040  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
21041 #endif
21042  cast->type = ret;
21043  ret = 0;
21044  } else {
21045  /* Check for casting already in the list */
21046  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
21047 #ifdef SWIGRUNTIME_DEBUG
21048  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
21049 #endif
21050  if (!ocast) ret = 0;
21051  }
21052  }
21053 
21054  if (!ret) {
21055 #ifdef SWIGRUNTIME_DEBUG
21056  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
21057 #endif
21058  if (type->cast) {
21059  type->cast->prev = cast;
21060  cast->next = type->cast;
21061  }
21062  type->cast = cast;
21063  }
21064  cast++;
21065  }
21066  /* Set entry in modules->types array equal to the type */
21067  swig_module.types[i] = type;
21068  }
21069  swig_module.types[i] = 0;
21070 
21071 #ifdef SWIGRUNTIME_DEBUG
21072  printf("**** SWIG_InitializeModule: Cast List ******\n");
21073  for (i = 0; i < swig_module.size; ++i) {
21074  int j = 0;
21075  swig_cast_info *cast = swig_module.cast_initial[i];
21076  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
21077  while (cast->type) {
21078  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
21079  cast++;
21080  ++j;
21081  }
21082  printf("---- Total casts: %d\n",j);
21083  }
21084  printf("**** SWIG_InitializeModule: Cast List ******\n");
21085 #endif
21086 }
21087 
21088 /* This function will propagate the clientdata field of type to
21089 * any new swig_type_info structures that have been added into the list
21090 * of equivalent types. It is like calling
21091 * SWIG_TypeClientData(type, clientdata) a second time.
21092 */
21093 SWIGRUNTIME void
21095  size_t i;
21096  swig_cast_info *equiv;
21097  static int init_run = 0;
21098 
21099  if (init_run) return;
21100  init_run = 1;
21101 
21102  for (i = 0; i < swig_module.size; i++) {
21103  if (swig_module.types[i]->clientdata) {
21104  equiv = swig_module.types[i]->cast;
21105  while (equiv) {
21106  if (!equiv->converter) {
21107  if (equiv->type && !equiv->type->clientdata)
21108  SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
21109  }
21110  equiv = equiv->next;
21111  }
21112  }
21113  }
21114 }
21115 
21116 #ifdef __cplusplus
21117 #if 0
21118 {
21119  /* c-mode */
21120 #endif
21121 }
21122 #endif
21123 
21124 
21125 
21126 #ifdef __cplusplus
21127 extern "C" {
21128 #endif
21129 
21130  /* Python-specific SWIG API */
21131 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21132 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21133 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21134 
21135  /* -----------------------------------------------------------------------------
21136  * global variable support code.
21137  * ----------------------------------------------------------------------------- */
21138 
21139  typedef struct swig_globalvar {
21140  char *name; /* Name of global variable */
21141  PyObject *(*get_attr)(void); /* Return the current value */
21142  int (*set_attr)(PyObject *); /* Set the value */
21144  } swig_globalvar;
21145 
21146  typedef struct swig_varlinkobject {
21147  PyObject_HEAD
21150 
21151  SWIGINTERN PyObject *
21153 #if PY_VERSION_HEX >= 0x03000000
21154  return PyUnicode_InternFromString("<Swig global variables>");
21155 #else
21156  return PyString_FromString("<Swig global variables>");
21157 #endif
21158  }
21159 
21160  SWIGINTERN PyObject *
21162 #if PY_VERSION_HEX >= 0x03000000
21163  PyObject *str = PyUnicode_InternFromString("(");
21164  PyObject *tail;
21165  PyObject *joined;
21166  swig_globalvar *var;
21167  for (var = v->vars; var; var=var->next) {
21168  tail = PyUnicode_FromString(var->name);
21169  joined = PyUnicode_Concat(str, tail);
21170  Py_DecRef(str);
21171  Py_DecRef(tail);
21172  str = joined;
21173  if (var->next) {
21174  tail = PyUnicode_InternFromString(", ");
21175  joined = PyUnicode_Concat(str, tail);
21176  Py_DecRef(str);
21177  Py_DecRef(tail);
21178  str = joined;
21179  }
21180  }
21181  tail = PyUnicode_InternFromString(")");
21182  joined = PyUnicode_Concat(str, tail);
21183  Py_DecRef(str);
21184  Py_DecRef(tail);
21185  str = joined;
21186 #else
21187  PyObject *str = PyString_FromString("(");
21188  swig_globalvar *var;
21189  for (var = v->vars; var; var=var->next) {
21190  PyString_ConcatAndDel(&str,PyString_FromString(var->name));
21191  if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
21192  }
21193  PyString_ConcatAndDel(&str,PyString_FromString(")"));
21194 #endif
21195  return str;
21196  }
21197 
21198  SWIGINTERN int
21200  char *tmp;
21201  PyObject *str = swig_varlink_str(v);
21202  fprintf(fp,"Swig global variables ");
21203  fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
21205  Py_DECREF(str);
21206  return 0;
21207  }
21208 
21209  SWIGINTERN void
21211  swig_globalvar *var = v->vars;
21212  while (var) {
21213  swig_globalvar *n = var->next;
21214  free(var->name);
21215  free(var);
21216  var = n;
21217  }
21218  }
21219 
21220  SWIGINTERN PyObject *
21222  PyObject *res = NULL;
21223  swig_globalvar *var = v->vars;
21224  while (var) {
21225  if (strcmp(var->name,n) == 0) {
21226  res = (*var->get_attr)();
21227  break;
21228  }
21229  var = var->next;
21230  }
21231  if (res == NULL && !PyErr_Occurred()) {
21232  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21233  }
21234  return res;
21235  }
21236 
21237  SWIGINTERN int
21238  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
21239  int res = 1;
21240  swig_globalvar *var = v->vars;
21241  while (var) {
21242  if (strcmp(var->name,n) == 0) {
21243  res = (*var->set_attr)(p);
21244  break;
21245  }
21246  var = var->next;
21247  }
21248  if (res == 1 && !PyErr_Occurred()) {
21249  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21250  }
21251  return res;
21252  }
21253 
21254  SWIGINTERN PyTypeObject*
21256  static char varlink__doc__[] = "Swig var link object";
21257  static PyTypeObject varlink_type;
21258  static int type_init = 0;
21259  if (!type_init) {
21260  const PyTypeObject tmp = {
21261  /* PyObject header changed in Python 3 */
21262 #if PY_VERSION_HEX >= 0x03000000
21263  PyVarObject_HEAD_INIT(NULL, 0)
21264 #else
21265  PyObject_HEAD_INIT(NULL)
21266  0, /* ob_size */
21267 #endif
21268  (char *)"swigvarlink", /* tp_name */
21269  sizeof(swig_varlinkobject), /* tp_basicsize */
21270  0, /* tp_itemsize */
21271  (destructor) swig_varlink_dealloc, /* tp_dealloc */
21272  (printfunc) swig_varlink_print, /* tp_print */
21273  (getattrfunc) swig_varlink_getattr, /* tp_getattr */
21274  (setattrfunc) swig_varlink_setattr, /* tp_setattr */
21275  0, /* tp_compare */
21276  (reprfunc) swig_varlink_repr, /* tp_repr */
21277  0, /* tp_as_number */
21278  0, /* tp_as_sequence */
21279  0, /* tp_as_mapping */
21280  0, /* tp_hash */
21281  0, /* tp_call */
21282  (reprfunc) swig_varlink_str, /* tp_str */
21283  0, /* tp_getattro */
21284  0, /* tp_setattro */
21285  0, /* tp_as_buffer */
21286  0, /* tp_flags */
21287  varlink__doc__, /* tp_doc */
21288  0, /* tp_traverse */
21289  0, /* tp_clear */
21290  0, /* tp_richcompare */
21291  0, /* tp_weaklistoffset */
21292 #if PY_VERSION_HEX >= 0x02020000
21293  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
21294 #endif
21295 #if PY_VERSION_HEX >= 0x02030000
21296  0, /* tp_del */
21297 #endif
21298 #if PY_VERSION_HEX >= 0x02060000
21299  0, /* tp_version */
21300 #endif
21301 #ifdef COUNT_ALLOCS
21302  0,0,0,0 /* tp_alloc -> tp_next */
21303 #endif
21304  };
21305  varlink_type = tmp;
21306  type_init = 1;
21307 #if PY_VERSION_HEX < 0x02020000
21308  varlink_type.ob_type = &PyType_Type;
21309 #else
21310  if (PyType_Ready(&varlink_type) < 0)
21311  return NULL;
21312 #endif
21313  }
21314  return &varlink_type;
21315  }
21316 
21317  /* Create a variable linking object for use later */
21318  SWIGINTERN PyObject *
21320  swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
21321  if (result) {
21322  result->vars = 0;
21323  }
21324  return ((PyObject*) result);
21325  }
21326 
21327  SWIGINTERN void
21328  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
21330  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
21331  if (gv) {
21332  size_t size = strlen(name)+1;
21333  gv->name = (char *)malloc(size);
21334  if (gv->name) {
21335  strncpy(gv->name,name,size);
21336  gv->get_attr = get_attr;
21337  gv->set_attr = set_attr;
21338  gv->next = v->vars;
21339  }
21340  }
21341  v->vars = gv;
21342  }
21343 
21344  SWIGINTERN PyObject *
21346  static PyObject *_SWIG_globals = 0;
21347  if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
21348  return _SWIG_globals;
21349  }
21350 
21351  /* -----------------------------------------------------------------------------
21352  * constants/methods manipulation
21353  * ----------------------------------------------------------------------------- */
21354 
21355  /* Install Constants */
21356  SWIGINTERN void
21357  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
21358  PyObject *obj = 0;
21359  size_t i;
21360  for (i = 0; constants[i].type; ++i) {
21361  switch(constants[i].type) {
21362  case SWIG_PY_POINTER:
21363  obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
21364  break;
21365  case SWIG_PY_BINARY:
21366  obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21367  break;
21368  default:
21369  obj = 0;
21370  break;
21371  }
21372  if (obj) {
21373  PyDict_SetItemString(d, constants[i].name, obj);
21374  Py_DECREF(obj);
21375  }
21376  }
21377  }
21378 
21379  /* -----------------------------------------------------------------------------*/
21380  /* Fix SwigMethods to carry the callback ptrs when needed */
21381  /* -----------------------------------------------------------------------------*/
21382 
21383  SWIGINTERN void
21384  SWIG_Python_FixMethods(PyMethodDef *methods,
21385  swig_const_info *const_table,
21386  swig_type_info **types,
21387  swig_type_info **types_initial) {
21388  size_t i;
21389  for (i = 0; methods[i].ml_name; ++i) {
21390  const char *c = methods[i].ml_doc;
21391  if (c && (c = strstr(c, "swig_ptr: "))) {
21392  int j;
21393  swig_const_info *ci = 0;
21394  const char *name = c + 10;
21395  for (j = 0; const_table[j].type; ++j) {
21396  if (strncmp(const_table[j].name, name,
21397  strlen(const_table[j].name)) == 0) {
21398  ci = &(const_table[j]);
21399  break;
21400  }
21401  }
21402  if (ci) {
21403  void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
21404  if (ptr) {
21405  size_t shift = (ci->ptype) - types;
21406  swig_type_info *ty = types_initial[shift];
21407  size_t ldoc = (c - methods[i].ml_doc);
21408  size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
21409  char *ndoc = (char*)malloc(ldoc + lptr + 10);
21410  if (ndoc) {
21411  char *buff = ndoc;
21412  strncpy(buff, methods[i].ml_doc, ldoc);
21413  buff += ldoc;
21414  strncpy(buff, "swig_ptr: ", 10);
21415  buff += 10;
21416  SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
21417  methods[i].ml_doc = ndoc;
21418  }
21419  }
21420  }
21421  }
21422  }
21423  }
21424 
21425 #ifdef __cplusplus
21426 }
21427 #endif
21428 
21429 /* -----------------------------------------------------------------------------*
21430  * Partial Init method
21431  * -----------------------------------------------------------------------------*/
21432 
21433 #ifdef __cplusplus
21434 extern "C"
21435 #endif
21436 
21437 SWIGEXPORT
21438 #if PY_VERSION_HEX >= 0x03000000
21439 PyObject*
21440 #else
21441 void
21442 #endif
21443 SWIG_init(void) {
21444  PyObject *m, *d, *md;
21445 #if PY_VERSION_HEX >= 0x03000000
21446  static struct PyModuleDef SWIG_module = {
21447 # if PY_VERSION_HEX >= 0x03020000
21448  PyModuleDef_HEAD_INIT,
21449 # else
21450  {
21451  PyObject_HEAD_INIT(NULL)
21452  NULL, /* m_init */
21453  0, /* m_index */
21454  NULL, /* m_copy */
21455  },
21456 # endif
21457  (char *) SWIG_name,
21458  NULL,
21459  -1,
21460  SwigMethods,
21461  NULL,
21462  NULL,
21463  NULL,
21464  NULL
21465  };
21466 #endif
21467 
21468 #if defined(SWIGPYTHON_BUILTIN)
21469  static SwigPyClientData SwigPyObject_clientdata = {
21470  0, 0, 0, 0, 0, 0, 0
21471  };
21472  static PyGetSetDef this_getset_def = {
21473  (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
21474  };
21475  static SwigPyGetSet thisown_getset_closure = {
21476  (PyCFunction) SwigPyObject_own,
21477  (PyCFunction) SwigPyObject_own
21478  };
21479  static PyGetSetDef thisown_getset_def = {
21480  (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
21481  };
21482  PyObject *metatype_args;
21483  PyTypeObject *builtin_pytype;
21484  int builtin_base_count;
21485  swig_type_info *builtin_basetype;
21486  PyObject *tuple;
21487  PyGetSetDescrObject *static_getset;
21488  PyTypeObject *metatype;
21489  SwigPyClientData *cd;
21490  PyObject *public_interface, *public_symbol;
21491  PyObject *this_descr;
21492  PyObject *thisown_descr;
21493  int i;
21494 
21495  (void)builtin_pytype;
21496  (void)builtin_base_count;
21497  (void)builtin_basetype;
21498  (void)tuple;
21499  (void)static_getset;
21500 
21501  /* metatype is used to implement static member variables. */
21502  metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
21503  assert(metatype_args);
21504  metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
21505  assert(metatype);
21506  Py_DECREF(metatype_args);
21507  metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
21508  assert(PyType_Ready(metatype) >= 0);
21509 #endif
21510 
21511  /* Fix SwigMethods to carry the callback ptrs when needed */
21512  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
21513 
21514 #if PY_VERSION_HEX >= 0x03000000
21515  m = PyModule_Create(&SWIG_module);
21516 #else
21517  m = Py_InitModule((char *) SWIG_name, SwigMethods);
21518 #endif
21519  md = d = PyModule_GetDict(m);
21520  (void)md;
21521 
21523 
21524 #ifdef SWIGPYTHON_BUILTIN
21525  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
21526  assert(SwigPyObject_stype);
21527  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
21528  if (!cd) {
21529  SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
21530  SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
21531  } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
21532  PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
21533 # if PY_VERSION_HEX >= 0x03000000
21534  return NULL;
21535 # else
21536  return;
21537 # endif
21538  }
21539 
21540  /* All objects have a 'this' attribute */
21541  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
21542  (void)this_descr;
21543 
21544  /* All objects have a 'thisown' attribute */
21545  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
21546  (void)thisown_descr;
21547 
21548  public_interface = PyList_New(0);
21549  public_symbol = 0;
21550  (void)public_symbol;
21551 
21552  PyDict_SetItemString(md, "__all__", public_interface);
21553  Py_DECREF(public_interface);
21554  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
21555  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
21556  for (i = 0; swig_const_table[i].name != 0; ++i)
21557  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
21558 #endif
21559 
21561 
21562 
21563  import_array();
21564 
21565  SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
21566  SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
21567  SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
21568  SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
21569  SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
21570  SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
21571  SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
21572  SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
21573  SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
21574  SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
21575  SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
21576  SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
21577  SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
21578  SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
21579  SWIG_Python_SetConstant(d, "PLESC_PLFLTBUFFERING",SWIG_From_int((int)(15)));
21580  SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
21581  SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
21582  SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
21583  SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
21584  SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
21585  SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
21586  SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
21587  SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x01)));
21588  SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x02)));
21589  SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x03)));
21590  SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x04)));
21591  SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x08)));
21592  SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x10)));
21593  SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x20)));
21594  SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x40)));
21595  SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x80)));
21596  SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
21597  SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0)));
21598  SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(1)));
21599  SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(2)));
21600  SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(4)));
21601  SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0)));
21602  SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(1)));
21603  SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(2)));
21604  SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(8)));
21605  SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(16)));
21606  SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(1)));
21607  SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(2)));
21608  SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(4)));
21609  SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(8)));
21610  SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(16)));
21611  SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(32)));
21612  SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(64)));
21613  SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(128)));
21614  SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(1)));
21615  SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(2)));
21616  SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(4)));
21617  SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(8)));
21618  SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(16)));
21619  SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(32)));
21620  SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(64)));
21621  SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(128)));
21622  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
21623  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
21624  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
21625  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
21626  SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
21627  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
21628  SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
21629  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
21630  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
21631  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
21632  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
21633  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
21634  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
21635  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
21636  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
21637  SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
21638  SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
21639  SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
21640  SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
21641  SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
21642  SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
21643  SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
21644  SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
21645  SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
21646  SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
21647  SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
21648  SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
21649  SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
21650  SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
21651  SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
21652  SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
21653  SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
21654  SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
21655  SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
21656  SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
21657  SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
21658  SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
21659  SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
21660  SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
21661  SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
21662  SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
21663  SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
21664  SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
21665  SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
21666  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
21667  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
21668  SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
21669  SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
21670  SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
21671  SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
21672  SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
21673  SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
21674  SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
21675  SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
21676  SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
21677  SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
21678  SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
21679  SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
21680  SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
21681  SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
21682  SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
21683  SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
21684  SWIG_Python_SetConstant(d, "PLESPLFLTBUFFERING_ENABLE",SWIG_From_int((int)(1)));
21685  SWIG_Python_SetConstant(d, "PLESPLFLTBUFFERING_DISABLE",SWIG_From_int((int)(2)));
21686  SWIG_Python_SetConstant(d, "PLESPLFLTBUFFERING_QUERY",SWIG_From_int((int)(3)));
21687  SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
21688  SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
21689  SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
21690  SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
21691  SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
21692  SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
21693 #if PY_VERSION_HEX >= 0x03000000
21694  return m;
21695 #else
21696  return;
21697 #endif
21698 }
21699