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.11
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 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
125 /* Use debug wrappers with the Python release dll */
126 # undef _DEBUG
127 # include <Python.h>
128 # define _DEBUG
129 #else
130 # include <Python.h>
131 #endif
132 
133 /* -----------------------------------------------------------------------------
134  * swigrun.swg
135  *
136  * This file contains generic C API SWIG runtime support for pointer
137  * type checking.
138  * ----------------------------------------------------------------------------- */
139 
140 /* This should only be incremented when either the layout of swig_type_info changes,
141  or for whatever reason, the runtime changes incompatibly */
142 #define SWIG_RUNTIME_VERSION "4"
143 
144 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
145 #ifdef SWIG_TYPE_TABLE
146 # define SWIG_QUOTE_STRING(x) #x
147 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
148 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
149 #else
150 # define SWIG_TYPE_TABLE_NAME
151 #endif
152 
153 /*
154  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
155  creating a static or dynamic library from the SWIG runtime code.
156  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
157 
158  But only do this if strictly necessary, ie, if you have problems
159  with your compiler or suchlike.
160 */
161 
162 #ifndef SWIGRUNTIME
163 # define SWIGRUNTIME SWIGINTERN
164 #endif
165 
166 #ifndef SWIGRUNTIMEINLINE
167 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
168 #endif
169 
170 /* Generic buffer size */
171 #ifndef SWIG_BUFFER_SIZE
172 # define SWIG_BUFFER_SIZE 1024
173 #endif
174 
175 /* Flags for pointer conversions */
176 #define SWIG_POINTER_DISOWN 0x1
177 #define SWIG_CAST_NEW_MEMORY 0x2
178 
179 /* Flags for new pointer objects */
180 #define SWIG_POINTER_OWN 0x1
181 
182 
183 /*
184  Flags/methods for returning states.
185 
186  The SWIG conversion methods, as ConvertPtr, return an integer
187  that tells if the conversion was successful or not. And if not,
188  an error code can be returned (see swigerrors.swg for the codes).
189 
190  Use the following macros/flags to set or process the returning
191  states.
192 
193  In old versions of SWIG, code such as the following was usually written:
194 
195  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
196  // success code
197  } else {
198  //fail code
199  }
200 
201  Now you can be more explicit:
202 
203  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
204  if (SWIG_IsOK(res)) {
205  // success code
206  } else {
207  // fail code
208  }
209 
210  which is the same really, but now you can also do
211 
212  Type *ptr;
213  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
214  if (SWIG_IsOK(res)) {
215  // success code
216  if (SWIG_IsNewObj(res) {
217  ...
218  delete *ptr;
219  } else {
220  ...
221  }
222  } else {
223  // fail code
224  }
225 
226  I.e., now SWIG_ConvertPtr can return new objects and you can
227  identify the case and take care of the deallocation. Of course that
228  also requires SWIG_ConvertPtr to return new result values, such as
229 
230  int SWIG_ConvertPtr(obj, ptr,...) {
231  if (<obj is ok>) {
232  if (<need new object>) {
233  *ptr = <ptr to new allocated object>;
234  return SWIG_NEWOBJ;
235  } else {
236  *ptr = <ptr to old object>;
237  return SWIG_OLDOBJ;
238  }
239  } else {
240  return SWIG_BADOBJ;
241  }
242  }
243 
244  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
245  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
246  SWIG errors code.
247 
248  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
249  allows to return the 'cast rank', for example, if you have this
250 
251  int food(double)
252  int fooi(int);
253 
254  and you call
255 
256  food(1) // cast rank '1' (1 -> 1.0)
257  fooi(1) // cast rank '0'
258 
259  just use the SWIG_AddCast()/SWIG_CheckState()
260 */
261 
262 #define SWIG_OK (0)
263 #define SWIG_ERROR (-1)
264 #define SWIG_IsOK(r) (r >= 0)
265 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
266 
267 /* The CastRankLimit says how many bits are used for the cast rank */
268 #define SWIG_CASTRANKLIMIT (1 << 8)
269 /* The NewMask denotes the object was created (using new/malloc) */
270 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
271 /* The TmpMask is for in/out typemaps that use temporal objects */
272 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
273 /* Simple returning values */
274 #define SWIG_BADOBJ (SWIG_ERROR)
275 #define SWIG_OLDOBJ (SWIG_OK)
276 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
277 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
278 /* Check, add and del mask methods */
279 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
280 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
281 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
282 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
283 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
284 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
285 
286 /* Cast-Rank Mode */
287 #if defined(SWIG_CASTRANK_MODE)
288 # ifndef SWIG_TypeRank
289 # define SWIG_TypeRank unsigned long
290 # endif
291 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
292 # define SWIG_MAXCASTRANK (2)
293 # endif
294 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
295 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
296 SWIGINTERNINLINE int SWIG_AddCast(int r) {
297  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
298 }
300  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
301 }
302 #else /* no cast-rank mode */
303 # define SWIG_AddCast(r) (r)
304 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
305 #endif
306 
307 
308 #include <string.h>
309 
310 #ifdef __cplusplus
311 extern "C" {
312 #endif
313 
314 typedef void *(*swig_converter_func)(void *, int *);
315 typedef struct swig_type_info *(*swig_dycast_func)(void **);
316 
317 /* Structure to store information on one type */
318 typedef struct swig_type_info {
319  const char *name; /* mangled name of this type */
320  const char *str; /* human readable name of this type */
321  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
322  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
323  void *clientdata; /* language specific type data */
324  int owndata; /* flag if the structure owns the clientdata */
326 
327 /* Structure to store a type and conversion function used for casting */
328 typedef struct swig_cast_info {
329  swig_type_info *type; /* pointer to type that is equivalent to this type */
330  swig_converter_func converter; /* function to cast the void pointers */
331  struct swig_cast_info *next; /* pointer to next cast in linked list */
332  struct swig_cast_info *prev; /* pointer to the previous cast */
334 
335 /* Structure used to store module information
336  * Each module generates one structure like this, and the runtime collects
337  * all of these structures and stores them in a circularly linked list.*/
338 typedef struct swig_module_info {
339  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
340  size_t size; /* Number of types in this module */
341  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
342  swig_type_info **type_initial; /* Array of initially generated type structures */
343  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
344  void *clientdata; /* Language specific module data */
346 
347 /*
348  Compare two type names skipping the space characters, therefore
349  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
350 
351  Return 0 when the two name types are equivalent, as in
352  strncmp, but skipping ' '.
353 */
354 SWIGRUNTIME int
355 SWIG_TypeNameComp(const char *f1, const char *l1,
356  const char *f2, const char *l2) {
357  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
358  while ((*f1 == ' ') && (f1 != l1)) ++f1;
359  while ((*f2 == ' ') && (f2 != l2)) ++f2;
360  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
361  }
362  return (int)((l1 - f1) - (l2 - f2));
363 }
364 
365 /*
366  Check type equivalence in a name list like <name1>|<name2>|...
367  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
368 */
369 SWIGRUNTIME int
370 SWIG_TypeCmp(const char *nb, const char *tb) {
371  int equiv = 1;
372  const char* te = tb + strlen(tb);
373  const char* ne = nb;
374  while (equiv != 0 && *ne) {
375  for (nb = ne; *ne; ++ne) {
376  if (*ne == '|') break;
377  }
378  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
379  if (*ne) ++ne;
380  }
381  return equiv;
382 }
383 
384 /*
385  Check type equivalence in a name list like <name1>|<name2>|...
386  Return 0 if not equal, 1 if equal
387 */
388 SWIGRUNTIME int
389 SWIG_TypeEquiv(const char *nb, const char *tb) {
390  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
391 }
392 
393 /*
394  Check the typename
395 */
397 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
398  if (ty) {
399  swig_cast_info *iter = ty->cast;
400  while (iter) {
401  if (strcmp(iter->type->name, c) == 0) {
402  if (iter == ty->cast)
403  return iter;
404  /* Move iter to the top of the linked list */
405  iter->prev->next = iter->next;
406  if (iter->next)
407  iter->next->prev = iter->prev;
408  iter->next = ty->cast;
409  iter->prev = 0;
410  if (ty->cast) ty->cast->prev = iter;
411  ty->cast = iter;
412  return iter;
413  }
414  iter = iter->next;
415  }
416  }
417  return 0;
418 }
419 
420 /*
421  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
422 */
425  if (ty) {
426  swig_cast_info *iter = ty->cast;
427  while (iter) {
428  if (iter->type == from) {
429  if (iter == ty->cast)
430  return iter;
431  /* Move iter to the top of the linked list */
432  iter->prev->next = iter->next;
433  if (iter->next)
434  iter->next->prev = iter->prev;
435  iter->next = ty->cast;
436  iter->prev = 0;
437  if (ty->cast) ty->cast->prev = iter;
438  ty->cast = iter;
439  return iter;
440  }
441  iter = iter->next;
442  }
443  }
444  return 0;
445 }
446 
447 /*
448  Cast a pointer up an inheritance hierarchy
449 */
450 SWIGRUNTIMEINLINE void *
451 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
452  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
453 }
454 
455 /*
456  Dynamic pointer casting. Down an inheritance hierarchy
457 */
460  swig_type_info *lastty = ty;
461  if (!ty || !ty->dcast) return ty;
462  while (ty && (ty->dcast)) {
463  ty = (*ty->dcast)(ptr);
464  if (ty) lastty = ty;
465  }
466  return lastty;
467 }
468 
469 /*
470  Return the name associated with this type
471 */
472 SWIGRUNTIMEINLINE const char *
474  return ty->name;
475 }
476 
477 /*
478  Return the pretty name associated with this type,
479  that is an unmangled type name in a form presentable to the user.
480 */
481 SWIGRUNTIME const char *
483  /* The "str" field contains the equivalent pretty names of the
484  type, separated by vertical-bar characters. We choose
485  to print the last name, as it is often (?) the most
486  specific. */
487  if (!type) return NULL;
488  if (type->str != NULL) {
489  const char *last_name = type->str;
490  const char *s;
491  for (s = type->str; *s; s++)
492  if (*s == '|') last_name = s+1;
493  return last_name;
494  }
495  else
496  return type->name;
497 }
498 
499 /*
500  Set the clientdata field for a type
501 */
502 SWIGRUNTIME void
504  swig_cast_info *cast = ti->cast;
505  /* if (ti->clientdata == clientdata) return; */
506  ti->clientdata = clientdata;
507 
508  while (cast) {
509  if (!cast->converter) {
510  swig_type_info *tc = cast->type;
511  if (!tc->clientdata) {
512  SWIG_TypeClientData(tc, clientdata);
513  }
514  }
515  cast = cast->next;
516  }
517 }
518 SWIGRUNTIME void
520  SWIG_TypeClientData(ti, clientdata);
521  ti->owndata = 1;
522 }
523 
524 /*
525  Search for a swig_type_info structure only by mangled name
526  Search is a O(log #types)
527 
528  We start searching at module start, and finish searching when start == end.
529  Note: if start == end at the beginning of the function, we go all the way around
530  the circular list.
531 */
534  swig_module_info *end,
535  const char *name) {
536  swig_module_info *iter = start;
537  do {
538  if (iter->size) {
539  register size_t l = 0;
540  register size_t r = iter->size - 1;
541  do {
542  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
543  register size_t i = (l + r) >> 1;
544  const char *iname = iter->types[i]->name;
545  if (iname) {
546  register int compare = strcmp(name, iname);
547  if (compare == 0) {
548  return iter->types[i];
549  } else if (compare < 0) {
550  if (i) {
551  r = i - 1;
552  } else {
553  break;
554  }
555  } else if (compare > 0) {
556  l = i + 1;
557  }
558  } else {
559  break; /* should never happen */
560  }
561  } while (l <= r);
562  }
563  iter = iter->next;
564  } while (iter != end);
565  return 0;
566 }
567 
568 /*
569  Search for a swig_type_info structure for either a mangled name or a human readable name.
570  It first searches the mangled names of the types, which is a O(log #types)
571  If a type is not found it then searches the human readable names, which is O(#types).
572 
573  We start searching at module start, and finish searching when start == end.
574  Note: if start == end at the beginning of the function, we go all the way around
575  the circular list.
576 */
579  swig_module_info *end,
580  const char *name) {
581  /* STEP 1: Search the name field using binary search */
582  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
583  if (ret) {
584  return ret;
585  } else {
586  /* STEP 2: If the type hasn't been found, do a complete search
587  of the str field (the human readable name) */
588  swig_module_info *iter = start;
589  do {
590  register size_t i = 0;
591  for (; i < iter->size; ++i) {
592  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
593  return iter->types[i];
594  }
595  iter = iter->next;
596  } while (iter != end);
597  }
598 
599  /* neither found a match */
600  return 0;
601 }
602 
603 /*
604  Pack binary data into a string
605 */
606 SWIGRUNTIME char *
607 SWIG_PackData(char *c, void *ptr, size_t sz) {
608  static const char hex[17] = "0123456789abcdef";
609  register const unsigned char *u = (unsigned char *) ptr;
610  register const unsigned char *eu = u + sz;
611  for (; u != eu; ++u) {
612  register unsigned char uu = *u;
613  *(c++) = hex[(uu & 0xf0) >> 4];
614  *(c++) = hex[uu & 0xf];
615  }
616  return c;
617 }
618 
619 /*
620  Unpack binary data from a string
621 */
622 SWIGRUNTIME const char *
623 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
624  register unsigned char *u = (unsigned char *) ptr;
625  register const unsigned char *eu = u + sz;
626  for (; u != eu; ++u) {
627  register char d = *(c++);
628  register unsigned char uu;
629  if ((d >= '0') && (d <= '9'))
630  uu = ((d - '0') << 4);
631  else if ((d >= 'a') && (d <= 'f'))
632  uu = ((d - ('a'-10)) << 4);
633  else
634  return (char *) 0;
635  d = *(c++);
636  if ((d >= '0') && (d <= '9'))
637  uu |= (d - '0');
638  else if ((d >= 'a') && (d <= 'f'))
639  uu |= (d - ('a'-10));
640  else
641  return (char *) 0;
642  *u = uu;
643  }
644  return c;
645 }
646 
647 /*
648  Pack 'void *' into a string buffer.
649 */
650 SWIGRUNTIME char *
651 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
652  char *r = buff;
653  if ((2*sizeof(void *) + 2) > bsz) return 0;
654  *(r++) = '_';
655  r = SWIG_PackData(r,&ptr,sizeof(void *));
656  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
657  strcpy(r,name);
658  return buff;
659 }
660 
661 SWIGRUNTIME const char *
662 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
663  if (*c != '_') {
664  if (strcmp(c,"NULL") == 0) {
665  *ptr = (void *) 0;
666  return name;
667  } else {
668  return 0;
669  }
670  }
671  return SWIG_UnpackData(++c,ptr,sizeof(void *));
672 }
673 
674 SWIGRUNTIME char *
675 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
676  char *r = buff;
677  size_t lname = (name ? strlen(name) : 0);
678  if ((2*sz + 2 + lname) > bsz) return 0;
679  *(r++) = '_';
680  r = SWIG_PackData(r,ptr,sz);
681  if (lname) {
682  strncpy(r,name,lname+1);
683  } else {
684  *r = 0;
685  }
686  return buff;
687 }
688 
689 SWIGRUNTIME const char *
690 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
691  if (*c != '_') {
692  if (strcmp(c,"NULL") == 0) {
693  memset(ptr,0,sz);
694  return name;
695  } else {
696  return 0;
697  }
698  }
699  return SWIG_UnpackData(++c,ptr,sz);
700 }
701 
702 #ifdef __cplusplus
703 }
704 #endif
705 
706 /* Errors in SWIG */
707 #define SWIG_UnknownError -1
708 #define SWIG_IOError -2
709 #define SWIG_RuntimeError -3
710 #define SWIG_IndexError -4
711 #define SWIG_TypeError -5
712 #define SWIG_DivisionByZero -6
713 #define SWIG_OverflowError -7
714 #define SWIG_SyntaxError -8
715 #define SWIG_ValueError -9
716 #define SWIG_SystemError -10
717 #define SWIG_AttributeError -11
718 #define SWIG_MemoryError -12
719 #define SWIG_NullReferenceError -13
720 
721 
722 
723 /* Compatibility macros for Python 3 */
724 #if PY_VERSION_HEX >= 0x03000000
725 
726 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
727 #define PyInt_Check(x) PyLong_Check(x)
728 #define PyInt_AsLong(x) PyLong_AsLong(x)
729 #define PyInt_FromLong(x) PyLong_FromLong(x)
730 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
731 #define PyString_Check(name) PyBytes_Check(name)
732 #define PyString_FromString(x) PyUnicode_FromString(x)
733 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
734 #define PyString_AsString(str) PyBytes_AsString(str)
735 #define PyString_Size(str) PyBytes_Size(str)
736 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
737 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
738 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
739 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
740 
741 #endif
742 
743 #ifndef Py_TYPE
744 # define Py_TYPE(op) ((op)->ob_type)
745 #endif
746 
747 /* SWIG APIs for compatibility of both Python 2 & 3 */
748 
749 #if PY_VERSION_HEX >= 0x03000000
750 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
751 #else
752 # define SWIG_Python_str_FromFormat PyString_FromFormat
753 #endif
754 
755 
756 /* Warning: This function will allocate a new string in Python 3,
757  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
758  */
759 SWIGINTERN char*
761 {
762 #if PY_VERSION_HEX >= 0x03000000
763  char *cstr;
764  char *newstr;
765  Py_ssize_t len;
766  str = PyUnicode_AsUTF8String(str);
767  PyBytes_AsStringAndSize(str, &cstr, &len);
768  newstr = (char *) malloc(len+1);
769  memcpy(newstr, cstr, len+1);
770  Py_XDECREF(str);
771  return newstr;
772 #else
773  return PyString_AsString(str);
774 #endif
775 }
776 
777 #if PY_VERSION_HEX >= 0x03000000
778 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
779 #else
780 # define SWIG_Python_str_DelForPy3(x)
781 #endif
782 
783 
784 SWIGINTERN PyObject*
786 {
787 #if PY_VERSION_HEX >= 0x03000000
788  return PyUnicode_FromString(c);
789 #else
790  return PyString_FromString(c);
791 #endif
792 }
793 
794 /* Add PyOS_snprintf for old Pythons */
795 #if PY_VERSION_HEX < 0x02020000
796 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
797 # define PyOS_snprintf _snprintf
798 # else
799 # define PyOS_snprintf snprintf
800 # endif
801 #endif
802 
803 /* A crude PyString_FromFormat implementation for old Pythons */
804 #if PY_VERSION_HEX < 0x02020000
805 
806 #ifndef SWIG_PYBUFFER_SIZE
807 # define SWIG_PYBUFFER_SIZE 1024
808 #endif
809 
810 static PyObject *
811 PyString_FromFormat(const char *fmt, ...) {
812  va_list ap;
813  char buf[SWIG_PYBUFFER_SIZE * 2];
814  int res;
815  va_start(ap, fmt);
816  res = vsnprintf(buf, sizeof(buf), fmt, ap);
817  va_end(ap);
818  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
819 }
820 #endif
821 
822 /* Add PyObject_Del for old Pythons */
823 #if PY_VERSION_HEX < 0x01060000
824 # define PyObject_Del(op) PyMem_DEL((op))
825 #endif
826 #ifndef PyObject_DEL
827 # define PyObject_DEL PyObject_Del
828 #endif
829 
830 /* A crude PyExc_StopIteration exception for old Pythons */
831 #if PY_VERSION_HEX < 0x02020000
832 # ifndef PyExc_StopIteration
833 # define PyExc_StopIteration PyExc_RuntimeError
834 # endif
835 # ifndef PyObject_GenericGetAttr
836 # define PyObject_GenericGetAttr 0
837 # endif
838 #endif
839 
840 /* Py_NotImplemented is defined in 2.1 and up. */
841 #if PY_VERSION_HEX < 0x02010000
842 # ifndef Py_NotImplemented
843 # define Py_NotImplemented PyExc_RuntimeError
844 # endif
845 #endif
846 
847 /* A crude PyString_AsStringAndSize implementation for old Pythons */
848 #if PY_VERSION_HEX < 0x02010000
849 # ifndef PyString_AsStringAndSize
850 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
851 # endif
852 #endif
853 
854 /* PySequence_Size for old Pythons */
855 #if PY_VERSION_HEX < 0x02000000
856 # ifndef PySequence_Size
857 # define PySequence_Size PySequence_Length
858 # endif
859 #endif
860 
861 /* PyBool_FromLong for old Pythons */
862 #if PY_VERSION_HEX < 0x02030000
863 static
864 PyObject *PyBool_FromLong(long ok)
865 {
866  PyObject *result = ok ? Py_True : Py_False;
867  Py_INCREF(result);
868  return result;
869 }
870 #endif
871 
872 /* Py_ssize_t for old Pythons */
873 /* This code is as recommended by: */
874 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
875 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
876 typedef int Py_ssize_t;
877 # define PY_SSIZE_T_MAX INT_MAX
878 # define PY_SSIZE_T_MIN INT_MIN
879 typedef inquiry lenfunc;
880 typedef intargfunc ssizeargfunc;
881 typedef intintargfunc ssizessizeargfunc;
882 typedef intobjargproc ssizeobjargproc;
883 typedef intintobjargproc ssizessizeobjargproc;
884 typedef getreadbufferproc readbufferproc;
885 typedef getwritebufferproc writebufferproc;
886 typedef getsegcountproc segcountproc;
887 typedef getcharbufferproc charbufferproc;
888 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
889 {
890  long result = 0;
891  PyObject *i = PyNumber_Int(x);
892  if (i) {
893  result = PyInt_AsLong(i);
894  Py_DECREF(i);
895  }
896  return result;
897 }
898 #endif
899 
900 #if PY_VERSION_HEX < 0x02050000
901 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
902 #endif
903 
904 #if PY_VERSION_HEX < 0x02040000
905 #define Py_VISIT(op) \
906  do { \
907  if (op) { \
908  int vret = visit((op), arg); \
909  if (vret) \
910  return vret; \
911  } \
912  } while (0)
913 #endif
914 
915 #if PY_VERSION_HEX < 0x02030000
916 typedef struct {
917  PyTypeObject type;
918  PyNumberMethods as_number;
919  PyMappingMethods as_mapping;
920  PySequenceMethods as_sequence;
921  PyBufferProcs as_buffer;
922  PyObject *name, *slots;
924 #endif
925 
926 #if PY_VERSION_HEX < 0x02030000
927 typedef destructor freefunc;
928 #endif
929 
930 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
931  (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
932  (PY_MAJOR_VERSION > 3))
933 # define SWIGPY_USE_CAPSULE
934 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
935 #endif
936 
937 #if PY_VERSION_HEX < 0x03020000
938 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
939 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
940 #endif
941 
942 /* -----------------------------------------------------------------------------
943  * error manipulation
944  * ----------------------------------------------------------------------------- */
945 
946 SWIGRUNTIME PyObject*
948  PyObject* type = 0;
949  switch(code) {
950  case SWIG_MemoryError:
951  type = PyExc_MemoryError;
952  break;
953  case SWIG_IOError:
954  type = PyExc_IOError;
955  break;
956  case SWIG_RuntimeError:
957  type = PyExc_RuntimeError;
958  break;
959  case SWIG_IndexError:
960  type = PyExc_IndexError;
961  break;
962  case SWIG_TypeError:
963  type = PyExc_TypeError;
964  break;
965  case SWIG_DivisionByZero:
966  type = PyExc_ZeroDivisionError;
967  break;
968  case SWIG_OverflowError:
969  type = PyExc_OverflowError;
970  break;
971  case SWIG_SyntaxError:
972  type = PyExc_SyntaxError;
973  break;
974  case SWIG_ValueError:
975  type = PyExc_ValueError;
976  break;
977  case SWIG_SystemError:
978  type = PyExc_SystemError;
979  break;
980  case SWIG_AttributeError:
981  type = PyExc_AttributeError;
982  break;
983  default:
984  type = PyExc_RuntimeError;
985  }
986  return type;
987 }
988 
989 
990 SWIGRUNTIME void
991 SWIG_Python_AddErrorMsg(const char* mesg)
992 {
993  PyObject *type = 0;
994  PyObject *value = 0;
995  PyObject *traceback = 0;
996 
997  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
998  if (value) {
999  char *tmp;
1000  PyObject *old_str = PyObject_Str(value);
1001  PyErr_Clear();
1002  Py_XINCREF(type);
1003 
1004  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1006  Py_DECREF(old_str);
1007  Py_DECREF(value);
1008  } else {
1009  PyErr_SetString(PyExc_RuntimeError, mesg);
1010  }
1011 }
1012 
1013 #if defined(SWIG_PYTHON_NO_THREADS)
1014 # if defined(SWIG_PYTHON_THREADS)
1015 # undef SWIG_PYTHON_THREADS
1016 # endif
1017 #endif
1018 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1019 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1020 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1021 # define SWIG_PYTHON_USE_GIL
1022 # endif
1023 # endif
1024 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1025 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1026 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1027 # endif
1028 # ifdef __cplusplus /* C++ code */
1029  class SWIG_Python_Thread_Block {
1030  bool status;
1031  PyGILState_STATE state;
1032  public:
1033  void end() { if (status) { PyGILState_Release(state); status = false;} }
1034  SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1035  ~SWIG_Python_Thread_Block() { end(); }
1036  };
1037  class SWIG_Python_Thread_Allow {
1038  bool status;
1039  PyThreadState *save;
1040  public:
1041  void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1042  SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1043  ~SWIG_Python_Thread_Allow() { end(); }
1044  };
1045 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1046 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1047 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1048 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1049 # else /* C code */
1050 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1051 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1052 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1053 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1054 # endif
1055 # else /* Old thread way, not implemented, user must provide it */
1056 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1057 # define SWIG_PYTHON_INITIALIZE_THREADS
1058 # endif
1059 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1060 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1061 # endif
1062 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1063 # define SWIG_PYTHON_THREAD_END_BLOCK
1064 # endif
1065 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1066 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1067 # endif
1068 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1069 # define SWIG_PYTHON_THREAD_END_ALLOW
1070 # endif
1071 # endif
1072 #else /* No thread support */
1073 # define SWIG_PYTHON_INITIALIZE_THREADS
1074 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1075 # define SWIG_PYTHON_THREAD_END_BLOCK
1076 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1077 # define SWIG_PYTHON_THREAD_END_ALLOW
1078 #endif
1079 
1080 /* -----------------------------------------------------------------------------
1081  * Python API portion that goes into the runtime
1082  * ----------------------------------------------------------------------------- */
1083 
1084 #ifdef __cplusplus
1085 extern "C" {
1086 #endif
1087 
1088 /* -----------------------------------------------------------------------------
1089  * Constant declarations
1090  * ----------------------------------------------------------------------------- */
1091 
1092 /* Constant Types */
1093 #define SWIG_PY_POINTER 4
1094 #define SWIG_PY_BINARY 5
1095 
1096 /* Constant information structure */
1097 typedef struct swig_const_info {
1098  int type;
1099  char *name;
1100  long lvalue;
1101  double dvalue;
1102  void *pvalue;
1104 } swig_const_info;
1105 
1106 
1107 /* -----------------------------------------------------------------------------
1108  * Wrapper of PyInstanceMethod_New() used in Python 3
1109  * It is exported to the generated module, used for -fastproxy
1110  * ----------------------------------------------------------------------------- */
1111 #if PY_VERSION_HEX >= 0x03000000
1112 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1113 {
1114  return PyInstanceMethod_New(func);
1115 }
1116 #else
1117 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1118 {
1119  return NULL;
1120 }
1121 #endif
1122 
1123 #ifdef __cplusplus
1124 }
1125 #endif
1126 
1127 
1128 /* -----------------------------------------------------------------------------
1129  * pyrun.swg
1130  *
1131  * This file contains the runtime support for Python modules
1132  * and includes code for managing global variables and pointer
1133  * type checking.
1134  *
1135  * ----------------------------------------------------------------------------- */
1136 
1137 /* Common SWIG API */
1138 
1139 /* for raw pointers */
1140 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1141 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1142 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1143 
1144 #ifdef SWIGPYTHON_BUILTIN
1145 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1146 #else
1147 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1148 #endif
1149 
1150 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1151 
1152 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1153 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1154 #define swig_owntype int
1155 
1156 /* for raw packed data */
1157 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1158 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1159 
1160 /* for class or struct pointers */
1161 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1162 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1163 
1164 /* for C or C++ function pointers */
1165 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1166 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1167 
1168 /* for C++ member pointers, ie, member methods */
1169 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1170 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1171 
1172 
1173 /* Runtime API */
1174 
1175 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1176 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1177 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1178 
1179 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1180 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1181 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1182 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1183 #define SWIG_fail goto fail
1184 
1185 
1186 /* Runtime API implementation */
1187 
1188 /* Error manipulation */
1189 
1190 SWIGINTERN void
1191 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1193  PyErr_SetObject(errtype, obj);
1194  Py_DECREF(obj);
1196 }
1197 
1198 SWIGINTERN void
1199 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1201  PyErr_SetString(errtype, msg);
1203 }
1204 
1205 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1206 
1207 /* Set a constant value */
1208 
1209 #if defined(SWIGPYTHON_BUILTIN)
1210 
1211 SWIGINTERN void
1212 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1213  PyObject *s = PyString_InternFromString(key);
1214  PyList_Append(seq, s);
1215  Py_DECREF(s);
1216 }
1217 
1218 SWIGINTERN void
1219 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1220 #if PY_VERSION_HEX < 0x02030000
1221  PyDict_SetItemString(d, (char *)name, obj);
1222 #else
1223  PyDict_SetItemString(d, name, obj);
1224 #endif
1225  Py_DECREF(obj);
1226  if (public_interface)
1227  SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1228 }
1229 
1230 #else
1231 
1232 SWIGINTERN void
1233 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1234 #if PY_VERSION_HEX < 0x02030000
1235  PyDict_SetItemString(d, (char *)name, obj);
1236 #else
1237  PyDict_SetItemString(d, name, obj);
1238 #endif
1239  Py_DECREF(obj);
1240 }
1241 
1242 #endif
1243 
1244 /* Append a value to the result obj */
1245 
1246 SWIGINTERN PyObject*
1247 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1248 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1249  if (!result) {
1250  result = obj;
1251  } else if (result == Py_None) {
1252  Py_DECREF(result);
1253  result = obj;
1254  } else {
1255  if (!PyList_Check(result)) {
1256  PyObject *o2 = result;
1257  result = PyList_New(1);
1258  PyList_SetItem(result, 0, o2);
1259  }
1260  PyList_Append(result,obj);
1261  Py_DECREF(obj);
1262  }
1263  return result;
1264 #else
1265  PyObject* o2;
1266  PyObject* o3;
1267  if (!result) {
1268  result = obj;
1269  } else if (result == Py_None) {
1270  Py_DECREF(result);
1271  result = obj;
1272  } else {
1273  if (!PyTuple_Check(result)) {
1274  o2 = result;
1275  result = PyTuple_New(1);
1276  PyTuple_SET_ITEM(result, 0, o2);
1277  }
1278  o3 = PyTuple_New(1);
1279  PyTuple_SET_ITEM(o3, 0, obj);
1280  o2 = result;
1281  result = PySequence_Concat(o2, o3);
1282  Py_DECREF(o2);
1283  Py_DECREF(o3);
1284  }
1285  return result;
1286 #endif
1287 }
1288 
1289 /* Unpack the argument tuple */
1290 
1291 SWIGINTERN int
1292 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1293 {
1294  if (!args) {
1295  if (!min && !max) {
1296  return 1;
1297  } else {
1298  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1299  name, (min == max ? "" : "at least "), (int)min);
1300  return 0;
1301  }
1302  }
1303  if (!PyTuple_Check(args)) {
1304  if (min <= 1 && max >= 1) {
1305  register int i;
1306  objs[0] = args;
1307  for (i = 1; i < max; ++i) {
1308  objs[i] = 0;
1309  }
1310  return 2;
1311  }
1312  PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1313  return 0;
1314  } else {
1315  register Py_ssize_t l = PyTuple_GET_SIZE(args);
1316  if (l < min) {
1317  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1318  name, (min == max ? "" : "at least "), (int)min, (int)l);
1319  return 0;
1320  } else if (l > max) {
1321  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1322  name, (min == max ? "" : "at most "), (int)max, (int)l);
1323  return 0;
1324  } else {
1325  register int i;
1326  for (i = 0; i < l; ++i) {
1327  objs[i] = PyTuple_GET_ITEM(args, i);
1328  }
1329  for (; l < max; ++l) {
1330  objs[l] = 0;
1331  }
1332  return i + 1;
1333  }
1334  }
1335 }
1336 
1337 /* A functor is a function object with one single object argument */
1338 #if PY_VERSION_HEX >= 0x02020000
1339 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1340 #else
1341 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1342 #endif
1343 
1344 /*
1345  Helper for static pointer initialization for both C and C++ code, for example
1346  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1347 */
1348 #ifdef __cplusplus
1349 #define SWIG_STATIC_POINTER(var) var
1350 #else
1351 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1352 #endif
1353 
1354 /* -----------------------------------------------------------------------------
1355  * Pointer declarations
1356  * ----------------------------------------------------------------------------- */
1357 
1358 /* Flags for new pointer objects */
1359 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1360 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1361 
1362 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1363 
1364 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1365 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1366 
1367 #ifdef __cplusplus
1368 extern "C" {
1369 #endif
1370 
1371 /* How to access Py_None */
1372 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1373 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1374 # ifndef SWIG_PYTHON_BUILD_NONE
1375 # define SWIG_PYTHON_BUILD_NONE
1376 # endif
1377 # endif
1378 #endif
1379 
1380 #ifdef SWIG_PYTHON_BUILD_NONE
1381 # ifdef Py_None
1382 # undef Py_None
1383 # define Py_None SWIG_Py_None()
1384 # endif
1385 SWIGRUNTIMEINLINE PyObject *
1386 _SWIG_Py_None(void)
1387 {
1388  PyObject *none = Py_BuildValue((char*)"");
1389  Py_DECREF(none);
1390  return none;
1391 }
1392 SWIGRUNTIME PyObject *
1393 SWIG_Py_None(void)
1394 {
1395  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1396  return none;
1397 }
1398 #endif
1399 
1400 /* The python void return value */
1401 
1402 SWIGRUNTIMEINLINE PyObject *
1404 {
1405  PyObject *none = Py_None;
1406  Py_INCREF(none);
1407  return none;
1408 }
1409 
1410 /* SwigPyClientData */
1411 
1412 typedef struct {
1413  PyObject *klass;
1414  PyObject *newraw;
1415  PyObject *newargs;
1416  PyObject *destroy;
1417  int delargs;
1419  PyTypeObject *pytype;
1421 
1422 SWIGRUNTIMEINLINE int
1424 {
1426  return data ? data->implicitconv : 0;
1427 }
1428 
1429 SWIGRUNTIMEINLINE PyObject *
1431  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1432  PyObject *klass = data ? data->klass : 0;
1433  return (klass ? klass : PyExc_RuntimeError);
1434 }
1435 
1436 
1438 SwigPyClientData_New(PyObject* obj)
1439 {
1440  if (!obj) {
1441  return 0;
1442  } else {
1443  SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1444  /* the klass element */
1445  data->klass = obj;
1446  Py_INCREF(data->klass);
1447  /* the newraw method and newargs arguments used to create a new raw instance */
1448  if (PyClass_Check(obj)) {
1449  data->newraw = 0;
1450  data->newargs = obj;
1451  Py_INCREF(obj);
1452  } else {
1453 #if (PY_VERSION_HEX < 0x02020000)
1454  data->newraw = 0;
1455 #else
1456  data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1457 #endif
1458  if (data->newraw) {
1459  Py_INCREF(data->newraw);
1460  data->newargs = PyTuple_New(1);
1461  PyTuple_SetItem(data->newargs, 0, obj);
1462  } else {
1463  data->newargs = obj;
1464  }
1465  Py_INCREF(data->newargs);
1466  }
1467  /* the destroy method, aka as the C++ delete method */
1468  data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1469  if (PyErr_Occurred()) {
1470  PyErr_Clear();
1471  data->destroy = 0;
1472  }
1473  if (data->destroy) {
1474  int flags;
1475  Py_INCREF(data->destroy);
1476  flags = PyCFunction_GET_FLAGS(data->destroy);
1477 #ifdef METH_O
1478  data->delargs = !(flags & (METH_O));
1479 #else
1480  data->delargs = 0;
1481 #endif
1482  } else {
1483  data->delargs = 0;
1484  }
1485  data->implicitconv = 0;
1486  data->pytype = 0;
1487  return data;
1488  }
1489 }
1490 
1491 SWIGRUNTIME void
1493  Py_XDECREF(data->newraw);
1494  Py_XDECREF(data->newargs);
1495  Py_XDECREF(data->destroy);
1496 }
1497 
1498 /* =============== SwigPyObject =====================*/
1499 
1500 typedef struct {
1501  PyObject_HEAD
1502  void *ptr;
1504  int own;
1505  PyObject *next;
1506 #ifdef SWIGPYTHON_BUILTIN
1507  PyObject *dict;
1508 #endif
1509 } SwigPyObject;
1510 
1511 SWIGRUNTIME PyObject *
1513 {
1514  return PyLong_FromVoidPtr(v->ptr);
1515 }
1516 
1517 SWIGRUNTIME PyObject *
1518 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1519 {
1520  PyObject *res = NULL;
1521  PyObject *args = PyTuple_New(1);
1522  if (args) {
1523  if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1524  PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1525  if (ofmt) {
1526 #if PY_VERSION_HEX >= 0x03000000
1527  res = PyUnicode_Format(ofmt,args);
1528 #else
1529  res = PyString_Format(ofmt,args);
1530 #endif
1531  Py_DECREF(ofmt);
1532  }
1533  Py_DECREF(args);
1534  }
1535  }
1536  return res;
1537 }
1538 
1539 SWIGRUNTIME PyObject *
1541 {
1542  return SwigPyObject_format("%o",v);
1543 }
1544 
1545 SWIGRUNTIME PyObject *
1547 {
1548  return SwigPyObject_format("%x",v);
1549 }
1550 
1551 SWIGRUNTIME PyObject *
1552 #ifdef METH_NOARGS
1554 #else
1555 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1556 #endif
1557 {
1558  const char *name = SWIG_TypePrettyName(v->ty);
1559  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1560  if (v->next) {
1561 # ifdef METH_NOARGS
1562  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1563 # else
1564  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1565 # endif
1566 # if PY_VERSION_HEX >= 0x03000000
1567  PyObject *joined = PyUnicode_Concat(repr, nrep);
1568  Py_DecRef(repr);
1569  Py_DecRef(nrep);
1570  repr = joined;
1571 # else
1572  PyString_ConcatAndDel(&repr,nrep);
1573 # endif
1574  }
1575  return repr;
1576 }
1577 
1578 SWIGRUNTIME int
1580 {
1581  void *i = v->ptr;
1582  void *j = w->ptr;
1583  return (i < j) ? -1 : ((i > j) ? 1 : 0);
1584 }
1585 
1586 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1587 SWIGRUNTIME PyObject*
1589 {
1590  PyObject* res;
1591  if( op != Py_EQ && op != Py_NE ) {
1592  Py_INCREF(Py_NotImplemented);
1593  return Py_NotImplemented;
1594  }
1595  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1596  return res;
1597 }
1598 
1599 
1600 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1601 
1602 #ifdef SWIGPYTHON_BUILTIN
1603 static swig_type_info *SwigPyObject_stype = 0;
1604 SWIGRUNTIME PyTypeObject*
1605 SwigPyObject_type(void) {
1606  SwigPyClientData *cd;
1607  assert(SwigPyObject_stype);
1608  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1609  assert(cd);
1610  assert(cd->pytype);
1611  return cd->pytype;
1612 }
1613 #else
1614 SWIGRUNTIME PyTypeObject*
1616  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1617  return type;
1618 }
1619 #endif
1620 
1622 SwigPyObject_Check(PyObject *op) {
1623 #ifdef SWIGPYTHON_BUILTIN
1624  PyTypeObject *target_tp = SwigPyObject_type();
1625  if (PyType_IsSubtype(op->ob_type, target_tp))
1626  return 1;
1627  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1628 #else
1629  return (Py_TYPE(op) == SwigPyObject_type())
1630  || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1631 #endif
1632 }
1633 
1634 SWIGRUNTIME PyObject *
1635 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1636 
1637 SWIGRUNTIME void
1639 {
1640  SwigPyObject *sobj = (SwigPyObject *) v;
1641  PyObject *next = sobj->next;
1642  if (sobj->own == SWIG_POINTER_OWN) {
1643  swig_type_info *ty = sobj->ty;
1644  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1645  PyObject *destroy = data ? data->destroy : 0;
1646  if (destroy) {
1647  /* destroy is always a VARARGS method */
1648  PyObject *res;
1649  if (data->delargs) {
1650  /* we need to create a temporary object to carry the destroy operation */
1651  PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1652  res = SWIG_Python_CallFunctor(destroy, tmp);
1653  Py_DECREF(tmp);
1654  } else {
1655  PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1656  PyObject *mself = PyCFunction_GET_SELF(destroy);
1657  res = ((*meth)(mself, v));
1658  }
1659  Py_XDECREF(res);
1660  }
1661 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1662  else {
1663  const char *name = SWIG_TypePrettyName(ty);
1664  printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1665  }
1666 #endif
1667  }
1668  Py_XDECREF(next);
1669  PyObject_DEL(v);
1670 }
1671 
1672 SWIGRUNTIME PyObject*
1673 SwigPyObject_append(PyObject* v, PyObject* next)
1674 {
1675  SwigPyObject *sobj = (SwigPyObject *) v;
1676 #ifndef METH_O
1677  PyObject *tmp = 0;
1678  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1679  next = tmp;
1680 #endif
1681  if (!SwigPyObject_Check(next)) {
1682  return NULL;
1683  }
1684  sobj->next = next;
1685  Py_INCREF(next);
1686  return SWIG_Py_Void();
1687 }
1688 
1689 SWIGRUNTIME PyObject*
1690 #ifdef METH_NOARGS
1691 SwigPyObject_next(PyObject* v)
1692 #else
1693 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1694 #endif
1695 {
1696  SwigPyObject *sobj = (SwigPyObject *) v;
1697  if (sobj->next) {
1698  Py_INCREF(sobj->next);
1699  return sobj->next;
1700  } else {
1701  return SWIG_Py_Void();
1702  }
1703 }
1704 
1705 SWIGINTERN PyObject*
1706 #ifdef METH_NOARGS
1707 SwigPyObject_disown(PyObject *v)
1708 #else
1709 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1710 #endif
1711 {
1712  SwigPyObject *sobj = (SwigPyObject *)v;
1713  sobj->own = 0;
1714  return SWIG_Py_Void();
1715 }
1716 
1717 SWIGINTERN PyObject*
1718 #ifdef METH_NOARGS
1719 SwigPyObject_acquire(PyObject *v)
1720 #else
1721 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1722 #endif
1723 {
1724  SwigPyObject *sobj = (SwigPyObject *)v;
1725  sobj->own = SWIG_POINTER_OWN;
1726  return SWIG_Py_Void();
1727 }
1728 
1729 SWIGINTERN PyObject*
1730 SwigPyObject_own(PyObject *v, PyObject *args)
1731 {
1732  PyObject *val = 0;
1733 #if (PY_VERSION_HEX < 0x02020000)
1734  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1735 #elif (PY_VERSION_HEX < 0x02050000)
1736  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1737 #else
1738  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1739 #endif
1740  {
1741  return NULL;
1742  }
1743  else
1744  {
1745  SwigPyObject *sobj = (SwigPyObject *)v;
1746  PyObject *obj = PyBool_FromLong(sobj->own);
1747  if (val) {
1748 #ifdef METH_NOARGS
1749  if (PyObject_IsTrue(val)) {
1751  } else {
1753  }
1754 #else
1755  if (PyObject_IsTrue(val)) {
1756  SwigPyObject_acquire(v,args);
1757  } else {
1758  SwigPyObject_disown(v,args);
1759  }
1760 #endif
1761  }
1762  return obj;
1763  }
1764 }
1765 
1766 #ifdef METH_O
1767 static PyMethodDef
1768 swigobject_methods[] = {
1769  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1770  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
1771  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1772  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1773  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1774  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1775  {0, 0, 0, 0}
1776 };
1777 #else
1778 static PyMethodDef
1779 swigobject_methods[] = {
1780  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1781  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1782  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1783  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1784  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1785  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1786  {0, 0, 0, 0}
1787 };
1788 #endif
1789 
1790 #if PY_VERSION_HEX < 0x02020000
1791 SWIGINTERN PyObject *
1793 {
1794  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1795 }
1796 #endif
1797 
1798 SWIGRUNTIME PyTypeObject*
1800  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1801 
1802  static PyNumberMethods SwigPyObject_as_number = {
1803  (binaryfunc)0, /*nb_add*/
1804  (binaryfunc)0, /*nb_subtract*/
1805  (binaryfunc)0, /*nb_multiply*/
1806  /* nb_divide removed in Python 3 */
1807 #if PY_VERSION_HEX < 0x03000000
1808  (binaryfunc)0, /*nb_divide*/
1809 #endif
1810  (binaryfunc)0, /*nb_remainder*/
1811  (binaryfunc)0, /*nb_divmod*/
1812  (ternaryfunc)0,/*nb_power*/
1813  (unaryfunc)0, /*nb_negative*/
1814  (unaryfunc)0, /*nb_positive*/
1815  (unaryfunc)0, /*nb_absolute*/
1816  (inquiry)0, /*nb_nonzero*/
1817  0, /*nb_invert*/
1818  0, /*nb_lshift*/
1819  0, /*nb_rshift*/
1820  0, /*nb_and*/
1821  0, /*nb_xor*/
1822  0, /*nb_or*/
1823 #if PY_VERSION_HEX < 0x03000000
1824  0, /*nb_coerce*/
1825 #endif
1826  (unaryfunc)SwigPyObject_long, /*nb_int*/
1827 #if PY_VERSION_HEX < 0x03000000
1828  (unaryfunc)SwigPyObject_long, /*nb_long*/
1829 #else
1830  0, /*nb_reserved*/
1831 #endif
1832  (unaryfunc)0, /*nb_float*/
1833 #if PY_VERSION_HEX < 0x03000000
1834  (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1835  (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1836 #endif
1837 #if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1838  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1839 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1840  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1841 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1842  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1843 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1844  0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1845 #endif
1846  };
1847 
1848  static PyTypeObject swigpyobject_type;
1849  static int type_init = 0;
1850  if (!type_init) {
1851  const PyTypeObject tmp = {
1852  /* PyObject header changed in Python 3 */
1853 #if PY_VERSION_HEX >= 0x03000000
1854  PyVarObject_HEAD_INIT(NULL, 0)
1855 #else
1856  PyObject_HEAD_INIT(NULL)
1857  0, /* ob_size */
1858 #endif
1859  (char *)"SwigPyObject", /* tp_name */
1860  sizeof(SwigPyObject), /* tp_basicsize */
1861  0, /* tp_itemsize */
1862  (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1863  0, /* tp_print */
1864 #if PY_VERSION_HEX < 0x02020000
1865  (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1866 #else
1867  (getattrfunc)0, /* tp_getattr */
1868 #endif
1869  (setattrfunc)0, /* tp_setattr */
1870 #if PY_VERSION_HEX >= 0x03000000
1871  0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1872 #else
1873  (cmpfunc)SwigPyObject_compare, /* tp_compare */
1874 #endif
1875  (reprfunc)SwigPyObject_repr, /* tp_repr */
1876  &SwigPyObject_as_number, /* tp_as_number */
1877  0, /* tp_as_sequence */
1878  0, /* tp_as_mapping */
1879  (hashfunc)0, /* tp_hash */
1880  (ternaryfunc)0, /* tp_call */
1881  0, /* tp_str */
1882  PyObject_GenericGetAttr, /* tp_getattro */
1883  0, /* tp_setattro */
1884  0, /* tp_as_buffer */
1885  Py_TPFLAGS_DEFAULT, /* tp_flags */
1886  swigobject_doc, /* tp_doc */
1887  0, /* tp_traverse */
1888  0, /* tp_clear */
1889  (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1890  0, /* tp_weaklistoffset */
1891 #if PY_VERSION_HEX >= 0x02020000
1892  0, /* tp_iter */
1893  0, /* tp_iternext */
1894  swigobject_methods, /* tp_methods */
1895  0, /* tp_members */
1896  0, /* tp_getset */
1897  0, /* tp_base */
1898  0, /* tp_dict */
1899  0, /* tp_descr_get */
1900  0, /* tp_descr_set */
1901  0, /* tp_dictoffset */
1902  0, /* tp_init */
1903  0, /* tp_alloc */
1904  0, /* tp_new */
1905  0, /* tp_free */
1906  0, /* tp_is_gc */
1907  0, /* tp_bases */
1908  0, /* tp_mro */
1909  0, /* tp_cache */
1910  0, /* tp_subclasses */
1911  0, /* tp_weaklist */
1912 #endif
1913 #if PY_VERSION_HEX >= 0x02030000
1914  0, /* tp_del */
1915 #endif
1916 #if PY_VERSION_HEX >= 0x02060000
1917  0, /* tp_version */
1918 #endif
1919 #ifdef COUNT_ALLOCS
1920  0,0,0,0 /* tp_alloc -> tp_next */
1921 #endif
1922  };
1923  swigpyobject_type = tmp;
1924  type_init = 1;
1925 #if PY_VERSION_HEX < 0x02020000
1926  swigpyobject_type.ob_type = &PyType_Type;
1927 #else
1928  if (PyType_Ready(&swigpyobject_type) < 0)
1929  return NULL;
1930 #endif
1931  }
1932  return &swigpyobject_type;
1933 }
1934 
1935 SWIGRUNTIME PyObject *
1936 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1937 {
1938  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1939  if (sobj) {
1940  sobj->ptr = ptr;
1941  sobj->ty = ty;
1942  sobj->own = own;
1943  sobj->next = 0;
1944  }
1945  return (PyObject *)sobj;
1946 }
1947 
1948 /* -----------------------------------------------------------------------------
1949  * Implements a simple Swig Packed type, and use it instead of string
1950  * ----------------------------------------------------------------------------- */
1951 
1952 typedef struct {
1953  PyObject_HEAD
1954  void *pack;
1956  size_t size;
1957 } SwigPyPacked;
1958 
1959 SWIGRUNTIME int
1961 {
1962  char result[SWIG_BUFFER_SIZE];
1963  fputs("<Swig Packed ", fp);
1964  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1965  fputs("at ", fp);
1966  fputs(result, fp);
1967  }
1968  fputs(v->ty->name,fp);
1969  fputs(">", fp);
1970  return 0;
1971 }
1972 
1973 SWIGRUNTIME PyObject *
1975 {
1976  char result[SWIG_BUFFER_SIZE];
1977  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1978  return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1979  } else {
1980  return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1981  }
1982 }
1983 
1984 SWIGRUNTIME PyObject *
1986 {
1987  char result[SWIG_BUFFER_SIZE];
1988  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1989  return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1990  } else {
1991  return SWIG_Python_str_FromChar(v->ty->name);
1992  }
1993 }
1994 
1995 SWIGRUNTIME int
1997 {
1998  size_t i = v->size;
1999  size_t j = w->size;
2000  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2001  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2002 }
2003 
2004 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2005 
2006 SWIGRUNTIME PyTypeObject*
2008  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2009  return type;
2010 }
2011 
2013 SwigPyPacked_Check(PyObject *op) {
2014  return ((op)->ob_type == SwigPyPacked_TypeOnce())
2015  || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2016 }
2017 
2018 SWIGRUNTIME void
2020 {
2021  if (SwigPyPacked_Check(v)) {
2022  SwigPyPacked *sobj = (SwigPyPacked *) v;
2023  free(sobj->pack);
2024  }
2025  PyObject_DEL(v);
2026 }
2027 
2028 SWIGRUNTIME PyTypeObject*
2030  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2031  static PyTypeObject swigpypacked_type;
2032  static int type_init = 0;
2033  if (!type_init) {
2034  const PyTypeObject tmp = {
2035  /* PyObject header changed in Python 3 */
2036 #if PY_VERSION_HEX>=0x03000000
2037  PyVarObject_HEAD_INIT(NULL, 0)
2038 #else
2039  PyObject_HEAD_INIT(NULL)
2040  0, /* ob_size */
2041 #endif
2042  (char *)"SwigPyPacked", /* tp_name */
2043  sizeof(SwigPyPacked), /* tp_basicsize */
2044  0, /* tp_itemsize */
2045  (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2046  (printfunc)SwigPyPacked_print, /* tp_print */
2047  (getattrfunc)0, /* tp_getattr */
2048  (setattrfunc)0, /* tp_setattr */
2049 #if PY_VERSION_HEX>=0x03000000
2050  0, /* tp_reserved in 3.0.1 */
2051 #else
2052  (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2053 #endif
2054  (reprfunc)SwigPyPacked_repr, /* tp_repr */
2055  0, /* tp_as_number */
2056  0, /* tp_as_sequence */
2057  0, /* tp_as_mapping */
2058  (hashfunc)0, /* tp_hash */
2059  (ternaryfunc)0, /* tp_call */
2060  (reprfunc)SwigPyPacked_str, /* tp_str */
2061  PyObject_GenericGetAttr, /* tp_getattro */
2062  0, /* tp_setattro */
2063  0, /* tp_as_buffer */
2064  Py_TPFLAGS_DEFAULT, /* tp_flags */
2065  swigpacked_doc, /* tp_doc */
2066  0, /* tp_traverse */
2067  0, /* tp_clear */
2068  0, /* tp_richcompare */
2069  0, /* tp_weaklistoffset */
2070 #if PY_VERSION_HEX >= 0x02020000
2071  0, /* tp_iter */
2072  0, /* tp_iternext */
2073  0, /* tp_methods */
2074  0, /* tp_members */
2075  0, /* tp_getset */
2076  0, /* tp_base */
2077  0, /* tp_dict */
2078  0, /* tp_descr_get */
2079  0, /* tp_descr_set */
2080  0, /* tp_dictoffset */
2081  0, /* tp_init */
2082  0, /* tp_alloc */
2083  0, /* tp_new */
2084  0, /* tp_free */
2085  0, /* tp_is_gc */
2086  0, /* tp_bases */
2087  0, /* tp_mro */
2088  0, /* tp_cache */
2089  0, /* tp_subclasses */
2090  0, /* tp_weaklist */
2091 #endif
2092 #if PY_VERSION_HEX >= 0x02030000
2093  0, /* tp_del */
2094 #endif
2095 #if PY_VERSION_HEX >= 0x02060000
2096  0, /* tp_version */
2097 #endif
2098 #ifdef COUNT_ALLOCS
2099  0,0,0,0 /* tp_alloc -> tp_next */
2100 #endif
2101  };
2102  swigpypacked_type = tmp;
2103  type_init = 1;
2104 #if PY_VERSION_HEX < 0x02020000
2105  swigpypacked_type.ob_type = &PyType_Type;
2106 #else
2107  if (PyType_Ready(&swigpypacked_type) < 0)
2108  return NULL;
2109 #endif
2110  }
2111  return &swigpypacked_type;
2112 }
2113 
2114 SWIGRUNTIME PyObject *
2115 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2116 {
2117  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2118  if (sobj) {
2119  void *pack = malloc(size);
2120  if (pack) {
2121  memcpy(pack, ptr, size);
2122  sobj->pack = pack;
2123  sobj->ty = ty;
2124  sobj->size = size;
2125  } else {
2126  PyObject_DEL((PyObject *) sobj);
2127  sobj = 0;
2128  }
2129  }
2130  return (PyObject *) sobj;
2131 }
2132 
2134 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2135 {
2136  if (SwigPyPacked_Check(obj)) {
2137  SwigPyPacked *sobj = (SwigPyPacked *)obj;
2138  if (sobj->size != size) return 0;
2139  memcpy(ptr, sobj->pack, size);
2140  return sobj->ty;
2141  } else {
2142  return 0;
2143  }
2144 }
2145 
2146 /* -----------------------------------------------------------------------------
2147  * pointers/data manipulation
2148  * ----------------------------------------------------------------------------- */
2149 
2150 SWIGRUNTIMEINLINE PyObject *
2152 {
2153  return SWIG_Python_str_FromChar("this");
2154 }
2155 
2156 static PyObject *swig_this = NULL;
2157 
2158 SWIGRUNTIME PyObject *
2160 {
2161  if (swig_this == NULL)
2162  swig_this = _SWIG_This();
2163  return swig_this;
2164 }
2165 
2166 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2167 
2168 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2169 #if PY_VERSION_HEX>=0x03000000
2170 #define SWIG_PYTHON_SLOW_GETSET_THIS
2171 #endif
2172 
2174 SWIG_Python_GetSwigThis(PyObject *pyobj)
2175 {
2176  PyObject *obj;
2177 
2178  if (SwigPyObject_Check(pyobj))
2179  return (SwigPyObject *) pyobj;
2180 
2181 #ifdef SWIGPYTHON_BUILTIN
2182  (void)obj;
2183 # ifdef PyWeakref_CheckProxy
2184  if (PyWeakref_CheckProxy(pyobj)) {
2185  pyobj = PyWeakref_GET_OBJECT(pyobj);
2186  if (pyobj && SwigPyObject_Check(pyobj))
2187  return (SwigPyObject*) pyobj;
2188  }
2189 # endif
2190  return NULL;
2191 #else
2192 
2193  obj = 0;
2194 
2195 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2196  if (PyInstance_Check(pyobj)) {
2197  obj = _PyInstance_Lookup(pyobj, SWIG_This());
2198  } else {
2199  PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2200  if (dictptr != NULL) {
2201  PyObject *dict = *dictptr;
2202  obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2203  } else {
2204 #ifdef PyWeakref_CheckProxy
2205  if (PyWeakref_CheckProxy(pyobj)) {
2206  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2207  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2208  }
2209 #endif
2210  obj = PyObject_GetAttr(pyobj,SWIG_This());
2211  if (obj) {
2212  Py_DECREF(obj);
2213  } else {
2214  if (PyErr_Occurred()) PyErr_Clear();
2215  return 0;
2216  }
2217  }
2218  }
2219 #else
2220  obj = PyObject_GetAttr(pyobj,SWIG_This());
2221  if (obj) {
2222  Py_DECREF(obj);
2223  } else {
2224  if (PyErr_Occurred()) PyErr_Clear();
2225  return 0;
2226  }
2227 #endif
2228  if (obj && !SwigPyObject_Check(obj)) {
2229  /* a PyObject is called 'this', try to get the 'real this'
2230  SwigPyObject from it */
2231  return SWIG_Python_GetSwigThis(obj);
2232  }
2233  return (SwigPyObject *)obj;
2234 #endif
2235 }
2236 
2237 /* Acquire a pointer value */
2238 
2239 SWIGRUNTIME int
2240 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2241  if (own == SWIG_POINTER_OWN) {
2243  if (sobj) {
2244  int oldown = sobj->own;
2245  sobj->own = own;
2246  return oldown;
2247  }
2248  }
2249  return 0;
2250 }
2251 
2252 /* Convert a pointer value */
2253 
2254 SWIGRUNTIME int
2255 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2256  int res;
2257  SwigPyObject *sobj;
2258  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2259 
2260  if (!obj)
2261  return SWIG_ERROR;
2262  if (obj == Py_None && !implicit_conv) {
2263  if (ptr)
2264  *ptr = 0;
2265  return SWIG_OK;
2266  }
2267 
2268  res = SWIG_ERROR;
2269 
2270  sobj = SWIG_Python_GetSwigThis(obj);
2271  if (own)
2272  *own = 0;
2273  while (sobj) {
2274  void *vptr = sobj->ptr;
2275  if (ty) {
2276  swig_type_info *to = sobj->ty;
2277  if (to == ty) {
2278  /* no type cast needed */
2279  if (ptr) *ptr = vptr;
2280  break;
2281  } else {
2282  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2283  if (!tc) {
2284  sobj = (SwigPyObject *)sobj->next;
2285  } else {
2286  if (ptr) {
2287  int newmemory = 0;
2288  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2289  if (newmemory == SWIG_CAST_NEW_MEMORY) {
2290  assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2291  if (own)
2292  *own = *own | SWIG_CAST_NEW_MEMORY;
2293  }
2294  }
2295  break;
2296  }
2297  }
2298  } else {
2299  if (ptr) *ptr = vptr;
2300  break;
2301  }
2302  }
2303  if (sobj) {
2304  if (own)
2305  *own = *own | sobj->own;
2306  if (flags & SWIG_POINTER_DISOWN) {
2307  sobj->own = 0;
2308  }
2309  res = SWIG_OK;
2310  } else {
2311  if (implicit_conv) {
2312  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2313  if (data && !data->implicitconv) {
2314  PyObject *klass = data->klass;
2315  if (klass) {
2316  PyObject *impconv;
2317  data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2318  impconv = SWIG_Python_CallFunctor(klass, obj);
2319  data->implicitconv = 0;
2320  if (PyErr_Occurred()) {
2321  PyErr_Clear();
2322  impconv = 0;
2323  }
2324  if (impconv) {
2325  SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2326  if (iobj) {
2327  void *vptr;
2328  res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2329  if (SWIG_IsOK(res)) {
2330  if (ptr) {
2331  *ptr = vptr;
2332  /* transfer the ownership to 'ptr' */
2333  iobj->own = 0;
2334  res = SWIG_AddCast(res);
2335  res = SWIG_AddNewMask(res);
2336  } else {
2337  res = SWIG_AddCast(res);
2338  }
2339  }
2340  }
2341  Py_DECREF(impconv);
2342  }
2343  }
2344  }
2345  }
2346  if (!SWIG_IsOK(res) && obj == Py_None) {
2347  if (ptr)
2348  *ptr = 0;
2349  if (PyErr_Occurred())
2350  PyErr_Clear();
2351  res = SWIG_OK;
2352  }
2353  }
2354  return res;
2355 }
2356 
2357 /* Convert a function ptr value */
2358 
2359 SWIGRUNTIME int
2360 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2361  if (!PyCFunction_Check(obj)) {
2362  return SWIG_ConvertPtr(obj, ptr, ty, 0);
2363  } else {
2364  void *vptr = 0;
2365 
2366  /* here we get the method pointer for callbacks */
2367  const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2368  const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2369  if (desc)
2370  desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2371  if (!desc)
2372  return SWIG_ERROR;
2373  if (ty) {
2374  swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2375  if (tc) {
2376  int newmemory = 0;
2377  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2378  assert(!newmemory); /* newmemory handling not yet implemented */
2379  } else {
2380  return SWIG_ERROR;
2381  }
2382  } else {
2383  *ptr = vptr;
2384  }
2385  return SWIG_OK;
2386  }
2387 }
2388 
2389 /* Convert a packed value value */
2390 
2391 SWIGRUNTIME int
2392 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2393  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2394  if (!to) return SWIG_ERROR;
2395  if (ty) {
2396  if (to != ty) {
2397  /* check type cast? */
2398  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2399  if (!tc) return SWIG_ERROR;
2400  }
2401  }
2402  return SWIG_OK;
2403 }
2404 
2405 /* -----------------------------------------------------------------------------
2406  * Create a new pointer object
2407  * ----------------------------------------------------------------------------- */
2408 
2409 /*
2410  Create a new instance object, without calling __init__, and set the
2411  'this' attribute.
2412 */
2413 
2414 SWIGRUNTIME PyObject*
2416 {
2417 #if (PY_VERSION_HEX >= 0x02020000)
2418  PyObject *inst = 0;
2419  PyObject *newraw = data->newraw;
2420  if (newraw) {
2421  inst = PyObject_Call(newraw, data->newargs, NULL);
2422  if (inst) {
2423 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2424  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2425  if (dictptr != NULL) {
2426  PyObject *dict = *dictptr;
2427  if (dict == NULL) {
2428  dict = PyDict_New();
2429  *dictptr = dict;
2430  PyDict_SetItem(dict, SWIG_This(), swig_this);
2431  }
2432  }
2433 #else
2434  PyObject *key = SWIG_This();
2435  PyObject_SetAttr(inst, key, swig_this);
2436 #endif
2437  }
2438  } else {
2439 #if PY_VERSION_HEX >= 0x03000000
2440  inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2441  if (inst) {
2442  PyObject_SetAttr(inst, SWIG_This(), swig_this);
2443  Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2444  }
2445 #else
2446  PyObject *dict = PyDict_New();
2447  if (dict) {
2448  PyDict_SetItem(dict, SWIG_This(), swig_this);
2449  inst = PyInstance_NewRaw(data->newargs, dict);
2450  Py_DECREF(dict);
2451  }
2452 #endif
2453  }
2454  return inst;
2455 #else
2456 #if (PY_VERSION_HEX >= 0x02010000)
2457  PyObject *inst = 0;
2458  PyObject *dict = PyDict_New();
2459  if (dict) {
2460  PyDict_SetItem(dict, SWIG_This(), swig_this);
2461  inst = PyInstance_NewRaw(data->newargs, dict);
2462  Py_DECREF(dict);
2463  }
2464  return (PyObject *) inst;
2465 #else
2466  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2467  if (inst == NULL) {
2468  return NULL;
2469  }
2470  inst->in_class = (PyClassObject *)data->newargs;
2471  Py_INCREF(inst->in_class);
2472  inst->in_dict = PyDict_New();
2473  if (inst->in_dict == NULL) {
2474  Py_DECREF(inst);
2475  return NULL;
2476  }
2477 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2478  inst->in_weakreflist = NULL;
2479 #endif
2480 #ifdef Py_TPFLAGS_GC
2481  PyObject_GC_Init(inst);
2482 #endif
2483  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2484  return (PyObject *) inst;
2485 #endif
2486 #endif
2487 }
2488 
2489 SWIGRUNTIME void
2490 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2491 {
2492  PyObject *dict;
2493 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2494  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2495  if (dictptr != NULL) {
2496  dict = *dictptr;
2497  if (dict == NULL) {
2498  dict = PyDict_New();
2499  *dictptr = dict;
2500  }
2501  PyDict_SetItem(dict, SWIG_This(), swig_this);
2502  return;
2503  }
2504 #endif
2505  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2506  PyDict_SetItem(dict, SWIG_This(), swig_this);
2507  Py_DECREF(dict);
2508 }
2509 
2510 
2511 SWIGINTERN PyObject *
2513  PyObject *obj[2];
2514  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2515  return NULL;
2516  } else {
2517  SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2518  if (sthis) {
2519  SwigPyObject_append((PyObject*) sthis, obj[1]);
2520  } else {
2521  SWIG_Python_SetSwigThis(obj[0], obj[1]);
2522  }
2523  return SWIG_Py_Void();
2524  }
2525 }
2526 
2527 /* Create a new pointer object */
2528 
2529 SWIGRUNTIME PyObject *
2530 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2531  SwigPyClientData *clientdata;
2532  PyObject * robj;
2533  int own;
2534 
2535  if (!ptr)
2536  return SWIG_Py_Void();
2537 
2538  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2539  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2540  if (clientdata && clientdata->pytype) {
2541  SwigPyObject *newobj;
2542  if (flags & SWIG_BUILTIN_TP_INIT) {
2543  newobj = (SwigPyObject*) self;
2544  if (newobj->ptr) {
2545  PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2546  while (newobj->next)
2547  newobj = (SwigPyObject *) newobj->next;
2548  newobj->next = next_self;
2549  newobj = (SwigPyObject *)next_self;
2550  }
2551  } else {
2552  newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2553  }
2554  if (newobj) {
2555  newobj->ptr = ptr;
2556  newobj->ty = type;
2557  newobj->own = own;
2558  newobj->next = 0;
2559 #ifdef SWIGPYTHON_BUILTIN
2560  newobj->dict = 0;
2561 #endif
2562  return (PyObject*) newobj;
2563  }
2564  return SWIG_Py_Void();
2565  }
2566 
2567  assert(!(flags & SWIG_BUILTIN_TP_INIT));
2568 
2569  robj = SwigPyObject_New(ptr, type, own);
2570  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2571  PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2572  Py_DECREF(robj);
2573  robj = inst;
2574  }
2575  return robj;
2576 }
2577 
2578 /* Create a new packed object */
2579 
2580 SWIGRUNTIMEINLINE PyObject *
2581 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2582  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2583 }
2584 
2585 /* -----------------------------------------------------------------------------*
2586  * Get type list
2587  * -----------------------------------------------------------------------------*/
2588 
2589 #ifdef SWIG_LINK_RUNTIME
2590 void *SWIG_ReturnGlobalTypeList(void *);
2591 #endif
2592 
2595  static void *type_pointer = (void *)0;
2596  /* first check if module already created */
2597  if (!type_pointer) {
2598 #ifdef SWIG_LINK_RUNTIME
2599  type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2600 #else
2601 # ifdef SWIGPY_USE_CAPSULE
2602  type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2603 # else
2604  type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2605  (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2606 # endif
2607  if (PyErr_Occurred()) {
2608  PyErr_Clear();
2609  type_pointer = (void *)0;
2610  }
2611 #endif
2612  }
2613  return (swig_module_info *) type_pointer;
2614 }
2615 
2616 #if PY_MAJOR_VERSION < 2
2617 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2618  is copied out of Python/modsupport.c in python version 2.3.4 */
2619 SWIGINTERN int
2620 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2621 {
2622  PyObject *dict;
2623  if (!PyModule_Check(m)) {
2624  PyErr_SetString(PyExc_TypeError,
2625  "PyModule_AddObject() needs module as first arg");
2626  return SWIG_ERROR;
2627  }
2628  if (!o) {
2629  PyErr_SetString(PyExc_TypeError,
2630  "PyModule_AddObject() needs non-NULL value");
2631  return SWIG_ERROR;
2632  }
2633 
2634  dict = PyModule_GetDict(m);
2635  if (dict == NULL) {
2636  /* Internal error -- modules must have a dict! */
2637  PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2638  PyModule_GetName(m));
2639  return SWIG_ERROR;
2640  }
2641  if (PyDict_SetItemString(dict, name, o))
2642  return SWIG_ERROR;
2643  Py_DECREF(o);
2644  return SWIG_OK;
2645 }
2646 #endif
2647 
2648 SWIGRUNTIME void
2649 #ifdef SWIGPY_USE_CAPSULE
2650 SWIG_Python_DestroyModule(PyObject *obj)
2651 #else
2653 #endif
2654 {
2655 #ifdef SWIGPY_USE_CAPSULE
2656  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2657 #else
2658  swig_module_info *swig_module = (swig_module_info *) vptr;
2659 #endif
2660  swig_type_info **types = swig_module->types;
2661  size_t i;
2662  for (i =0; i < swig_module->size; ++i) {
2663  swig_type_info *ty = types[i];
2664  if (ty->owndata) {
2666  if (data) SwigPyClientData_Del(data);
2667  }
2668  }
2669  Py_DECREF(SWIG_This());
2670  swig_this = NULL;
2671 }
2672 
2673 SWIGRUNTIME void
2675 #if PY_VERSION_HEX >= 0x03000000
2676  /* Add a dummy module object into sys.modules */
2677  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2678 #else
2679  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2680  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2681 #endif
2682 #ifdef SWIGPY_USE_CAPSULE
2683  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2684  if (pointer && module) {
2685  PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2686  } else {
2687  Py_XDECREF(pointer);
2688  }
2689 #else
2690  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2691  if (pointer && module) {
2692  PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2693  } else {
2694  Py_XDECREF(pointer);
2695  }
2696 #endif
2697 }
2698 
2699 /* The python cached type query */
2700 SWIGRUNTIME PyObject *
2702  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2703  return cache;
2704 }
2705 
2707 SWIG_Python_TypeQuery(const char *type)
2708 {
2709  PyObject *cache = SWIG_Python_TypeCache();
2710  PyObject *key = SWIG_Python_str_FromChar(type);
2711  PyObject *obj = PyDict_GetItem(cache, key);
2712  swig_type_info *descriptor;
2713  if (obj) {
2714 #ifdef SWIGPY_USE_CAPSULE
2715  descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2716 #else
2717  descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2718 #endif
2719  } else {
2721  descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2722  if (descriptor) {
2723 #ifdef SWIGPY_USE_CAPSULE
2724  obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2725 #else
2726  obj = PyCObject_FromVoidPtr(descriptor, NULL);
2727 #endif
2728  PyDict_SetItem(cache, key, obj);
2729  Py_DECREF(obj);
2730  }
2731  }
2732  Py_DECREF(key);
2733  return descriptor;
2734 }
2735 
2736 /*
2737  For backward compatibility only
2738 */
2739 #define SWIG_POINTER_EXCEPTION 0
2740 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2741 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2742 
2743 SWIGRUNTIME int
2744 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2745 {
2746  if (PyErr_Occurred()) {
2747  PyObject *type = 0;
2748  PyObject *value = 0;
2749  PyObject *traceback = 0;
2750  PyErr_Fetch(&type, &value, &traceback);
2751  if (value) {
2752  char *tmp;
2753  PyObject *old_str = PyObject_Str(value);
2754  Py_XINCREF(type);
2755  PyErr_Clear();
2756  if (infront) {
2757  PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2758  } else {
2759  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2760  }
2762  Py_DECREF(old_str);
2763  }
2764  return 1;
2765  } else {
2766  return 0;
2767  }
2768 }
2769 
2770 SWIGRUNTIME int
2772 {
2773  if (PyErr_Occurred()) {
2774  /* add information about failing argument */
2775  char mesg[256];
2776  PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2777  return SWIG_Python_AddErrMesg(mesg, 1);
2778  } else {
2779  return 0;
2780  }
2781 }
2782 
2783 SWIGRUNTIMEINLINE const char *
2784 SwigPyObject_GetDesc(PyObject *self)
2785 {
2786  SwigPyObject *v = (SwigPyObject *)self;
2787  swig_type_info *ty = v ? v->ty : 0;
2788  return ty ? ty->str : "";
2789 }
2790 
2791 SWIGRUNTIME void
2792 SWIG_Python_TypeError(const char *type, PyObject *obj)
2793 {
2794  if (type) {
2795 #if defined(SWIG_COBJECT_TYPES)
2796  if (obj && SwigPyObject_Check(obj)) {
2797  const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2798  if (otype) {
2799  PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2800  type, otype);
2801  return;
2802  }
2803  } else
2804 #endif
2805  {
2806  const char *otype = (obj ? obj->ob_type->tp_name : 0);
2807  if (otype) {
2808  PyObject *str = PyObject_Str(obj);
2809  const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2810  if (cstr) {
2811  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2812  type, otype, cstr);
2814  } else {
2815  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2816  type, otype);
2817  }
2818  Py_XDECREF(str);
2819  return;
2820  }
2821  }
2822  PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2823  } else {
2824  PyErr_Format(PyExc_TypeError, "unexpected type is received");
2825  }
2826 }
2827 
2828 
2829 /* Convert a pointer value, signal an exception on a type mismatch */
2830 SWIGRUNTIME void *
2831 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2832  void *result;
2833  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2834  PyErr_Clear();
2835 #if SWIG_POINTER_EXCEPTION
2836  if (flags) {
2838  SWIG_Python_ArgFail(argnum);
2839  }
2840 #endif
2841  }
2842  return result;
2843 }
2844 
2845 #ifdef SWIGPYTHON_BUILTIN
2846 SWIGRUNTIME int
2847 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2848  PyTypeObject *tp = obj->ob_type;
2849  PyObject *descr;
2850  PyObject *encoded_name;
2851  descrsetfunc f;
2852  int res = -1;
2853 
2854 # ifdef Py_USING_UNICODE
2855  if (PyString_Check(name)) {
2856  name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2857  if (!name)
2858  return -1;
2859  } else if (!PyUnicode_Check(name))
2860 # else
2861  if (!PyString_Check(name))
2862 # endif
2863  {
2864  PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2865  return -1;
2866  } else {
2867  Py_INCREF(name);
2868  }
2869 
2870  if (!tp->tp_dict) {
2871  if (PyType_Ready(tp) < 0)
2872  goto done;
2873  }
2874 
2875  descr = _PyType_Lookup(tp, name);
2876  f = NULL;
2877  if (descr != NULL)
2878  f = descr->ob_type->tp_descr_set;
2879  if (!f) {
2880  if (PyString_Check(name)) {
2881  encoded_name = name;
2882  Py_INCREF(name);
2883  } else {
2884  encoded_name = PyUnicode_AsUTF8String(name);
2885  }
2886  PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2887  Py_DECREF(encoded_name);
2888  } else {
2889  res = f(descr, obj, value);
2890  }
2891 
2892  done:
2893  Py_DECREF(name);
2894  return res;
2895 }
2896 #endif
2897 
2898 
2899 #ifdef __cplusplus
2900 }
2901 #endif
2902 
2903 
2904 
2905 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2906 
2907 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2908 
2909 
2910 
2911 /* -------- TYPES TABLE (BEGIN) -------- */
2912 
2913 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2914 #define SWIGTYPE_p_PLcGrid swig_types[1]
2915 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
2916 #define SWIGTYPE_p_char swig_types[3]
2917 #define SWIGTYPE_p_double swig_types[4]
2918 #define SWIGTYPE_p_f_double_double__int swig_types[5]
2919 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
2920 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
2921 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
2922 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
2923 #define SWIGTYPE_p_int swig_types[10]
2924 #define SWIGTYPE_p_p_char swig_types[11]
2925 #define SWIGTYPE_p_p_double swig_types[12]
2926 #define SWIGTYPE_p_unsigned_int swig_types[13]
2928 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
2929 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2930 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2931 
2932 /* -------- TYPES TABLE (END) -------- */
2933 
2934 #if (PY_VERSION_HEX <= 0x02000000)
2935 # if !defined(SWIG_PYTHON_CLASSIC)
2936 # error "This python version requires swig to be run with the '-classic' option"
2937 # endif
2938 #endif
2939 
2940 /*-----------------------------------------------
2941  @(target):= _plplotc.so
2942  ------------------------------------------------*/
2943 #if PY_VERSION_HEX >= 0x03000000
2944 # define SWIG_init PyInit__plplotc
2945 
2946 #else
2947 # define SWIG_init init_plplotc
2948 
2949 #endif
2950 #define SWIG_name "_plplotc"
2951 
2952 #define SWIGVERSION 0x020011
2953 #define SWIG_VERSION SWIGVERSION
2954 
2955 
2956 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2957 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2958 
2959 
2960 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
2961 #include <arrayobject.h>
2962 #include "plplot.h"
2963 #include "plplotP.h"
2964 
2965 #define NPY_PLINT NPY_INT32
2966 
2967 #ifdef PL_DOUBLE
2968 #define NPY_PLFLT NPY_DOUBLE
2969 #else
2970 #define NPY_PLFLT NPY_FLOAT
2971 #endif
2972 
2973 // python-1.5 compatibility mode?
2974 #if !defined ( PySequence_Fast_GET_ITEM )
2975  #define PySequence_Fast_GET_ITEM PySequence_GetItem
2976 #endif
2977 #define PySequence_Size PySequence_Length
2978 
2979 
2980  static PLINT Alen = 0;
2981  static PLINT Xlen = 0, Ylen = 0;
2982 
2983 
2984 SWIGINTERN int
2985 SWIG_AsVal_double (PyObject *obj, double *val)
2986 {
2987  int res = SWIG_TypeError;
2988  if (PyFloat_Check(obj)) {
2989  if (val) *val = PyFloat_AsDouble(obj);
2990  return SWIG_OK;
2991  } else if (PyInt_Check(obj)) {
2992  if (val) *val = PyInt_AsLong(obj);
2993  return SWIG_OK;
2994  } else if (PyLong_Check(obj)) {
2995  double v = PyLong_AsDouble(obj);
2996  if (!PyErr_Occurred()) {
2997  if (val) *val = v;
2998  return SWIG_OK;
2999  } else {
3000  PyErr_Clear();
3001  }
3002  }
3003 #ifdef SWIG_PYTHON_CAST_MODE
3004  {
3005  int dispatch = 0;
3006  double d = PyFloat_AsDouble(obj);
3007  if (!PyErr_Occurred()) {
3008  if (val) *val = d;
3009  return SWIG_AddCast(SWIG_OK);
3010  } else {
3011  PyErr_Clear();
3012  }
3013  if (!dispatch) {
3014  long v = PyLong_AsLong(obj);
3015  if (!PyErr_Occurred()) {
3016  if (val) *val = v;
3018  } else {
3019  PyErr_Clear();
3020  }
3021  }
3022  }
3023 #endif
3024  return res;
3025 }
3026 
3027 
3028  #define SWIG_From_double PyFloat_FromDouble
3029 
3030 
3031  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3032  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3033  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3034  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3035  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3037  typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
3038 
3039 
3040 SWIGINTERNINLINE PyObject*
3041  SWIG_From_int (int value)
3042 {
3043  return PyInt_FromLong((long) value);
3044 }
3045 
3046 
3047 #include <limits.h>
3048 #if !defined(SWIG_NO_LLONG_MAX)
3049 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3050 # define LLONG_MAX __LONG_LONG_MAX__
3051 # define LLONG_MIN (-LLONG_MAX - 1LL)
3052 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3053 # endif
3054 #endif
3055 
3056 
3057 #include <float.h>
3058 
3059 
3060 #include <math.h>
3061 
3062 
3063 SWIGINTERNINLINE int
3064 SWIG_CanCastAsInteger(double *d, double min, double max) {
3065  double x = *d;
3066  if ((min <= x && x <= max)) {
3067  double fx = floor(x);
3068  double cx = ceil(x);
3069  double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3070  if ((errno == EDOM) || (errno == ERANGE)) {
3071  errno = 0;
3072  } else {
3073  double summ, reps, diff;
3074  if (rd < x) {
3075  diff = x - rd;
3076  } else if (rd > x) {
3077  diff = rd - x;
3078  } else {
3079  return 1;
3080  }
3081  summ = rd + x;
3082  reps = diff/summ;
3083  if (reps < 8*DBL_EPSILON) {
3084  *d = rd;
3085  return 1;
3086  }
3087  }
3088  }
3089  return 0;
3090 }
3091 
3092 
3093 SWIGINTERN int
3094 SWIG_AsVal_long (PyObject *obj, long* val)
3095 {
3096  if (PyInt_Check(obj)) {
3097  if (val) *val = PyInt_AsLong(obj);
3098  return SWIG_OK;
3099  } else if (PyLong_Check(obj)) {
3100  long v = PyLong_AsLong(obj);
3101  if (!PyErr_Occurred()) {
3102  if (val) *val = v;
3103  return SWIG_OK;
3104  } else {
3105  PyErr_Clear();
3106  }
3107  }
3108 #ifdef SWIG_PYTHON_CAST_MODE
3109  {
3110  int dispatch = 0;
3111  long v = PyInt_AsLong(obj);
3112  if (!PyErr_Occurred()) {
3113  if (val) *val = v;
3114  return SWIG_AddCast(SWIG_OK);
3115  } else {
3116  PyErr_Clear();
3117  }
3118  if (!dispatch) {
3119  double d;
3120  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3121  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3122  if (val) *val = (long)(d);
3123  return res;
3124  }
3125  }
3126  }
3127 #endif
3128  return SWIG_TypeError;
3129 }
3130 
3131 
3132 SWIGINTERN int
3133 SWIG_AsVal_int (PyObject * obj, int *val)
3134 {
3135  long v;
3136  int res = SWIG_AsVal_long (obj, &v);
3137  if (SWIG_IsOK(res)) {
3138  if ((v < INT_MIN || v > INT_MAX)) {
3139  return SWIG_OverflowError;
3140  } else {
3141  if (val) *val = (int)(v);
3142  }
3143  }
3144  return res;
3145 }
3146 
3147 
3148 SWIGINTERN int
3149 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3150 {
3151 #if PY_VERSION_HEX < 0x03000000
3152  if (PyInt_Check(obj)) {
3153  long v = PyInt_AsLong(obj);
3154  if (v >= 0) {
3155  if (val) *val = v;
3156  return SWIG_OK;
3157  } else {
3158  return SWIG_OverflowError;
3159  }
3160  } else
3161 #endif
3162  if (PyLong_Check(obj)) {
3163  unsigned long v = PyLong_AsUnsignedLong(obj);
3164  if (!PyErr_Occurred()) {
3165  if (val) *val = v;
3166  return SWIG_OK;
3167  } else {
3168  PyErr_Clear();
3169 #if PY_VERSION_HEX >= 0x03000000
3170  {
3171  long v = PyLong_AsLong(obj);
3172  if (!PyErr_Occurred()) {
3173  if (v < 0) {
3174  return SWIG_OverflowError;
3175  }
3176  } else {
3177  PyErr_Clear();
3178  }
3179  }
3180 #endif
3181  }
3182  }
3183 #ifdef SWIG_PYTHON_CAST_MODE
3184  {
3185  int dispatch = 0;
3186  unsigned long v = PyLong_AsUnsignedLong(obj);
3187  if (!PyErr_Occurred()) {
3188  if (val) *val = v;
3189  return SWIG_AddCast(SWIG_OK);
3190  } else {
3191  PyErr_Clear();
3192  }
3193  if (!dispatch) {
3194  double d;
3195  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3196  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3197  if (val) *val = (unsigned long)(d);
3198  return res;
3199  }
3200  }
3201  }
3202 #endif
3203  return SWIG_TypeError;
3204 }
3205 
3206 
3207 SWIGINTERN int
3208 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3209 {
3210  unsigned long v;
3211  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3212  if (SWIG_IsOK(res)) {
3213  if ((v > UINT_MAX)) {
3214  return SWIG_OverflowError;
3215  } else {
3216  if (val) *val = (unsigned int)(v);
3217  }
3218  }
3219  return res;
3220 }
3221 
3222 
3223 SWIGINTERNINLINE PyObject*
3224  SWIG_From_unsigned_SS_int (unsigned int value)
3225 {
3226  return PyInt_FromSize_t((size_t) value);
3227 }
3228 
3229 
3232 {
3233  static int init = 0;
3234  static swig_type_info* info = 0;
3235  if (!init) {
3236  info = SWIG_TypeQuery("_p_char");
3237  init = 1;
3238  }
3239  return info;
3240 }
3241 
3242 
3243 SWIGINTERN int
3244 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3245 {
3246 #if PY_VERSION_HEX>=0x03000000
3247  if (PyUnicode_Check(obj))
3248 #else
3249  if (PyString_Check(obj))
3250 #endif
3251  {
3252  char *cstr; Py_ssize_t len;
3253 #if PY_VERSION_HEX>=0x03000000
3254  if (!alloc && cptr) {
3255  /* We can't allow converting without allocation, since the internal
3256  representation of string in Python 3 is UCS-2/UCS-4 but we require
3257  a UTF-8 representation.
3258  TODO(bhy) More detailed explanation */
3259  return SWIG_RuntimeError;
3260  }
3261  obj = PyUnicode_AsUTF8String(obj);
3262  PyBytes_AsStringAndSize(obj, &cstr, &len);
3263  if(alloc) *alloc = SWIG_NEWOBJ;
3264 #else
3265  PyString_AsStringAndSize(obj, &cstr, &len);
3266 #endif
3267  if (cptr) {
3268  if (alloc) {
3269  /*
3270  In python the user should not be able to modify the inner
3271  string representation. To warranty that, if you define
3272  SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3273  buffer is always returned.
3274 
3275  The default behavior is just to return the pointer value,
3276  so, be careful.
3277  */
3278 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3279  if (*alloc != SWIG_OLDOBJ)
3280 #else
3281  if (*alloc == SWIG_NEWOBJ)
3282 #endif
3283  {
3284  *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3285  *alloc = SWIG_NEWOBJ;
3286  }
3287  else {
3288  *cptr = cstr;
3289  *alloc = SWIG_OLDOBJ;
3290  }
3291  } else {
3292  #if PY_VERSION_HEX>=0x03000000
3293  assert(0); /* Should never reach here in Python 3 */
3294  #endif
3295  *cptr = SWIG_Python_str_AsChar(obj);
3296  }
3297  }
3298  if (psize) *psize = len + 1;
3299 #if PY_VERSION_HEX>=0x03000000
3300  Py_XDECREF(obj);
3301 #endif
3302  return SWIG_OK;
3303  } else {
3304  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3305  if (pchar_descriptor) {
3306  void* vptr = 0;
3307  if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3308  if (cptr) *cptr = (char *) vptr;
3309  if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3310  if (alloc) *alloc = SWIG_OLDOBJ;
3311  return SWIG_OK;
3312  }
3313  }
3314  }
3315  return SWIG_TypeError;
3316 }
3317 
3318 
3319 SWIGINTERN int
3320 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3321 {
3322  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3323  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3324  if (SWIG_IsOK(res)) {
3325  if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3326  if (csize <= size) {
3327  if (val) {
3328  if (csize) memcpy(val, cptr, csize*sizeof(char));
3329  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3330  }
3331  if (alloc == SWIG_NEWOBJ) {
3332  free((char*)cptr);
3333  res = SWIG_DelNewMask(res);
3334  }
3335  return res;
3336  }
3337  if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3338  }
3339  return SWIG_TypeError;
3340 }
3341 
3342 
3343 SWIGINTERNINLINE PyObject *
3344 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3345 {
3346  if (carray) {
3347  if (size > INT_MAX) {
3348  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3349  return pchar_descriptor ?
3350  SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3351  } else {
3352 #if PY_VERSION_HEX >= 0x03000000
3353  return PyUnicode_FromStringAndSize(carray, (int)(size));
3354 #else
3355  return PyString_FromStringAndSize(carray, (int)(size));
3356 #endif
3357  }
3358  } else {
3359  return SWIG_Py_Void();
3360  }
3361 }
3362 
3363 
3364 
3365 
3366 
3367 #define t_output_helper SWIG_Python_AppendOutput
3368 
3369 
3370 SWIGINTERN int
3371 SWIG_AsVal_char (PyObject * obj, char *val)
3372 {
3373  int res = SWIG_AsCharArray(obj, val, 1);
3374  if (!SWIG_IsOK(res)) {
3375  long v;
3376  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3377  if (SWIG_IsOK(res)) {
3378  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3379  if (val) *val = (char)(v);
3380  } else {
3381  res = SWIG_OverflowError;
3382  }
3383  }
3384  }
3385  return res;
3386 }
3387 
3388 #ifdef __cplusplus
3389 extern "C" {
3390 #endif
3391 
3392 // some really twisted stuff to allow calling a single precision library from python
3393  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims )
3394  {
3395  PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3396  mindims, maxdims );
3397  if ( !tmp )
3398  {
3399  // could be an incoming long array which can't be "safely" converted, do it anyway
3400  if ( PyArray_Check( in ) )
3401  {
3402  PyErr_Clear();
3403  tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3404  }
3405  }
3406  return tmp;
3407  }
3408 
3409 
3410 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3411 
3412 SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3413  PyObject *resultobj = 0;
3414  PLFLT arg1 ;
3415  PLFLT arg2 ;
3416  PLFLT *arg3 = (PLFLT *) 0 ;
3417  PLFLT *arg4 = (PLFLT *) 0 ;
3418  PLPointer arg5 = (PLPointer) 0 ;
3419  double val1 ;
3420  int ecode1 = 0 ;
3421  double val2 ;
3422  int ecode2 = 0 ;
3423  PLFLT temp3 ;
3424  int res3 = SWIG_TMPOBJ ;
3425  PLFLT temp4 ;
3426  int res4 = SWIG_TMPOBJ ;
3427  PyObject * obj0 = 0 ;
3428  PyObject * obj1 = 0 ;
3429 
3430  arg3 = &temp3;
3431  arg4 = &temp4;
3432  {
3433  arg5 = NULL;
3434  }
3435  if (!PyArg_ParseTuple(args,(char *)"OO:pltr0",&obj0,&obj1)) SWIG_fail;
3436  ecode1 = SWIG_AsVal_double(obj0, &val1);
3437  if (!SWIG_IsOK(ecode1)) {
3438  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3439  }
3440  arg1 = (PLFLT)(val1);
3441  ecode2 = SWIG_AsVal_double(obj1, &val2);
3442  if (!SWIG_IsOK(ecode2)) {
3443  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3444  }
3445  arg2 = (PLFLT)(val2);
3446  pltr0(arg1,arg2,arg3,arg4,arg5);
3447  resultobj = SWIG_Py_Void();
3448  if (SWIG_IsTmpObj(res3)) {
3449  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3450  } else {
3451  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3452  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3453  }
3454  if (SWIG_IsTmpObj(res4)) {
3455  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3456  } else {
3457  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3458  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3459  }
3460  return resultobj;
3461 fail:
3462  return NULL;
3463 }
3464 
3465 
3466 
3467  PyArrayObject *pltr_xg, *pltr_yg;
3470 
3471  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3472  {
3473  // fprintf(stderr, "marshal PLcGrid1\n");
3474  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3475  {
3476  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3477  return NULL;
3478  }
3479  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3480  NPY_PLFLT, 1, 1 );
3481  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3482  NPY_PLFLT, 1, 1 );
3483  if ( pltr_xg == 0 || pltr_yg == 0 )
3484  {
3485  PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3486  return NULL;
3487  }
3488  tmpGrid1.nx = PyArray_DIMS( pltr_xg )[0];
3489  tmpGrid1.ny = PyArray_DIMS( pltr_yg )[0];
3490  if ( isimg == 0 )
3491  {
3492  if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3493  {
3494  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3495  return NULL;
3496  }
3497  }
3498  else
3499  {
3500  if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3501  {
3502  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3503  return NULL;
3504  }
3505  }
3506  tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3507  tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3508  return &tmpGrid1;
3509  }
3510 
3511  void cleanup_PLcGrid1( void )
3512  {
3513  // fprintf(stderr, "cleanup PLcGrid1\n");
3514  Py_DECREF( pltr_xg );
3515  Py_DECREF( pltr_yg );
3516  }
3517 
3518  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3519  {
3520  int i, size;
3521  // fprintf(stderr, "marshal PLcGrid2\n");
3522  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3523  {
3524  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3525  return NULL;
3526  }
3527  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3528  NPY_PLFLT, 2, 2 );
3529  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3530  NPY_PLFLT, 2, 2 );
3531  if ( pltr_xg == 0 || pltr_yg == 0 )
3532  {
3533  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3534  return NULL;
3535  }
3536  if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3537  PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3538  {
3539  PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3540  return NULL;
3541  }
3542  tmpGrid2.nx = PyArray_DIMS( pltr_xg )[0];
3543  tmpGrid2.ny = PyArray_DIMS( pltr_xg )[1];
3544  if ( isimg == 0 )
3545  {
3546  if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3547  {
3548  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3549  return NULL;
3550  }
3551  }
3552  else
3553  {
3554  if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3555  {
3556  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3557  return NULL;
3558  }
3559  }
3560  size = sizeof ( PLFLT ) * tmpGrid2.ny;
3561  tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * tmpGrid2.nx );
3562  for ( i = 0; i < tmpGrid2.nx; i++ )
3563  tmpGrid2.xg[i] = (PLFLT *) ( PyArray_DATA( pltr_xg ) + i * size );
3564  tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * tmpGrid2.nx );
3565  for ( i = 0; i < tmpGrid2.nx; i++ )
3566  tmpGrid2.yg[i] = (PLFLT *) ( PyArray_DATA( pltr_yg ) + i * size );
3567  return &tmpGrid2;
3568  }
3569 
3570  void cleanup_PLcGrid2( void )
3571  {
3572  // fprintf(stderr, "cleanup PLcGrid2\n");
3573  free( tmpGrid2.xg );
3574  free( tmpGrid2.yg );
3575  Py_DECREF( pltr_xg );
3576  Py_DECREF( pltr_yg );
3577  }
3578 
3579 SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3580  PyObject *resultobj = 0;
3581  PLFLT arg1 ;
3582  PLFLT arg2 ;
3583  PLFLT *arg3 = (PLFLT *) 0 ;
3584  PLFLT *arg4 = (PLFLT *) 0 ;
3585  PLcGrid *arg5 = (PLcGrid *) 0 ;
3586  double val1 ;
3587  int ecode1 = 0 ;
3588  double val2 ;
3589  int ecode2 = 0 ;
3590  PLFLT temp3 ;
3591  int res3 = SWIG_TMPOBJ ;
3592  PLFLT temp4 ;
3593  int res4 = SWIG_TMPOBJ ;
3594  PyObject * obj0 = 0 ;
3595  PyObject * obj1 = 0 ;
3596  PyObject * obj2 = 0 ;
3597 
3598  arg3 = &temp3;
3599  arg4 = &temp4;
3600  if (!PyArg_ParseTuple(args,(char *)"OOO:pltr1",&obj0,&obj1,&obj2)) SWIG_fail;
3601  ecode1 = SWIG_AsVal_double(obj0, &val1);
3602  if (!SWIG_IsOK(ecode1)) {
3603  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3604  }
3605  arg1 = (PLFLT)(val1);
3606  ecode2 = SWIG_AsVal_double(obj1, &val2);
3607  if (!SWIG_IsOK(ecode2)) {
3608  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3609  }
3610  arg2 = (PLFLT)(val2);
3611  {
3612  arg5 = marshal_PLcGrid1( obj2, 0 );
3613  if ( !arg5 )
3614  return NULL;
3615  }
3616  pltr1(arg1,arg2,arg3,arg4,arg5);
3617  resultobj = SWIG_Py_Void();
3618  if (SWIG_IsTmpObj(res3)) {
3619  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3620  } else {
3621  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3622  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3623  }
3624  if (SWIG_IsTmpObj(res4)) {
3625  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3626  } else {
3627  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3628  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3629  }
3630  {
3631  cleanup_PLcGrid1();
3632  }
3633  return resultobj;
3634 fail:
3635  {
3636  cleanup_PLcGrid1();
3637  }
3638  return NULL;
3639 }
3640 
3641 
3642 SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3643  PyObject *resultobj = 0;
3644  PLFLT arg1 ;
3645  PLFLT arg2 ;
3646  PLFLT *arg3 = (PLFLT *) 0 ;
3647  PLFLT *arg4 = (PLFLT *) 0 ;
3648  PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3649  double val1 ;
3650  int ecode1 = 0 ;
3651  double val2 ;
3652  int ecode2 = 0 ;
3653  PLFLT temp3 ;
3654  int res3 = SWIG_TMPOBJ ;
3655  PLFLT temp4 ;
3656  int res4 = SWIG_TMPOBJ ;
3657  PyObject * obj0 = 0 ;
3658  PyObject * obj1 = 0 ;
3659  PyObject * obj2 = 0 ;
3660 
3661  arg3 = &temp3;
3662  arg4 = &temp4;
3663  if (!PyArg_ParseTuple(args,(char *)"OOO:pltr2",&obj0,&obj1,&obj2)) SWIG_fail;
3664  ecode1 = SWIG_AsVal_double(obj0, &val1);
3665  if (!SWIG_IsOK(ecode1)) {
3666  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3667  }
3668  arg1 = (PLFLT)(val1);
3669  ecode2 = SWIG_AsVal_double(obj1, &val2);
3670  if (!SWIG_IsOK(ecode2)) {
3671  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3672  }
3673  arg2 = (PLFLT)(val2);
3674  {
3675  arg5 = marshal_PLcGrid2( obj2, 0 );
3676  if ( !arg5 )
3677  return NULL;
3678  }
3679  pltr2(arg1,arg2,arg3,arg4,arg5);
3680  resultobj = SWIG_Py_Void();
3681  if (SWIG_IsTmpObj(res3)) {
3682  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3683  } else {
3684  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3685  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3686  }
3687  if (SWIG_IsTmpObj(res4)) {
3688  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3689  } else {
3690  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3691  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3692  }
3693  {
3694  cleanup_PLcGrid2();
3695  }
3696  return resultobj;
3697 fail:
3698  {
3699  cleanup_PLcGrid2();
3700  }
3701  return NULL;
3702 }
3703 
3704 
3705 
3706  // helper code for handling the callback
3707 #if 0
3708  static PyInterpreterState *save_interp = NULL;
3709 #endif
3711  PyObject* python_pltr = NULL;
3712  PyObject* python_f2eval = NULL;
3713  PyObject* python_ct = NULL;
3714  PyObject* python_mapform = NULL;
3715  PyObject* python_label = NULL;
3716 
3717 #if 0
3718 #define MY_BLOCK_THREADS { \
3719  PyThreadState *prev_state, *new_state; \
3720  /* need to have started a thread at some stage */ \
3721  /* for the following to work */ \
3722  PyEval_AcquireLock(); \
3723  new_state = PyThreadState_New( save_interp ); \
3724  prev_state = PyThreadState_Swap( new_state );
3725 #define MY_UNBLOCK_THREADS \
3726  new_state = PyThreadState_Swap( prev_state ); \
3727  PyThreadState_Clear( new_state ); \
3728  PyEval_ReleaseLock(); \
3729  PyThreadState_Delete( new_state ); \
3730  }
3731 #else
3732 #define MY_BLOCK_THREADS
3733 #define MY_UNBLOCK_THREADS
3734 #endif
3735 
3736 // This is the callback that gets handed to the C code. It, in turn, calls the Python callback
3737 
3738  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
3739  {
3740  PyObject *pdata, *arglist, *result;
3741  PyArrayObject *tmp;
3742 
3743  // the data argument is acutally a pointer to a python object
3744  pdata = (PyObject *) data;
3745  if ( data == NULL )
3746  {
3747  pdata = Py_None;
3748  }
3749  if ( python_pltr ) // if not something is terribly wrong
3750  { // hold a reference to the data object
3751  Py_XINCREF( pdata );
3752  // grab the Global Interpreter Lock to be sure threads don't mess us up
3754  // build the argument list
3755 #ifdef PL_DOUBLE
3756  arglist = Py_BuildValue( "(ddO)", x, y, pdata );
3757 #else
3758  arglist = Py_BuildValue( "(ffO)", x, y, pdata );
3759 #endif
3760  if ( arglist == NULL )
3761  {
3762  fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
3763  *tx = *ty = 0;
3764  return;
3765  }
3766  // call the python function
3767  result = PyEval_CallObject( python_pltr, arglist );
3768  // release the argument list
3769  Py_XDECREF( arglist );
3770  // check and unpack the result
3771  if ( result == NULL )
3772  {
3773  fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
3774  PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 argments." );
3775  *tx = *ty = 0;
3776  }
3777  else
3778  {
3779  tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
3780  if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3781  {
3782  fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
3783  PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
3784  *tx = *ty = 0;
3785  }
3786  else
3787  {
3788  PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3789  *tx = t[0];
3790  *ty = t[1];
3791  Py_XDECREF( tmp );
3792  }
3793  }
3794  // release the result
3795  Py_XDECREF( result );
3796  // release the global interpreter lock
3798  }
3799  }
3800 
3801  PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data )
3802  {
3803  PyObject *pdata, *arglist, *result;
3804  PLFLT fresult = 0.0;
3805 
3806  // the data argument is acutally a pointer to a python object
3807  pdata = (PyObject *) data;
3808  if ( python_f2eval ) // if not something is terribly wrong
3809  { // hold a reference to the data object
3810  Py_XINCREF( pdata );
3811  // grab the Global Interpreter Lock to be sure threads don't mess us up
3813  // build the argument list
3814  arglist = Py_BuildValue( "(iiO)", x, y, pdata );
3815  // call the python function
3816  result = PyEval_CallObject( python_f2eval, arglist );
3817  // release the argument list
3818  Py_DECREF( arglist );
3819  // check and unpack the result
3820  if ( !PyFloat_Check( result ) )
3821  {
3822  fprintf( stderr, "f2eval callback must return a float\n" );
3823  PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
3824  }
3825  else
3826  {
3827  // should I test the type here?
3828  fresult = (PLFLT) PyFloat_AsDouble( result );
3829  }
3830  // release the result
3831  Py_XDECREF( result );
3832  // release the global interpreter lock
3834  }
3835  return fresult;
3836  }
3837 
3838  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
3839  {
3840  PyObject *pdata, *arglist, *result;
3841  char *pystring;
3842  PLFLT fresult = 0.0;
3843 
3844  // the data argument is acutally a pointer to a python object
3845  if ( data )
3846  pdata = (PyObject *) data;
3847  else
3848  pdata = Py_None;
3849  if ( python_label ) // if not something is terribly wrong
3850  { // hold a reference to the data object
3851  Py_XINCREF( pdata );
3852  // grab the Global Interpreter Lock to be sure threads don't mess us up
3854  // build the argument list
3855 #ifdef PL_DOUBLE
3856  arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
3857 #else
3858  arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
3859 #endif
3860  // call the python function
3861  result = PyEval_CallObject( python_label, arglist );
3862  // release the argument list
3863  //Py_DECREF(arglist);
3864  // check and unpack the result
3865  if ( result == NULL )
3866  {
3867  fprintf( stderr, "label callback failed with 3 arguments\n" );
3868  PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
3869  }
3870  else if ( !PyString_Check( result ) )
3871  {
3872  fprintf( stderr, "label callback must return a string\n" );
3873  PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
3874  }
3875  else
3876  {
3877  // should I test the type here?
3878  pystring = PyString_AsString( result );
3879  strncpy( string, pystring, len );
3880  }
3881  // release the result
3882  Py_XDECREF( result );
3883  // release the global interpreter lock
3885  }
3886  }
3887 
3888  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
3889  {
3890  PyObject *px, *py, *pdata, *arglist, *result;
3891  npy_intp n;
3892  n = 1;
3893 
3894  // the data argument is acutally a pointer to a python object
3895  pdata = (PyObject *) data;
3896  if ( data == NULL )
3897  {
3898  pdata = Py_None;
3899  }
3900  if ( python_ct ) // if not something is terribly wrong
3901  { // hold a reference to the data object
3902  Py_XINCREF( pdata );
3903  // grab the Global Interpreter Lock to be sure threads don't mess us up
3905  // build the argument list
3906  px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
3907  py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
3908  arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
3909  // call the python function
3910  result = PyEval_CallObject( python_ct, arglist );
3911  // release the argument list
3912  Py_DECREF( arglist );
3913  Py_DECREF( px );
3914  Py_DECREF( py );
3915  Py_DECREF( pdata );
3916  // check and unpack the result
3917  if ( result == NULL )
3918  {
3919  fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
3920  PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
3921  }
3922  // release the result
3923  Py_XDECREF( result );
3924  // release the global interpreter lock
3926  }
3927  }
3928 
3929  void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y )
3930  {
3931  PyObject *px, *py, *arglist, *result;
3932  // PyArrayObject *tmpx, *tmpy;
3933 // PLFLT *xx, *yy;
3934 // PLINT i;
3935  npy_intp nn;
3936  nn = n;
3937 
3938  if ( python_mapform ) // if not something is terribly wrong
3939  { // grab the Global Interpreter Lock to be sure threads don't mess us up
3941  // build the argument list
3942 #ifdef PL_HAVE_PTHREAD
3943  px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
3944  py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
3945 #else
3946  px = PyArray_FromDimsAndData( 1, &n, PyArray_FLOAT, (char *) x );
3947  py = PyArray_FromDimsAndData( 1, &n, PyArray_FLOAT, (char *) y );
3948 #endif
3949  arglist = Py_BuildValue( "(iOO)", n, px, py );
3950  // call the python function
3951  result = PyEval_CallObject( python_mapform, arglist );
3952  // release the argument list
3953  Py_DECREF( arglist );
3954  Py_DECREF( px );
3955  Py_DECREF( py );
3956  // check and unpack the result
3957  if ( result == NULL )
3958  {
3959  fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
3960  PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
3961  }
3962  // release the result
3963  Py_XDECREF( result );
3964  // release the global interpreter lock
3966  }
3967  }
3968 
3969 // marshal the pltr function pointer argument
3970  pltr_func marshal_pltr( PyObject* input )
3971  {
3972  pltr_func result = do_pltr_callback;
3973  PyObject * rep = PyObject_Repr( input );
3974  if ( rep )
3975  {
3976  char* str = PyString_AsString( rep );
3977  if ( strcmp( str, "<built-in function pltr0>" ) == 0 )
3978  {
3979  result = pltr0;
3980  pltr_type = CB_0;
3981  python_pltr = NULL;
3982  }
3983  else if ( strcmp( str, "<built-in function pltr1>" ) == 0 )
3984  {
3985  result = pltr1;
3986  pltr_type = CB_1;
3987  python_pltr = NULL;
3988  }
3989  else if ( strcmp( str, "<built-in function pltr2>" ) == 0 )
3990  {
3991  result = pltr2;
3992  pltr_type = CB_2;
3993  python_pltr = NULL;
3994  }
3995  else
3996  {
3997  python_pltr = input;
3998  pltr_type = CB_Python;
3999  Py_XINCREF( input );
4000  }
4001  Py_DECREF( rep );
4002  }
4003  else
4004  {
4005  python_pltr = input;
4006  pltr_type = CB_Python;
4007  Py_XINCREF( input );
4008  }
4009  return result;
4010  }
4011 
4012  void cleanup_pltr( void )
4013  {
4014  Py_XDECREF( python_pltr );
4015  python_pltr = 0;
4016  }
4017 
4018 // marshal the ct function pointer argument
4019  ct_func marshal_ct( PyObject* input )
4020  {
4021  ct_func result = do_ct_callback;
4022  python_ct = input;
4023  Py_XINCREF( input );
4024  return result;
4025  }
4026 
4027  void cleanup_ct( void )
4028  {
4029  Py_XDECREF( python_ct );
4030  python_ct = 0;
4031  }
4032 
4033 // marshal the mapform function pointer argument
4034  mapform_func marshal_mapform( PyObject* input )
4035  {
4037  python_mapform = input;
4038  Py_XINCREF( input );
4039  return result;
4040  }
4041 
4042  void cleanup_mapform( void )
4043  {
4044  Py_XDECREF( python_mapform );
4045  python_mapform = 0;
4046  }
4047 
4048  PLPointer marshal_PLPointer( PyObject* input, int isimg )
4049  {
4050  PLPointer result = NULL;
4051  switch ( pltr_type )
4052  {
4053  case CB_0:
4054  break;
4055  case CB_1:
4056  if ( input != Py_None )
4057  result = marshal_PLcGrid1( input, isimg );
4058  break;
4059  case CB_2:
4060  if ( input != Py_None )
4061  result = marshal_PLcGrid2( input, isimg );
4062  break;
4063  case CB_Python:
4064  Py_XINCREF( input );
4065  result = (PLPointer *) input;
4066  break;
4067  default:
4068  fprintf( stderr, "pltr_type is invalid\n" );
4069  }
4070  return result;
4071  }
4072 
4073  void cleanup_PLPointer( void )
4074  {
4075  switch ( pltr_type )
4076  {
4077  case CB_0:
4078  break;
4079  case CB_1:
4080  cleanup_PLcGrid1();
4081  break;
4082  case CB_2:
4083  cleanup_PLcGrid2();
4084  break;
4085  case CB_Python:
4086  Py_XDECREF( python_pltr );
4087  break;
4088  default:
4089  fprintf( stderr, "pltr_type is invalid\n" );
4090  }
4091  python_pltr = 0;
4092  pltr_type = CB_0;
4093  }
4094 
4095 
4096 
4097 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4098  PyObject *resultobj = 0;
4099  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4100  int arg2 ;
4101  void *argp1 = 0 ;
4102  int res1 = 0 ;
4103  int val2 ;
4104  int ecode2 = 0 ;
4105  PyObject * obj0 = 0 ;
4106  PyObject * obj1 = 0 ;
4107 
4108  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_type_set",&obj0,&obj1)) SWIG_fail;
4109  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4110  if (!SWIG_IsOK(res1)) {
4111  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4112  }
4113  arg1 = (PLGraphicsIn *)(argp1);
4114  ecode2 = SWIG_AsVal_int(obj1, &val2);
4115  if (!SWIG_IsOK(ecode2)) {
4116  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4117  }
4118  arg2 = (int)(val2);
4119  if (arg1) (arg1)->type = arg2;
4120  resultobj = SWIG_Py_Void();
4121  return resultobj;
4122 fail:
4123  return NULL;
4124 }
4125 
4126 
4127 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4128  PyObject *resultobj = 0;
4129  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4130  void *argp1 = 0 ;
4131  int res1 = 0 ;
4132  PyObject * obj0 = 0 ;
4133  int result;
4134 
4135  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_type_get",&obj0)) SWIG_fail;
4136  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4137  if (!SWIG_IsOK(res1)) {
4138  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4139  }
4140  arg1 = (PLGraphicsIn *)(argp1);
4141  result = (int) ((arg1)->type);
4142  resultobj = SWIG_From_int((int)(result));
4143  return resultobj;
4144 fail:
4145  return NULL;
4146 }
4147 
4148 
4149 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4150  PyObject *resultobj = 0;
4151  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4152  unsigned int arg2 ;
4153  void *argp1 = 0 ;
4154  int res1 = 0 ;
4155  unsigned int val2 ;
4156  int ecode2 = 0 ;
4157  PyObject * obj0 = 0 ;
4158  PyObject * obj1 = 0 ;
4159 
4160  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_state_set",&obj0,&obj1)) SWIG_fail;
4161  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4162  if (!SWIG_IsOK(res1)) {
4163  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4164  }
4165  arg1 = (PLGraphicsIn *)(argp1);
4166  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4167  if (!SWIG_IsOK(ecode2)) {
4168  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4169  }
4170  arg2 = (unsigned int)(val2);
4171  if (arg1) (arg1)->state = arg2;
4172  resultobj = SWIG_Py_Void();
4173  return resultobj;
4174 fail:
4175  return NULL;
4176 }
4177 
4178 
4179 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4180  PyObject *resultobj = 0;
4181  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4182  void *argp1 = 0 ;
4183  int res1 = 0 ;
4184  PyObject * obj0 = 0 ;
4185  unsigned int result;
4186 
4187  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_state_get",&obj0)) SWIG_fail;
4188  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4189  if (!SWIG_IsOK(res1)) {
4190  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4191  }
4192  arg1 = (PLGraphicsIn *)(argp1);
4193  result = (unsigned int) ((arg1)->state);
4194  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4195  return resultobj;
4196 fail:
4197  return NULL;
4198 }
4199 
4200 
4201 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4202  PyObject *resultobj = 0;
4203  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4204  unsigned int arg2 ;
4205  void *argp1 = 0 ;
4206  int res1 = 0 ;
4207  unsigned int val2 ;
4208  int ecode2 = 0 ;
4209  PyObject * obj0 = 0 ;
4210  PyObject * obj1 = 0 ;
4211 
4212  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_keysym_set",&obj0,&obj1)) SWIG_fail;
4213  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4214  if (!SWIG_IsOK(res1)) {
4215  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4216  }
4217  arg1 = (PLGraphicsIn *)(argp1);
4218  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4219  if (!SWIG_IsOK(ecode2)) {
4220  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4221  }
4222  arg2 = (unsigned int)(val2);
4223  if (arg1) (arg1)->keysym = arg2;
4224  resultobj = SWIG_Py_Void();
4225  return resultobj;
4226 fail:
4227  return NULL;
4228 }
4229 
4230 
4231 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4232  PyObject *resultobj = 0;
4233  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4234  void *argp1 = 0 ;
4235  int res1 = 0 ;
4236  PyObject * obj0 = 0 ;
4237  unsigned int result;
4238 
4239  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_keysym_get",&obj0)) SWIG_fail;
4240  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4241  if (!SWIG_IsOK(res1)) {
4242  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4243  }
4244  arg1 = (PLGraphicsIn *)(argp1);
4245  result = (unsigned int) ((arg1)->keysym);
4246  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4247  return resultobj;
4248 fail:
4249  return NULL;
4250 }
4251 
4252 
4253 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4254  PyObject *resultobj = 0;
4255  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4256  unsigned int arg2 ;
4257  void *argp1 = 0 ;
4258  int res1 = 0 ;
4259  unsigned int val2 ;
4260  int ecode2 = 0 ;
4261  PyObject * obj0 = 0 ;
4262  PyObject * obj1 = 0 ;
4263 
4264  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_button_set",&obj0,&obj1)) SWIG_fail;
4265  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4266  if (!SWIG_IsOK(res1)) {
4267  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4268  }
4269  arg1 = (PLGraphicsIn *)(argp1);
4270  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4271  if (!SWIG_IsOK(ecode2)) {
4272  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4273  }
4274  arg2 = (unsigned int)(val2);
4275  if (arg1) (arg1)->button = arg2;
4276  resultobj = SWIG_Py_Void();
4277  return resultobj;
4278 fail:
4279  return NULL;
4280 }
4281 
4282 
4283 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4284  PyObject *resultobj = 0;
4285  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4286  void *argp1 = 0 ;
4287  int res1 = 0 ;
4288  PyObject * obj0 = 0 ;
4289  unsigned int result;
4290 
4291  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_button_get",&obj0)) SWIG_fail;
4292  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4293  if (!SWIG_IsOK(res1)) {
4294  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4295  }
4296  arg1 = (PLGraphicsIn *)(argp1);
4297  result = (unsigned int) ((arg1)->button);
4298  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4299  return resultobj;
4300 fail:
4301  return NULL;
4302 }
4303 
4304 
4305 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4306  PyObject *resultobj = 0;
4307  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4308  PLINT arg2 ;
4309  void *argp1 = 0 ;
4310  int res1 = 0 ;
4311  int val2 ;
4312  int ecode2 = 0 ;
4313  PyObject * obj0 = 0 ;
4314  PyObject * obj1 = 0 ;
4315 
4316  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1)) SWIG_fail;
4317  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4318  if (!SWIG_IsOK(res1)) {
4319  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4320  }
4321  arg1 = (PLGraphicsIn *)(argp1);
4322  ecode2 = SWIG_AsVal_int(obj1, &val2);
4323  if (!SWIG_IsOK(ecode2)) {
4324  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4325  }
4326  arg2 = (PLINT)(val2);
4327  if (arg1) (arg1)->subwindow = arg2;
4328  resultobj = SWIG_Py_Void();
4329  return resultobj;
4330 fail:
4331  return NULL;
4332 }
4333 
4334 
4335 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4336  PyObject *resultobj = 0;
4337  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4338  void *argp1 = 0 ;
4339  int res1 = 0 ;
4340  PyObject * obj0 = 0 ;
4341  PLINT result;
4342 
4343  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_subwindow_get",&obj0)) SWIG_fail;
4344  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4345  if (!SWIG_IsOK(res1)) {
4346  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4347  }
4348  arg1 = (PLGraphicsIn *)(argp1);
4349  result = (PLINT) ((arg1)->subwindow);
4350  resultobj = SWIG_From_int((int)(result));
4351  return resultobj;
4352 fail:
4353  return NULL;
4354 }
4355 
4356 
4357 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4358  PyObject *resultobj = 0;
4359  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4360  char *arg2 ;
4361  void *argp1 = 0 ;
4362  int res1 = 0 ;
4363  char temp2[16] ;
4364  int res2 ;
4365  PyObject * obj0 = 0 ;
4366  PyObject * obj1 = 0 ;
4367 
4368  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_string_set",&obj0,&obj1)) SWIG_fail;
4369  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4370  if (!SWIG_IsOK(res1)) {
4371  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4372  }
4373  arg1 = (PLGraphicsIn *)(argp1);
4374  res2 = SWIG_AsCharArray(obj1, temp2, 16);
4375  if (!SWIG_IsOK(res2)) {
4376  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4377  }
4378  arg2 = (char *)(temp2);
4379  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4380  else memset(arg1->string,0,16*sizeof(char));
4381  resultobj = SWIG_Py_Void();
4382  return resultobj;
4383 fail:
4384  return NULL;
4385 }
4386 
4387 
4388 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4389  PyObject *resultobj = 0;
4390  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4391  void *argp1 = 0 ;
4392  int res1 = 0 ;
4393  PyObject * obj0 = 0 ;
4394  char *result = 0 ;
4395 
4396  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_string_get",&obj0)) SWIG_fail;
4397  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4398  if (!SWIG_IsOK(res1)) {
4399  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4400  }
4401  arg1 = (PLGraphicsIn *)(argp1);
4402  result = (char *)(char *) ((arg1)->string);
4403  {
4404  size_t size = 16;
4405 
4406  while (size && (result[size - 1] == '\0')) --size;
4407 
4408  resultobj = SWIG_FromCharPtrAndSize(result, size);
4409  }
4410  return resultobj;
4411 fail:
4412  return NULL;
4413 }
4414 
4415 
4416 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4417  PyObject *resultobj = 0;
4418  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4419  int arg2 ;
4420  void *argp1 = 0 ;
4421  int res1 = 0 ;
4422  int val2 ;
4423  int ecode2 = 0 ;
4424  PyObject * obj0 = 0 ;
4425  PyObject * obj1 = 0 ;
4426 
4427  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pX_set",&obj0,&obj1)) SWIG_fail;
4428  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4429  if (!SWIG_IsOK(res1)) {
4430  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4431  }
4432  arg1 = (PLGraphicsIn *)(argp1);
4433  ecode2 = SWIG_AsVal_int(obj1, &val2);
4434  if (!SWIG_IsOK(ecode2)) {
4435  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4436  }
4437  arg2 = (int)(val2);
4438  if (arg1) (arg1)->pX = arg2;
4439  resultobj = SWIG_Py_Void();
4440  return resultobj;
4441 fail:
4442  return NULL;
4443 }
4444 
4445 
4446 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4447  PyObject *resultobj = 0;
4448  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4449  void *argp1 = 0 ;
4450  int res1 = 0 ;
4451  PyObject * obj0 = 0 ;
4452  int result;
4453 
4454  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pX_get",&obj0)) SWIG_fail;
4455  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4456  if (!SWIG_IsOK(res1)) {
4457  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4458  }
4459  arg1 = (PLGraphicsIn *)(argp1);
4460  result = (int) ((arg1)->pX);
4461  resultobj = SWIG_From_int((int)(result));
4462  return resultobj;
4463 fail:
4464  return NULL;
4465 }
4466 
4467 
4468 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4469  PyObject *resultobj = 0;
4470  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4471  int arg2 ;
4472  void *argp1 = 0 ;
4473  int res1 = 0 ;
4474  int val2 ;
4475  int ecode2 = 0 ;
4476  PyObject * obj0 = 0 ;
4477  PyObject * obj1 = 0 ;
4478 
4479  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pY_set",&obj0,&obj1)) SWIG_fail;
4480  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4481  if (!SWIG_IsOK(res1)) {
4482  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4483  }
4484  arg1 = (PLGraphicsIn *)(argp1);
4485  ecode2 = SWIG_AsVal_int(obj1, &val2);
4486  if (!SWIG_IsOK(ecode2)) {
4487  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4488  }
4489  arg2 = (int)(val2);
4490  if (arg1) (arg1)->pY = arg2;
4491  resultobj = SWIG_Py_Void();
4492  return resultobj;
4493 fail:
4494  return NULL;
4495 }
4496 
4497 
4498 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4499  PyObject *resultobj = 0;
4500  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4501  void *argp1 = 0 ;
4502  int res1 = 0 ;
4503  PyObject * obj0 = 0 ;
4504  int result;
4505 
4506  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pY_get",&obj0)) SWIG_fail;
4507  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4508  if (!SWIG_IsOK(res1)) {
4509  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4510  }
4511  arg1 = (PLGraphicsIn *)(argp1);
4512  result = (int) ((arg1)->pY);
4513  resultobj = SWIG_From_int((int)(result));
4514  return resultobj;
4515 fail:
4516  return NULL;
4517 }
4518 
4519 
4520 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4521  PyObject *resultobj = 0;
4522  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4523  PLFLT arg2 ;
4524  void *argp1 = 0 ;
4525  int res1 = 0 ;
4526  double val2 ;
4527  int ecode2 = 0 ;
4528  PyObject * obj0 = 0 ;
4529  PyObject * obj1 = 0 ;
4530 
4531  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dX_set",&obj0,&obj1)) SWIG_fail;
4532  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4533  if (!SWIG_IsOK(res1)) {
4534  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4535  }
4536  arg1 = (PLGraphicsIn *)(argp1);
4537  ecode2 = SWIG_AsVal_double(obj1, &val2);
4538  if (!SWIG_IsOK(ecode2)) {
4539  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4540  }
4541  arg2 = (PLFLT)(val2);
4542  if (arg1) (arg1)->dX = arg2;
4543  resultobj = SWIG_Py_Void();
4544  return resultobj;
4545 fail:
4546  return NULL;
4547 }
4548 
4549 
4550 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4551  PyObject *resultobj = 0;
4552  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4553  void *argp1 = 0 ;
4554  int res1 = 0 ;
4555  PyObject * obj0 = 0 ;
4556  PLFLT result;
4557 
4558  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dX_get",&obj0)) SWIG_fail;
4559  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4560  if (!SWIG_IsOK(res1)) {
4561  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4562  }
4563  arg1 = (PLGraphicsIn *)(argp1);
4564  result = (PLFLT) ((arg1)->dX);
4565  resultobj = SWIG_From_double((double)(result));
4566  return resultobj;
4567 fail:
4568  return NULL;
4569 }
4570 
4571 
4572 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4573  PyObject *resultobj = 0;
4574  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4575  PLFLT arg2 ;
4576  void *argp1 = 0 ;
4577  int res1 = 0 ;
4578  double val2 ;
4579  int ecode2 = 0 ;
4580  PyObject * obj0 = 0 ;
4581  PyObject * obj1 = 0 ;
4582 
4583  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dY_set",&obj0,&obj1)) SWIG_fail;
4584  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4585  if (!SWIG_IsOK(res1)) {
4586  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4587  }
4588  arg1 = (PLGraphicsIn *)(argp1);
4589  ecode2 = SWIG_AsVal_double(obj1, &val2);
4590  if (!SWIG_IsOK(ecode2)) {
4591  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4592  }
4593  arg2 = (PLFLT)(val2);
4594  if (arg1) (arg1)->dY = arg2;
4595  resultobj = SWIG_Py_Void();
4596  return resultobj;
4597 fail:
4598  return NULL;
4599 }
4600 
4601 
4602 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4603  PyObject *resultobj = 0;
4604  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4605  void *argp1 = 0 ;
4606  int res1 = 0 ;
4607  PyObject * obj0 = 0 ;
4608  PLFLT result;
4609 
4610  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dY_get",&obj0)) SWIG_fail;
4611  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4612  if (!SWIG_IsOK(res1)) {
4613  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4614  }
4615  arg1 = (PLGraphicsIn *)(argp1);
4616  result = (PLFLT) ((arg1)->dY);
4617  resultobj = SWIG_From_double((double)(result));
4618  return resultobj;
4619 fail:
4620  return NULL;
4621 }
4622 
4623 
4624 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4625  PyObject *resultobj = 0;
4626  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4627  PLFLT arg2 ;
4628  void *argp1 = 0 ;
4629  int res1 = 0 ;
4630  double val2 ;
4631  int ecode2 = 0 ;
4632  PyObject * obj0 = 0 ;
4633  PyObject * obj1 = 0 ;
4634 
4635  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wX_set",&obj0,&obj1)) SWIG_fail;
4636  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4637  if (!SWIG_IsOK(res1)) {
4638  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4639  }
4640  arg1 = (PLGraphicsIn *)(argp1);
4641  ecode2 = SWIG_AsVal_double(obj1, &val2);
4642  if (!SWIG_IsOK(ecode2)) {
4643  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4644  }
4645  arg2 = (PLFLT)(val2);
4646  if (arg1) (arg1)->wX = arg2;
4647  resultobj = SWIG_Py_Void();
4648  return resultobj;
4649 fail:
4650  return NULL;
4651 }
4652 
4653 
4654 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4655  PyObject *resultobj = 0;
4656  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4657  void *argp1 = 0 ;
4658  int res1 = 0 ;
4659  PyObject * obj0 = 0 ;
4660  PLFLT result;
4661 
4662  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wX_get",&obj0)) SWIG_fail;
4663  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4664  if (!SWIG_IsOK(res1)) {
4665  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4666  }
4667  arg1 = (PLGraphicsIn *)(argp1);
4668  result = (PLFLT) ((arg1)->wX);
4669  resultobj = SWIG_From_double((double)(result));
4670  return resultobj;
4671 fail:
4672  return NULL;
4673 }
4674 
4675 
4676 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4677  PyObject *resultobj = 0;
4678  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4679  PLFLT arg2 ;
4680  void *argp1 = 0 ;
4681  int res1 = 0 ;
4682  double val2 ;
4683  int ecode2 = 0 ;
4684  PyObject * obj0 = 0 ;
4685  PyObject * obj1 = 0 ;
4686 
4687  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wY_set",&obj0,&obj1)) SWIG_fail;
4688  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4689  if (!SWIG_IsOK(res1)) {
4690  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4691  }
4692  arg1 = (PLGraphicsIn *)(argp1);
4693  ecode2 = SWIG_AsVal_double(obj1, &val2);
4694  if (!SWIG_IsOK(ecode2)) {
4695  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
4696  }
4697  arg2 = (PLFLT)(val2);
4698  if (arg1) (arg1)->wY = arg2;
4699  resultobj = SWIG_Py_Void();
4700  return resultobj;
4701 fail:
4702  return NULL;
4703 }
4704 
4705 
4706 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4707  PyObject *resultobj = 0;
4708  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4709  void *argp1 = 0 ;
4710  int res1 = 0 ;
4711  PyObject * obj0 = 0 ;
4712  PLFLT result;
4713 
4714  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wY_get",&obj0)) SWIG_fail;
4715  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4716  if (!SWIG_IsOK(res1)) {
4717  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4718  }
4719  arg1 = (PLGraphicsIn *)(argp1);
4720  result = (PLFLT) ((arg1)->wY);
4721  resultobj = SWIG_From_double((double)(result));
4722  return resultobj;
4723 fail:
4724  return NULL;
4725 }
4726 
4727 
4728 SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4729  PyObject *resultobj = 0;
4730  PLGraphicsIn *result = 0 ;
4731 
4732  if (!PyArg_ParseTuple(args,(char *)":new_PLGraphicsIn")) SWIG_fail;
4733  result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
4735  return resultobj;
4736 fail:
4737  return NULL;
4738 }
4739 
4740 
4741 SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4742  PyObject *resultobj = 0;
4743  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4744  void *argp1 = 0 ;
4745  int res1 = 0 ;
4746  PyObject * obj0 = 0 ;
4747 
4748  if (!PyArg_ParseTuple(args,(char *)"O:delete_PLGraphicsIn",&obj0)) SWIG_fail;
4749  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
4750  if (!SWIG_IsOK(res1)) {
4751  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4752  }
4753  arg1 = (PLGraphicsIn *)(argp1);
4754  free((char *) arg1);
4755  resultobj = SWIG_Py_Void();
4756  return resultobj;
4757 fail:
4758  return NULL;
4759 }
4760 
4761 
4762 SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4763  PyObject *obj;
4764  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4766  return SWIG_Py_Void();
4767 }
4768 
4769 SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4770  PyObject *resultobj = 0;
4771  PLINT arg1 ;
4772  int val1 ;
4773  int ecode1 = 0 ;
4774  PyObject * obj0 = 0 ;
4775 
4776  if (!PyArg_ParseTuple(args,(char *)"O:plsxwin",&obj0)) SWIG_fail;
4777  ecode1 = SWIG_AsVal_int(obj0, &val1);
4778  if (!SWIG_IsOK(ecode1)) {
4779  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
4780  }
4781  arg1 = (PLINT)(val1);
4782  plsxwin(arg1);
4783  resultobj = SWIG_Py_Void();
4784  return resultobj;
4785 fail:
4786  return NULL;
4787 }
4788 
4789 
4790 SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4791  PyObject *resultobj = 0;
4792  PLINT arg1 ;
4793  PLINT arg2 ;
4794  int val1 ;
4795  int ecode1 = 0 ;
4796  int val2 ;
4797  int ecode2 = 0 ;
4798  PyObject * obj0 = 0 ;
4799  PyObject * obj1 = 0 ;
4800 
4801  if (!PyArg_ParseTuple(args,(char *)"OO:pl_setcontlabelformat",&obj0,&obj1)) SWIG_fail;
4802  ecode1 = SWIG_AsVal_int(obj0, &val1);
4803  if (!SWIG_IsOK(ecode1)) {
4804  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
4805  }
4806  arg1 = (PLINT)(val1);
4807  ecode2 = SWIG_AsVal_int(obj1, &val2);
4808  if (!SWIG_IsOK(ecode2)) {
4809  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
4810  }
4811  arg2 = (PLINT)(val2);
4812  pl_setcontlabelformat(arg1,arg2);
4813  resultobj = SWIG_Py_Void();
4814  return resultobj;
4815 fail:
4816  return NULL;
4817 }
4818 
4819 
4820 SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4821  PyObject *resultobj = 0;
4822  PLFLT arg1 ;
4823  PLFLT arg2 ;
4824  PLFLT arg3 ;
4825  PLINT arg4 ;
4826  double val1 ;
4827  int ecode1 = 0 ;
4828  double val2 ;
4829  int ecode2 = 0 ;
4830  double val3 ;
4831  int ecode3 = 0 ;
4832  int val4 ;
4833  int ecode4 = 0 ;
4834  PyObject * obj0 = 0 ;
4835  PyObject * obj1 = 0 ;
4836  PyObject * obj2 = 0 ;
4837  PyObject * obj3 = 0 ;
4838 
4839  if (!PyArg_ParseTuple(args,(char *)"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4840  ecode1 = SWIG_AsVal_double(obj0, &val1);
4841  if (!SWIG_IsOK(ecode1)) {
4842  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
4843  }
4844  arg1 = (PLFLT)(val1);
4845  ecode2 = SWIG_AsVal_double(obj1, &val2);
4846  if (!SWIG_IsOK(ecode2)) {
4847  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
4848  }
4849  arg2 = (PLFLT)(val2);
4850  ecode3 = SWIG_AsVal_double(obj2, &val3);
4851  if (!SWIG_IsOK(ecode3)) {
4852  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
4853  }
4854  arg3 = (PLFLT)(val3);
4855  ecode4 = SWIG_AsVal_int(obj3, &val4);
4856  if (!SWIG_IsOK(ecode4)) {
4857  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
4858  }
4859  arg4 = (PLINT)(val4);
4860  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
4861  resultobj = SWIG_Py_Void();
4862  return resultobj;
4863 fail:
4864  return NULL;
4865 }
4866 
4867 
4868 SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4869  PyObject *resultobj = 0;
4870  PLINT arg1 ;
4871  int val1 ;
4872  int ecode1 = 0 ;
4873  PyObject * obj0 = 0 ;
4874 
4875  if (!PyArg_ParseTuple(args,(char *)"O:pladv",&obj0)) SWIG_fail;
4876  ecode1 = SWIG_AsVal_int(obj0, &val1);
4877  if (!SWIG_IsOK(ecode1)) {
4878  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
4879  }
4880  arg1 = (PLINT)(val1);
4881  pladv(arg1);
4882  resultobj = SWIG_Py_Void();
4883  return resultobj;
4884 fail:
4885  return NULL;
4886 }
4887 
4888 
4889 SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4890  PyObject *resultobj = 0;
4891  PLFLT arg1 ;
4892  PLFLT arg2 ;
4893  PLFLT arg3 ;
4894  PLFLT arg4 ;
4895  PLFLT arg5 ;
4896  PLFLT arg6 ;
4897  PLFLT arg7 ;
4898  PLBOOL arg8 ;
4899  double val1 ;
4900  int ecode1 = 0 ;
4901  double val2 ;
4902  int ecode2 = 0 ;
4903  double val3 ;
4904  int ecode3 = 0 ;
4905  double val4 ;
4906  int ecode4 = 0 ;
4907  double val5 ;
4908  int ecode5 = 0 ;
4909  double val6 ;
4910  int ecode6 = 0 ;
4911  double val7 ;
4912  int ecode7 = 0 ;
4913  int val8 ;
4914  int ecode8 = 0 ;
4915  PyObject * obj0 = 0 ;
4916  PyObject * obj1 = 0 ;
4917  PyObject * obj2 = 0 ;
4918  PyObject * obj3 = 0 ;
4919  PyObject * obj4 = 0 ;
4920  PyObject * obj5 = 0 ;
4921  PyObject * obj6 = 0 ;
4922  PyObject * obj7 = 0 ;
4923 
4924  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
4925  ecode1 = SWIG_AsVal_double(obj0, &val1);
4926  if (!SWIG_IsOK(ecode1)) {
4927  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
4928  }
4929  arg1 = (PLFLT)(val1);
4930  ecode2 = SWIG_AsVal_double(obj1, &val2);
4931  if (!SWIG_IsOK(ecode2)) {
4932  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
4933  }
4934  arg2 = (PLFLT)(val2);
4935  ecode3 = SWIG_AsVal_double(obj2, &val3);
4936  if (!SWIG_IsOK(ecode3)) {
4937  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
4938  }
4939  arg3 = (PLFLT)(val3);
4940  ecode4 = SWIG_AsVal_double(obj3, &val4);
4941  if (!SWIG_IsOK(ecode4)) {
4942  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
4943  }
4944  arg4 = (PLFLT)(val4);
4945  ecode5 = SWIG_AsVal_double(obj4, &val5);
4946  if (!SWIG_IsOK(ecode5)) {
4947  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
4948  }
4949  arg5 = (PLFLT)(val5);
4950  ecode6 = SWIG_AsVal_double(obj5, &val6);
4951  if (!SWIG_IsOK(ecode6)) {
4952  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
4953  }
4954  arg6 = (PLFLT)(val6);
4955  ecode7 = SWIG_AsVal_double(obj6, &val7);
4956  if (!SWIG_IsOK(ecode7)) {
4957  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
4958  }
4959  arg7 = (PLFLT)(val7);
4960  ecode8 = SWIG_AsVal_int(obj7, &val8);
4961  if (!SWIG_IsOK(ecode8)) {
4962  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
4963  }
4964  arg8 = (PLBOOL)(val8);
4965  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4966  resultobj = SWIG_Py_Void();
4967  return resultobj;
4968 fail:
4969  return NULL;
4970 }
4971 
4972 
4973 SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4974  PyObject *resultobj = 0;
4975  PLFLT arg1 ;
4976  PLFLT arg2 ;
4977  char *arg3 = (char *) 0 ;
4978  PLFLT arg4 ;
4979  PLINT arg5 ;
4980  char *arg6 = (char *) 0 ;
4981  PLFLT arg7 ;
4982  PLINT arg8 ;
4983  double val1 ;
4984  int ecode1 = 0 ;
4985  double val2 ;
4986  int ecode2 = 0 ;
4987  int res3 ;
4988  char *buf3 = 0 ;
4989  int alloc3 = 0 ;
4990  double val4 ;
4991  int ecode4 = 0 ;
4992  int val5 ;
4993  int ecode5 = 0 ;
4994  int res6 ;
4995  char *buf6 = 0 ;
4996  int alloc6 = 0 ;
4997  double val7 ;
4998  int ecode7 = 0 ;
4999  int val8 ;
5000  int ecode8 = 0 ;
5001  PyObject * obj0 = 0 ;
5002  PyObject * obj1 = 0 ;
5003  PyObject * obj2 = 0 ;
5004  PyObject * obj3 = 0 ;
5005  PyObject * obj4 = 0 ;
5006  PyObject * obj5 = 0 ;
5007  PyObject * obj6 = 0 ;
5008  PyObject * obj7 = 0 ;
5009 
5010  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5011  ecode1 = SWIG_AsVal_double(obj0, &val1);
5012  if (!SWIG_IsOK(ecode1)) {
5013  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5014  }
5015  arg1 = (PLFLT)(val1);
5016  ecode2 = SWIG_AsVal_double(obj1, &val2);
5017  if (!SWIG_IsOK(ecode2)) {
5018  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5019  }
5020  arg2 = (PLFLT)(val2);
5021  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
5022  if (!SWIG_IsOK(res3)) {
5023  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5024  }
5025  arg3 = (char *)(buf3);
5026  ecode4 = SWIG_AsVal_double(obj3, &val4);
5027  if (!SWIG_IsOK(ecode4)) {
5028  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5029  }
5030  arg4 = (PLFLT)(val4);
5031  ecode5 = SWIG_AsVal_int(obj4, &val5);
5032  if (!SWIG_IsOK(ecode5)) {
5033  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5034  }
5035  arg5 = (PLINT)(val5);
5036  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5037  if (!SWIG_IsOK(res6)) {
5038  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5039  }
5040  arg6 = (char *)(buf6);
5041  ecode7 = SWIG_AsVal_double(obj6, &val7);
5042  if (!SWIG_IsOK(ecode7)) {
5043  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5044  }
5045  arg7 = (PLFLT)(val7);
5046  ecode8 = SWIG_AsVal_int(obj7, &val8);
5047  if (!SWIG_IsOK(ecode8)) {
5048  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5049  }
5050  arg8 = (PLINT)(val8);
5051  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5052  resultobj = SWIG_Py_Void();
5053  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5054  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5055  return resultobj;
5056 fail:
5057  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5058  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5059  return NULL;
5060 }
5061 
5062 
5063 SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5064  PyObject *resultobj = 0;
5065  PLINT arg1 ;
5066  PLFLT *arg2 = (PLFLT *) 0 ;
5067  PLFLT *arg3 = (PLFLT *) 0 ;
5068  PLINT arg4 ;
5069  PyArrayObject *tmp1 ;
5070  PyArrayObject *tmp3 ;
5071  int val4 ;
5072  int ecode4 = 0 ;
5073  PyObject * obj0 = 0 ;
5074  PyObject * obj1 = 0 ;
5075  PyObject * obj2 = 0 ;
5076 
5077  if (!PyArg_ParseTuple(args,(char *)"OOO:plbin",&obj0,&obj1,&obj2)) SWIG_fail;
5078  {
5079  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
5080  if ( tmp1 == NULL )
5081  return NULL;
5082  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5083  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5084  }
5085  {
5086  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
5087  if ( tmp3 == NULL )
5088  return NULL;
5089  if ( PyArray_DIMS( tmp3 )[0] != Alen )
5090  {
5091  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5092  return NULL;
5093  }
5094  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5095  }
5096  ecode4 = SWIG_AsVal_int(obj2, &val4);
5097  if (!SWIG_IsOK(ecode4)) {
5098  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5099  }
5100  arg4 = (PLINT)(val4);
5101  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5102  resultobj = SWIG_Py_Void();
5103  {
5104  Py_DECREF( tmp1 );
5105  }
5106  {
5107  Py_DECREF( tmp3 );
5108  }
5109  return resultobj;
5110 fail:
5111  {
5112  Py_DECREF( tmp1 );
5113  }
5114  {
5115  Py_DECREF( tmp3 );
5116  }
5117  return NULL;
5118 }
5119 
5120 
5121 SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5122  PyObject *resultobj = 0;
5123  PLINT *arg1 = (PLINT *) 0 ;
5124  PLINT *arg2 = (PLINT *) 0 ;
5125  PLINT *arg3 = (PLINT *) 0 ;
5126  PLINT *arg4 = (PLINT *) 0 ;
5127  PLINT *arg5 = (PLINT *) 0 ;
5128  PLFLT *arg6 = (PLFLT *) 0 ;
5129  PLFLT arg7 ;
5130  PLINT temp1 ;
5131  int res1 = SWIG_TMPOBJ ;
5132  PLINT temp2 ;
5133  int res2 = SWIG_TMPOBJ ;
5134  PLINT temp3 ;
5135  int res3 = SWIG_TMPOBJ ;
5136  PLINT temp4 ;
5137  int res4 = SWIG_TMPOBJ ;
5138  PLINT temp5 ;
5139  int res5 = SWIG_TMPOBJ ;
5140  PLFLT temp6 ;
5141  int res6 = SWIG_TMPOBJ ;
5142  double val7 ;
5143  int ecode7 = 0 ;
5144  PyObject * obj0 = 0 ;
5145 
5146  arg1 = &temp1;
5147  arg2 = &temp2;
5148  arg3 = &temp3;
5149  arg4 = &temp4;
5150  arg5 = &temp5;
5151  arg6 = &temp6;
5152  if (!PyArg_ParseTuple(args,(char *)"O:plbtime",&obj0)) SWIG_fail;
5153  ecode7 = SWIG_AsVal_double(obj0, &val7);
5154  if (!SWIG_IsOK(ecode7)) {
5155  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5156  }
5157  arg7 = (PLFLT)(val7);
5158  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5159  resultobj = SWIG_Py_Void();
5160  if (SWIG_IsTmpObj(res1)) {
5161  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5162  } else {
5163  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5164  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5165  }
5166  if (SWIG_IsTmpObj(res2)) {
5167  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5168  } else {
5169  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5170  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5171  }
5172  if (SWIG_IsTmpObj(res3)) {
5173  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
5174  } else {
5175  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5176  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
5177  }
5178  if (SWIG_IsTmpObj(res4)) {
5179  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
5180  } else {
5181  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5182  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
5183  }
5184  if (SWIG_IsTmpObj(res5)) {
5185  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5186  } else {
5187  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5188  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5189  }
5190  if (SWIG_IsTmpObj(res6)) {
5191  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
5192  } else {
5193  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5194  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
5195  }
5196  return resultobj;
5197 fail:
5198  return NULL;
5199 }
5200 
5201 
5202 SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5203  PyObject *resultobj = 0;
5204 
5205  if (!PyArg_ParseTuple(args,(char *)":plbop")) SWIG_fail;
5206  plbop();
5207  resultobj = SWIG_Py_Void();
5208  return resultobj;
5209 fail:
5210  return NULL;
5211 }
5212 
5213 
5214 SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5215  PyObject *resultobj = 0;
5216  char *arg1 = (char *) 0 ;
5217  PLFLT arg2 ;
5218  PLINT arg3 ;
5219  char *arg4 = (char *) 0 ;
5220  PLFLT arg5 ;
5221  PLINT arg6 ;
5222  int res1 ;
5223  char *buf1 = 0 ;
5224  int alloc1 = 0 ;
5225  double val2 ;
5226  int ecode2 = 0 ;
5227  int val3 ;
5228  int ecode3 = 0 ;
5229  int res4 ;
5230  char *buf4 = 0 ;
5231  int alloc4 = 0 ;
5232  double val5 ;
5233  int ecode5 = 0 ;
5234  int val6 ;
5235  int ecode6 = 0 ;
5236  PyObject * obj0 = 0 ;
5237  PyObject * obj1 = 0 ;
5238  PyObject * obj2 = 0 ;
5239  PyObject * obj3 = 0 ;
5240  PyObject * obj4 = 0 ;
5241  PyObject * obj5 = 0 ;
5242 
5243  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5244  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5245  if (!SWIG_IsOK(res1)) {
5246  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5247  }
5248  arg1 = (char *)(buf1);
5249  ecode2 = SWIG_AsVal_double(obj1, &val2);
5250  if (!SWIG_IsOK(ecode2)) {
5251  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5252  }
5253  arg2 = (PLFLT)(val2);
5254  ecode3 = SWIG_AsVal_int(obj2, &val3);
5255  if (!SWIG_IsOK(ecode3)) {
5256  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5257  }
5258  arg3 = (PLINT)(val3);
5259  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5260  if (!SWIG_IsOK(res4)) {
5261  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5262  }
5263  arg4 = (char *)(buf4);
5264  ecode5 = SWIG_AsVal_double(obj4, &val5);
5265  if (!SWIG_IsOK(ecode5)) {
5266  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5267  }
5268  arg5 = (PLFLT)(val5);
5269  ecode6 = SWIG_AsVal_int(obj5, &val6);
5270  if (!SWIG_IsOK(ecode6)) {
5271  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5272  }
5273  arg6 = (PLINT)(val6);
5274  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5275  resultobj = SWIG_Py_Void();
5276  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5277  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5278  return resultobj;
5279 fail:
5280  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5281  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5282  return NULL;
5283 }
5284 
5285 
5286 SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5287  PyObject *resultobj = 0;
5288  char *arg1 = (char *) 0 ;
5289  char *arg2 = (char *) 0 ;
5290  PLFLT arg3 ;
5291  PLINT arg4 ;
5292  char *arg5 = (char *) 0 ;
5293  char *arg6 = (char *) 0 ;
5294  PLFLT arg7 ;
5295  PLINT arg8 ;
5296  char *arg9 = (char *) 0 ;
5297  char *arg10 = (char *) 0 ;
5298  PLFLT arg11 ;
5299  PLINT arg12 ;
5300  int res1 ;
5301  char *buf1 = 0 ;
5302  int alloc1 = 0 ;
5303  int res2 ;
5304  char *buf2 = 0 ;
5305  int alloc2 = 0 ;
5306  double val3 ;
5307  int ecode3 = 0 ;
5308  int val4 ;
5309  int ecode4 = 0 ;
5310  int res5 ;
5311  char *buf5 = 0 ;
5312  int alloc5 = 0 ;
5313  int res6 ;
5314  char *buf6 = 0 ;
5315  int alloc6 = 0 ;
5316  double val7 ;
5317  int ecode7 = 0 ;
5318  int val8 ;
5319  int ecode8 = 0 ;
5320  int res9 ;
5321  char *buf9 = 0 ;
5322  int alloc9 = 0 ;
5323  int res10 ;
5324  char *buf10 = 0 ;
5325  int alloc10 = 0 ;
5326  double val11 ;
5327  int ecode11 = 0 ;
5328  int val12 ;
5329  int ecode12 = 0 ;
5330  PyObject * obj0 = 0 ;
5331  PyObject * obj1 = 0 ;
5332  PyObject * obj2 = 0 ;
5333  PyObject * obj3 = 0 ;
5334  PyObject * obj4 = 0 ;
5335  PyObject * obj5 = 0 ;
5336  PyObject * obj6 = 0 ;
5337  PyObject * obj7 = 0 ;
5338  PyObject * obj8 = 0 ;
5339  PyObject * obj9 = 0 ;
5340  PyObject * obj10 = 0 ;
5341  PyObject * obj11 = 0 ;
5342 
5343  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
5344  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5345  if (!SWIG_IsOK(res1)) {
5346  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5347  }
5348  arg1 = (char *)(buf1);
5349  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5350  if (!SWIG_IsOK(res2)) {
5351  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5352  }
5353  arg2 = (char *)(buf2);
5354  ecode3 = SWIG_AsVal_double(obj2, &val3);
5355  if (!SWIG_IsOK(ecode3)) {
5356  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5357  }
5358  arg3 = (PLFLT)(val3);
5359  ecode4 = SWIG_AsVal_int(obj3, &val4);
5360  if (!SWIG_IsOK(ecode4)) {
5361  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5362  }
5363  arg4 = (PLINT)(val4);
5364  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
5365  if (!SWIG_IsOK(res5)) {
5366  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5367  }
5368  arg5 = (char *)(buf5);
5369  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5370  if (!SWIG_IsOK(res6)) {
5371  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5372  }
5373  arg6 = (char *)(buf6);
5374  ecode7 = SWIG_AsVal_double(obj6, &val7);
5375  if (!SWIG_IsOK(ecode7)) {
5376  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5377  }
5378  arg7 = (PLFLT)(val7);
5379  ecode8 = SWIG_AsVal_int(obj7, &val8);
5380  if (!SWIG_IsOK(ecode8)) {
5381  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5382  }
5383  arg8 = (PLINT)(val8);
5384  res9 = SWIG_AsCharPtrAndSize(obj8, &buf9, NULL, &alloc9);
5385  if (!SWIG_IsOK(res9)) {
5386  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5387  }
5388  arg9 = (char *)(buf9);
5389  res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
5390  if (!SWIG_IsOK(res10)) {
5391  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5392  }
5393  arg10 = (char *)(buf10);
5394  ecode11 = SWIG_AsVal_double(obj10, &val11);
5395  if (!SWIG_IsOK(ecode11)) {
5396  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5397  }
5398  arg11 = (PLFLT)(val11);
5399  ecode12 = SWIG_AsVal_int(obj11, &val12);
5400  if (!SWIG_IsOK(ecode12)) {
5401  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5402  }
5403  arg12 = (PLINT)(val12);
5404  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);
5405  resultobj = SWIG_Py_Void();
5406  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5407  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5408  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5409  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5410  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5411  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5412  return resultobj;
5413 fail:
5414  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5415  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5416  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5417  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5418  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5419  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5420  return NULL;
5421 }
5422 
5423 
5424 SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5425  PyObject *resultobj = 0;
5426  PLFLT arg1 ;
5427  PLFLT arg2 ;
5428  PLFLT *arg3 = (PLFLT *) 0 ;
5429  PLFLT *arg4 = (PLFLT *) 0 ;
5430  PLINT *arg5 = (PLINT *) 0 ;
5431  double val1 ;
5432  int ecode1 = 0 ;
5433  double val2 ;
5434  int ecode2 = 0 ;
5435  PLFLT temp3 ;
5436  int res3 = SWIG_TMPOBJ ;
5437  PLFLT temp4 ;
5438  int res4 = SWIG_TMPOBJ ;
5439  PLINT temp5 ;
5440  int res5 = SWIG_TMPOBJ ;
5441  PyObject * obj0 = 0 ;
5442  PyObject * obj1 = 0 ;
5443 
5444  arg3 = &temp3;
5445  arg4 = &temp4;
5446  arg5 = &temp5;
5447  if (!PyArg_ParseTuple(args,(char *)"OO:plcalc_world",&obj0,&obj1)) SWIG_fail;
5448  ecode1 = SWIG_AsVal_double(obj0, &val1);
5449  if (!SWIG_IsOK(ecode1)) {
5450  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5451  }
5452  arg1 = (PLFLT)(val1);
5453  ecode2 = SWIG_AsVal_double(obj1, &val2);
5454  if (!SWIG_IsOK(ecode2)) {
5455  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5456  }
5457  arg2 = (PLFLT)(val2);
5458  plcalc_world(arg1,arg2,arg3,arg4,arg5);
5459  resultobj = SWIG_Py_Void();
5460  if (SWIG_IsTmpObj(res3)) {
5461  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5462  } else {
5463  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5464  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5465  }
5466  if (SWIG_IsTmpObj(res4)) {
5467  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5468  } else {
5469  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5470  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5471  }
5472  if (SWIG_IsTmpObj(res5)) {
5473  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5474  } else {
5475  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5476  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5477  }
5478  return resultobj;
5479 fail:
5480  return NULL;
5481 }
5482 
5483 
5484 SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5485  PyObject *resultobj = 0;
5486 
5487  if (!PyArg_ParseTuple(args,(char *)":plclear")) SWIG_fail;
5488  plclear();
5489  resultobj = SWIG_Py_Void();
5490  return resultobj;
5491 fail:
5492  return NULL;
5493 }
5494 
5495 
5496 SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5497  PyObject *resultobj = 0;
5498  PLINT arg1 ;
5499  int val1 ;
5500  int ecode1 = 0 ;
5501  PyObject * obj0 = 0 ;
5502 
5503  if (!PyArg_ParseTuple(args,(char *)"O:plcol0",&obj0)) SWIG_fail;
5504  ecode1 = SWIG_AsVal_int(obj0, &val1);
5505  if (!SWIG_IsOK(ecode1)) {
5506  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5507  }
5508  arg1 = (PLINT)(val1);
5509  plcol0(arg1);
5510  resultobj = SWIG_Py_Void();
5511  return resultobj;
5512 fail:
5513  return NULL;
5514 }
5515 
5516 
5517 SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5518  PyObject *resultobj = 0;
5519  PLFLT arg1 ;
5520  double val1 ;
5521  int ecode1 = 0 ;
5522  PyObject * obj0 = 0 ;
5523 
5524  if (!PyArg_ParseTuple(args,(char *)"O:plcol1",&obj0)) SWIG_fail;
5525  ecode1 = SWIG_AsVal_double(obj0, &val1);
5526  if (!SWIG_IsOK(ecode1)) {
5527  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5528  }
5529  arg1 = (PLFLT)(val1);
5530  plcol1(arg1);
5531  resultobj = SWIG_Py_Void();
5532  return resultobj;
5533 fail:
5534  return NULL;
5535 }
5536 
5537 
5538 SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5539  PyObject *resultobj = 0;
5540  PLFLT arg1 ;
5541  PLFLT arg2 ;
5542  PLFLT arg3 ;
5543  PLINT arg4 ;
5544  PLBOOL arg5 ;
5545  PLINT arg6 ;
5546  PLINT arg7 ;
5547  PLINT arg8 ;
5548  PLINT arg9 ;
5549  PLINT arg10 ;
5550  PLFLT arg11 ;
5551  double val1 ;
5552  int ecode1 = 0 ;
5553  double val2 ;
5554  int ecode2 = 0 ;
5555  double val3 ;
5556  int ecode3 = 0 ;
5557  int val4 ;
5558  int ecode4 = 0 ;
5559  int val5 ;
5560  int ecode5 = 0 ;
5561  int val6 ;
5562  int ecode6 = 0 ;
5563  int val7 ;
5564  int ecode7 = 0 ;
5565  int val8 ;
5566  int ecode8 = 0 ;
5567  int val9 ;
5568  int ecode9 = 0 ;
5569  int val10 ;
5570  int ecode10 = 0 ;
5571  double val11 ;
5572  int ecode11 = 0 ;
5573  PyObject * obj0 = 0 ;
5574  PyObject * obj1 = 0 ;
5575  PyObject * obj2 = 0 ;
5576  PyObject * obj3 = 0 ;
5577  PyObject * obj4 = 0 ;
5578  PyObject * obj5 = 0 ;
5579  PyObject * obj6 = 0 ;
5580  PyObject * obj7 = 0 ;
5581  PyObject * obj8 = 0 ;
5582  PyObject * obj9 = 0 ;
5583  PyObject * obj10 = 0 ;
5584 
5585  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
5586  ecode1 = SWIG_AsVal_double(obj0, &val1);
5587  if (!SWIG_IsOK(ecode1)) {
5588  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5589  }
5590  arg1 = (PLFLT)(val1);
5591  ecode2 = SWIG_AsVal_double(obj1, &val2);
5592  if (!SWIG_IsOK(ecode2)) {
5593  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5594  }
5595  arg2 = (PLFLT)(val2);
5596  ecode3 = SWIG_AsVal_double(obj2, &val3);
5597  if (!SWIG_IsOK(ecode3)) {
5598  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5599  }
5600  arg3 = (PLFLT)(val3);
5601  ecode4 = SWIG_AsVal_int(obj3, &val4);
5602  if (!SWIG_IsOK(ecode4)) {
5603  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5604  }
5605  arg4 = (PLINT)(val4);
5606  ecode5 = SWIG_AsVal_int(obj4, &val5);
5607  if (!SWIG_IsOK(ecode5)) {
5608  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5609  }
5610  arg5 = (PLBOOL)(val5);
5611  ecode6 = SWIG_AsVal_int(obj5, &val6);
5612  if (!SWIG_IsOK(ecode6)) {
5613  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5614  }
5615  arg6 = (PLINT)(val6);
5616  ecode7 = SWIG_AsVal_int(obj6, &val7);
5617  if (!SWIG_IsOK(ecode7)) {
5618  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5619  }
5620  arg7 = (PLINT)(val7);
5621  ecode8 = SWIG_AsVal_int(obj7, &val8);
5622  if (!SWIG_IsOK(ecode8)) {
5623  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5624  }
5625  arg8 = (PLINT)(val8);
5626  ecode9 = SWIG_AsVal_int(obj8, &val9);
5627  if (!SWIG_IsOK(ecode9)) {
5628  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5629  }
5630  arg9 = (PLINT)(val9);
5631  ecode10 = SWIG_AsVal_int(obj9, &val10);
5632  if (!SWIG_IsOK(ecode10)) {
5633  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5634  }
5635  arg10 = (PLINT)(val10);
5636  ecode11 = SWIG_AsVal_double(obj10, &val11);
5637  if (!SWIG_IsOK(ecode11)) {
5638  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5639  }
5640  arg11 = (PLFLT)(val11);
5641  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5642  resultobj = SWIG_Py_Void();
5643  return resultobj;
5644 fail:
5645  return NULL;
5646 }
5647 
5648 
5649 SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5650  PyObject *resultobj = 0;
5651  PLFLT **arg1 = (PLFLT **) 0 ;
5652  PLINT arg2 ;
5653  PLINT arg3 ;
5654  PLINT arg4 ;
5655  PLINT arg5 ;
5656  PLINT arg6 ;
5657  PLINT arg7 ;
5658  PLFLT *arg8 = (PLFLT *) 0 ;
5659  PLINT arg9 ;
5660  pltr_func arg10 = (pltr_func) 0 ;
5661  PLPointer arg11 = (PLPointer) 0 ;
5662  PyArrayObject *tmp1 ;
5663  int val4 ;
5664  int ecode4 = 0 ;
5665  int val5 ;
5666  int ecode5 = 0 ;
5667  int val6 ;
5668  int ecode6 = 0 ;
5669  int val7 ;
5670  int ecode7 = 0 ;
5671  PyArrayObject *tmp8 ;
5672  PyObject * obj0 = 0 ;
5673  PyObject * obj1 = 0 ;
5674  PyObject * obj2 = 0 ;
5675  PyObject * obj3 = 0 ;
5676  PyObject * obj4 = 0 ;
5677  PyObject * obj5 = 0 ;
5678  PyObject * obj6 = 0 ;
5679  PyObject * obj7 = 0 ;
5680 
5681  {
5682  python_pltr = 0;
5683  arg10 = NULL;
5684  }
5685  {
5686  arg11 = NULL;
5687  }
5688  if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5689  {
5690  int i, size;
5691  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
5692  if ( tmp1 == NULL )
5693  return NULL;
5694  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5695  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5696  size = sizeof ( PLFLT ) * arg3;
5697  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
5698  for ( i = 0; i < arg2; i++ )
5699  arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
5700  }
5701  ecode4 = SWIG_AsVal_int(obj1, &val4);
5702  if (!SWIG_IsOK(ecode4)) {
5703  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
5704  }
5705  arg4 = (PLINT)(val4);
5706  ecode5 = SWIG_AsVal_int(obj2, &val5);
5707  if (!SWIG_IsOK(ecode5)) {
5708  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
5709  }
5710  arg5 = (PLINT)(val5);
5711  ecode6 = SWIG_AsVal_int(obj3, &val6);
5712  if (!SWIG_IsOK(ecode6)) {
5713  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
5714  }
5715  arg6 = (PLINT)(val6);
5716  ecode7 = SWIG_AsVal_int(obj4, &val7);
5717  if (!SWIG_IsOK(ecode7)) {
5718  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
5719  }
5720  arg7 = (PLINT)(val7);
5721  {
5722  tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
5723  if ( tmp8 == NULL )
5724  return NULL;
5725  arg9 = PyArray_DIMS( tmp8 )[0];
5726  arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5727  }
5728  if (obj6) {
5729  {
5730  // it must be a callable or None
5731  if ( obj6 == Py_None )
5732  {
5733  arg10 = NULL;
5734  }
5735  else
5736  {
5737  if ( !PyCallable_Check( (PyObject *) obj6 ) )
5738  {
5739  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
5740  return NULL;
5741  }
5742  arg10 = marshal_pltr( obj6 );
5743  }
5744  }
5745  }
5746  if (obj7) {
5747  {
5748  if ( obj7 == Py_None )
5749  arg11 = NULL;
5750  else
5751  {
5752  arg11 = marshal_PLPointer( obj7, 0 );
5753  }
5754  }
5755  }
5756  plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
5757  resultobj = SWIG_Py_Void();
5758  {
5759  Py_DECREF( tmp1 );
5760  free( arg1 );
5761  }
5762  {
5763  Py_DECREF( tmp8 );
5764  }
5765  {
5766  cleanup_pltr();
5767  }
5768  {
5770  }
5771  return resultobj;
5772 fail:
5773  {
5774  Py_DECREF( tmp1 );
5775  free( arg1 );
5776  }
5777  {
5778  Py_DECREF( tmp8 );
5779  }
5780  {
5781  cleanup_pltr();
5782  }
5783  {
5785  }
5786  return NULL;
5787 }
5788 
5789 
5790 SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5791  PyObject *resultobj = 0;
5792  PLINT arg1 ;
5793  PLINT arg2 ;
5794  PLINT arg3 ;
5795  PLINT arg4 ;
5796  PLINT arg5 ;
5797  PLFLT arg6 ;
5798  PLFLT *arg7 = (PLFLT *) 0 ;
5799  int val1 ;
5800  int ecode1 = 0 ;
5801  int val2 ;
5802  int ecode2 = 0 ;
5803  int val3 ;
5804  int ecode3 = 0 ;
5805  int val4 ;
5806  int ecode4 = 0 ;
5807  int val5 ;
5808  int ecode5 = 0 ;
5809  double val6 ;
5810  int ecode6 = 0 ;
5811  PLFLT temp7 ;
5812  int res7 = SWIG_TMPOBJ ;
5813  PyObject * obj0 = 0 ;
5814  PyObject * obj1 = 0 ;
5815  PyObject * obj2 = 0 ;
5816  PyObject * obj3 = 0 ;
5817  PyObject * obj4 = 0 ;
5818  PyObject * obj5 = 0 ;
5819 
5820  arg7 = &temp7;
5821  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5822  ecode1 = SWIG_AsVal_int(obj0, &val1);
5823  if (!SWIG_IsOK(ecode1)) {
5824  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
5825  }
5826  arg1 = (PLINT)(val1);
5827  ecode2 = SWIG_AsVal_int(obj1, &val2);
5828  if (!SWIG_IsOK(ecode2)) {
5829  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
5830  }
5831  arg2 = (PLINT)(val2);
5832  ecode3 = SWIG_AsVal_int(obj2, &val3);
5833  if (!SWIG_IsOK(ecode3)) {
5834  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
5835  }
5836  arg3 = (PLINT)(val3);
5837  ecode4 = SWIG_AsVal_int(obj3, &val4);
5838  if (!SWIG_IsOK(ecode4)) {
5839  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
5840  }
5841  arg4 = (PLINT)(val4);
5842  ecode5 = SWIG_AsVal_int(obj4, &val5);
5843  if (!SWIG_IsOK(ecode5)) {
5844  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
5845  }
5846  arg5 = (PLINT)(val5);
5847  ecode6 = SWIG_AsVal_double(obj5, &val6);
5848  if (!SWIG_IsOK(ecode6)) {
5849  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
5850  }
5851  arg6 = (PLFLT)(val6);
5852  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5853  resultobj = SWIG_Py_Void();
5854  if (SWIG_IsTmpObj(res7)) {
5855  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
5856  } else {
5857  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5858  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
5859  }
5860  return resultobj;
5861 fail:
5862  return NULL;
5863 }
5864 
5865 
5866 SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5867  PyObject *resultobj = 0;
5868  PLINT arg1 ;
5869  PLBOOL arg2 ;
5870  int val1 ;
5871  int ecode1 = 0 ;
5872  int val2 ;
5873  int ecode2 = 0 ;
5874  PyObject * obj0 = 0 ;
5875  PyObject * obj1 = 0 ;
5876 
5877  if (!PyArg_ParseTuple(args,(char *)"OO:plcpstrm",&obj0,&obj1)) SWIG_fail;
5878  ecode1 = SWIG_AsVal_int(obj0, &val1);
5879  if (!SWIG_IsOK(ecode1)) {
5880  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
5881  }
5882  arg1 = (PLINT)(val1);
5883  ecode2 = SWIG_AsVal_int(obj1, &val2);
5884  if (!SWIG_IsOK(ecode2)) {
5885  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
5886  }
5887  arg2 = (PLBOOL)(val2);
5888  plcpstrm(arg1,arg2);
5889  resultobj = SWIG_Py_Void();
5890  return resultobj;
5891 fail:
5892  return NULL;
5893 }
5894 
5895 
5896 SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5897  PyObject *resultobj = 0;
5898 
5899  if (!PyArg_ParseTuple(args,(char *)":plend")) SWIG_fail;
5900  plend();
5901  resultobj = SWIG_Py_Void();
5902  return resultobj;
5903 fail:
5904  return NULL;
5905 }
5906 
5907 
5908 SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5909  PyObject *resultobj = 0;
5910 
5911  if (!PyArg_ParseTuple(args,(char *)":plend1")) SWIG_fail;
5912  plend1();
5913  resultobj = SWIG_Py_Void();
5914  return resultobj;
5915 fail:
5916  return NULL;
5917 }
5918 
5919 
5920 SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5921  PyObject *resultobj = 0;
5922  PLFLT arg1 ;
5923  PLFLT arg2 ;
5924  PLFLT arg3 ;
5925  PLFLT arg4 ;
5926  PLINT arg5 ;
5927  PLINT arg6 ;
5928  double val1 ;
5929  int ecode1 = 0 ;
5930  double val2 ;
5931  int ecode2 = 0 ;
5932  double val3 ;
5933  int ecode3 = 0 ;
5934  double val4 ;
5935  int ecode4 = 0 ;
5936  int val5 ;
5937  int ecode5 = 0 ;
5938  int val6 ;
5939  int ecode6 = 0 ;
5940  PyObject * obj0 = 0 ;
5941  PyObject * obj1 = 0 ;
5942  PyObject * obj2 = 0 ;
5943  PyObject * obj3 = 0 ;
5944  PyObject * obj4 = 0 ;
5945  PyObject * obj5 = 0 ;
5946 
5947  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5948  ecode1 = SWIG_AsVal_double(obj0, &val1);
5949  if (!SWIG_IsOK(ecode1)) {
5950  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
5951  }
5952  arg1 = (PLFLT)(val1);
5953  ecode2 = SWIG_AsVal_double(obj1, &val2);
5954  if (!SWIG_IsOK(ecode2)) {
5955  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
5956  }
5957  arg2 = (PLFLT)(val2);
5958  ecode3 = SWIG_AsVal_double(obj2, &val3);
5959  if (!SWIG_IsOK(ecode3)) {
5960  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
5961  }
5962  arg3 = (PLFLT)(val3);
5963  ecode4 = SWIG_AsVal_double(obj3, &val4);
5964  if (!SWIG_IsOK(ecode4)) {
5965  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
5966  }
5967  arg4 = (PLFLT)(val4);
5968  ecode5 = SWIG_AsVal_int(obj4, &val5);
5969  if (!SWIG_IsOK(ecode5)) {
5970  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
5971  }
5972  arg5 = (PLINT)(val5);
5973  ecode6 = SWIG_AsVal_int(obj5, &val6);
5974  if (!SWIG_IsOK(ecode6)) {
5975  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
5976  }
5977  arg6 = (PLINT)(val6);
5978  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
5979  resultobj = SWIG_Py_Void();
5980  return resultobj;
5981 fail:
5982  return NULL;
5983 }
5984 
5985 
5986 SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5987  PyObject *resultobj = 0;
5988  PLFLT arg1 ;
5989  PLFLT arg2 ;
5990  PLFLT arg3 ;
5991  PLFLT arg4 ;
5992  PLINT arg5 ;
5993  PLINT arg6 ;
5994  double val1 ;
5995  int ecode1 = 0 ;
5996  double val2 ;
5997  int ecode2 = 0 ;
5998  double val3 ;
5999  int ecode3 = 0 ;
6000  double val4 ;
6001  int ecode4 = 0 ;
6002  int val5 ;
6003  int ecode5 = 0 ;
6004  int val6 ;
6005  int ecode6 = 0 ;
6006  PyObject * obj0 = 0 ;
6007  PyObject * obj1 = 0 ;
6008  PyObject * obj2 = 0 ;
6009  PyObject * obj3 = 0 ;
6010  PyObject * obj4 = 0 ;
6011  PyObject * obj5 = 0 ;
6012 
6013  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6014  ecode1 = SWIG_AsVal_double(obj0, &val1);
6015  if (!SWIG_IsOK(ecode1)) {
6016  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6017  }
6018  arg1 = (PLFLT)(val1);
6019  ecode2 = SWIG_AsVal_double(obj1, &val2);
6020  if (!SWIG_IsOK(ecode2)) {
6021  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6022  }
6023  arg2 = (PLFLT)(val2);
6024  ecode3 = SWIG_AsVal_double(obj2, &val3);
6025  if (!SWIG_IsOK(ecode3)) {
6026  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6027  }
6028  arg3 = (PLFLT)(val3);
6029  ecode4 = SWIG_AsVal_double(obj3, &val4);
6030  if (!SWIG_IsOK(ecode4)) {
6031  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6032  }
6033  arg4 = (PLFLT)(val4);
6034  ecode5 = SWIG_AsVal_int(obj4, &val5);
6035  if (!SWIG_IsOK(ecode5)) {
6036  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6037  }
6038  arg5 = (PLINT)(val5);
6039  ecode6 = SWIG_AsVal_int(obj5, &val6);
6040  if (!SWIG_IsOK(ecode6)) {
6041  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6042  }
6043  arg6 = (PLINT)(val6);
6044  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6045  resultobj = SWIG_Py_Void();
6046  return resultobj;
6047 fail:
6048  return NULL;
6049 }
6050 
6051 
6052 SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6053  PyObject *resultobj = 0;
6054 
6055  if (!PyArg_ParseTuple(args,(char *)":pleop")) SWIG_fail;
6056  pleop();
6057  resultobj = SWIG_Py_Void();
6058  return resultobj;
6059 fail:
6060  return NULL;
6061 }
6062 
6063 
6064 SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6065  PyObject *resultobj = 0;
6066  PLINT arg1 ;
6067  PLFLT *arg2 = (PLFLT *) 0 ;
6068  PLFLT *arg3 = (PLFLT *) 0 ;
6069  PLFLT *arg4 = (PLFLT *) 0 ;
6070  PyArrayObject *tmp1 ;
6071  PyArrayObject *tmp3 ;
6072  PyArrayObject *tmp4 ;
6073  PyObject * obj0 = 0 ;
6074  PyObject * obj1 = 0 ;
6075  PyObject * obj2 = 0 ;
6076 
6077  if (!PyArg_ParseTuple(args,(char *)"OOO:plerrx",&obj0,&obj1,&obj2)) SWIG_fail;
6078  {
6079  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6080  if ( tmp1 == NULL )
6081  return NULL;
6082  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6083  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6084  }
6085  {
6086  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6087  if ( tmp3 == NULL )
6088  return NULL;
6089  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6090  {
6091  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6092  return NULL;
6093  }
6094  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6095  }
6096  {
6097  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6098  if ( tmp4 == NULL )
6099  return NULL;
6100  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6101  {
6102  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6103  return NULL;
6104  }
6105  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6106  }
6107  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6108  resultobj = SWIG_Py_Void();
6109  {
6110  Py_DECREF( tmp1 );
6111  }
6112  {
6113  Py_DECREF( tmp3 );
6114  }
6115  {
6116  Py_DECREF( tmp4 );
6117  }
6118  return resultobj;
6119 fail:
6120  {
6121  Py_DECREF( tmp1 );
6122  }
6123  {
6124  Py_DECREF( tmp3 );
6125  }
6126  {
6127  Py_DECREF( tmp4 );
6128  }
6129  return NULL;
6130 }
6131 
6132 
6133 SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6134  PyObject *resultobj = 0;
6135  PLINT arg1 ;
6136  PLFLT *arg2 = (PLFLT *) 0 ;
6137  PLFLT *arg3 = (PLFLT *) 0 ;
6138  PLFLT *arg4 = (PLFLT *) 0 ;
6139  PyArrayObject *tmp1 ;
6140  PyArrayObject *tmp3 ;
6141  PyArrayObject *tmp4 ;
6142  PyObject * obj0 = 0 ;
6143  PyObject * obj1 = 0 ;
6144  PyObject * obj2 = 0 ;
6145 
6146  if (!PyArg_ParseTuple(args,(char *)"OOO:plerry",&obj0,&obj1,&obj2)) SWIG_fail;
6147  {
6148  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6149  if ( tmp1 == NULL )
6150  return NULL;
6151  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6152  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6153  }
6154  {
6155  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6156  if ( tmp3 == NULL )
6157  return NULL;
6158  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6159  {
6160  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6161  return NULL;
6162  }
6163  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6164  }
6165  {
6166  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6167  if ( tmp4 == NULL )
6168  return NULL;
6169  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6170  {
6171  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6172  return NULL;
6173  }
6174  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6175  }
6176  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6177  resultobj = SWIG_Py_Void();
6178  {
6179  Py_DECREF( tmp1 );
6180  }
6181  {
6182  Py_DECREF( tmp3 );
6183  }
6184  {
6185  Py_DECREF( tmp4 );
6186  }
6187  return resultobj;
6188 fail:
6189  {
6190  Py_DECREF( tmp1 );
6191  }
6192  {
6193  Py_DECREF( tmp3 );
6194  }
6195  {
6196  Py_DECREF( tmp4 );
6197  }
6198  return NULL;
6199 }
6200 
6201 
6202 SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6203  PyObject *resultobj = 0;
6204 
6205  if (!PyArg_ParseTuple(args,(char *)":plfamadv")) SWIG_fail;
6206  plfamadv();
6207  resultobj = SWIG_Py_Void();
6208  return resultobj;
6209 fail:
6210  return NULL;
6211 }
6212 
6213 
6214 SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6215  PyObject *resultobj = 0;
6216  PLINT arg1 ;
6217  PLFLT *arg2 = (PLFLT *) 0 ;
6218  PLFLT *arg3 = (PLFLT *) 0 ;
6219  PyArrayObject *tmp1 ;
6220  PyArrayObject *tmp3 ;
6221  PyObject * obj0 = 0 ;
6222  PyObject * obj1 = 0 ;
6223 
6224  if (!PyArg_ParseTuple(args,(char *)"OO:plfill",&obj0,&obj1)) SWIG_fail;
6225  {
6226  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6227  if ( tmp1 == NULL )
6228  return NULL;
6229  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6230  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6231  }
6232  {
6233  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6234  if ( tmp3 == NULL )
6235  return NULL;
6236  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6237  {
6238  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6239  return NULL;
6240  }
6241  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6242  }
6243  plfill(arg1,(double const *)arg2,(double const *)arg3);
6244  resultobj = SWIG_Py_Void();
6245  {
6246  Py_DECREF( tmp1 );
6247  }
6248  {
6249  Py_DECREF( tmp3 );
6250  }
6251  return resultobj;
6252 fail:
6253  {
6254  Py_DECREF( tmp1 );
6255  }
6256  {
6257  Py_DECREF( tmp3 );
6258  }
6259  return NULL;
6260 }
6261 
6262 
6263 SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6264  PyObject *resultobj = 0;
6265  PLINT arg1 ;
6266  PLFLT *arg2 = (PLFLT *) 0 ;
6267  PLFLT *arg3 = (PLFLT *) 0 ;
6268  PLFLT *arg4 = (PLFLT *) 0 ;
6269  PyArrayObject *tmp1 ;
6270  PyArrayObject *tmp3 ;
6271  PyArrayObject *tmp4 ;
6272  PyObject * obj0 = 0 ;
6273  PyObject * obj1 = 0 ;
6274  PyObject * obj2 = 0 ;
6275 
6276  if (!PyArg_ParseTuple(args,(char *)"OOO:plfill3",&obj0,&obj1,&obj2)) SWIG_fail;
6277  {
6278  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6279  if ( tmp1 == NULL )
6280  return NULL;
6281  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6282  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6283  }
6284  {
6285  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6286  if ( tmp3 == NULL )
6287  return NULL;
6288  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6289  {
6290  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6291  return NULL;
6292  }
6293  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6294  }
6295  {
6296  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6297  if ( tmp4 == NULL )
6298  return NULL;
6299  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6300  {
6301  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6302  return NULL;
6303  }
6304  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6305  }
6306  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6307  resultobj = SWIG_Py_Void();
6308  {
6309  Py_DECREF( tmp1 );
6310  }
6311  {
6312  Py_DECREF( tmp3 );
6313  }
6314  {
6315  Py_DECREF( tmp4 );
6316  }
6317  return resultobj;
6318 fail:
6319  {
6320  Py_DECREF( tmp1 );
6321  }
6322  {
6323  Py_DECREF( tmp3 );
6324  }
6325  {
6326  Py_DECREF( tmp4 );
6327  }
6328  return NULL;
6329 }
6330 
6331 
6332 SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6333  PyObject *resultobj = 0;
6334  PLINT arg1 ;
6335  PLFLT *arg2 = (PLFLT *) 0 ;
6336  PLFLT *arg3 = (PLFLT *) 0 ;
6337  PLFLT arg4 ;
6338  PyArrayObject *tmp1 ;
6339  PyArrayObject *tmp3 ;
6340  double val4 ;
6341  int ecode4 = 0 ;
6342  PyObject * obj0 = 0 ;
6343  PyObject * obj1 = 0 ;
6344  PyObject * obj2 = 0 ;
6345 
6346  if (!PyArg_ParseTuple(args,(char *)"OOO:plgradient",&obj0,&obj1,&obj2)) SWIG_fail;
6347  {
6348  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6349  if ( tmp1 == NULL )
6350  return NULL;
6351  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6352  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6353  }
6354  {
6355  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6356  if ( tmp3 == NULL )
6357  return NULL;
6358  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6359  {
6360  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6361  return NULL;
6362  }
6363  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6364  }
6365  ecode4 = SWIG_AsVal_double(obj2, &val4);
6366  if (!SWIG_IsOK(ecode4)) {
6367  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6368  }
6369  arg4 = (PLFLT)(val4);
6370  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6371  resultobj = SWIG_Py_Void();
6372  {
6373  Py_DECREF( tmp1 );
6374  }
6375  {
6376  Py_DECREF( tmp3 );
6377  }
6378  return resultobj;
6379 fail:
6380  {
6381  Py_DECREF( tmp1 );
6382  }
6383  {
6384  Py_DECREF( tmp3 );
6385  }
6386  return NULL;
6387 }
6388 
6389 
6390 SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6391  PyObject *resultobj = 0;
6392 
6393  if (!PyArg_ParseTuple(args,(char *)":plflush")) SWIG_fail;
6394  plflush();
6395  resultobj = SWIG_Py_Void();
6396  return resultobj;
6397 fail:
6398  return NULL;
6399 }
6400 
6401 
6402 SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6403  PyObject *resultobj = 0;
6404  PLINT arg1 ;
6405  int val1 ;
6406  int ecode1 = 0 ;
6407  PyObject * obj0 = 0 ;
6408 
6409  if (!PyArg_ParseTuple(args,(char *)"O:plfont",&obj0)) SWIG_fail;
6410  ecode1 = SWIG_AsVal_int(obj0, &val1);
6411  if (!SWIG_IsOK(ecode1)) {
6412  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6413  }
6414  arg1 = (PLINT)(val1);
6415  plfont(arg1);
6416  resultobj = SWIG_Py_Void();
6417  return resultobj;
6418 fail:
6419  return NULL;
6420 }
6421 
6422 
6423 SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6424  PyObject *resultobj = 0;
6425  PLINT arg1 ;
6426  int val1 ;
6427  int ecode1 = 0 ;
6428  PyObject * obj0 = 0 ;
6429 
6430  if (!PyArg_ParseTuple(args,(char *)"O:plfontld",&obj0)) SWIG_fail;
6431  ecode1 = SWIG_AsVal_int(obj0, &val1);
6432  if (!SWIG_IsOK(ecode1)) {
6433  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6434  }
6435  arg1 = (PLINT)(val1);
6436  plfontld(arg1);
6437  resultobj = SWIG_Py_Void();
6438  return resultobj;
6439 fail:
6440  return NULL;
6441 }
6442 
6443 
6444 SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6445  PyObject *resultobj = 0;
6446  PLFLT *arg1 = (PLFLT *) 0 ;
6447  PLFLT *arg2 = (PLFLT *) 0 ;
6448  PLFLT temp1 ;
6449  int res1 = SWIG_TMPOBJ ;
6450  PLFLT temp2 ;
6451  int res2 = SWIG_TMPOBJ ;
6452 
6453  arg1 = &temp1;
6454  arg2 = &temp2;
6455  if (!PyArg_ParseTuple(args,(char *)":plgchr")) SWIG_fail;
6456  plgchr(arg1,arg2);
6457  resultobj = SWIG_Py_Void();
6458  if (SWIG_IsTmpObj(res1)) {
6459  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6460  } else {
6461  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6462  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6463  }
6464  if (SWIG_IsTmpObj(res2)) {
6465  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6466  } else {
6467  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6468  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6469  }
6470  return resultobj;
6471 fail:
6472  return NULL;
6473 }
6474 
6475 
6476 SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6477  PyObject *resultobj = 0;
6478  PLINT arg1 ;
6479  PLINT *arg2 = (PLINT *) 0 ;
6480  PLINT *arg3 = (PLINT *) 0 ;
6481  PLINT *arg4 = (PLINT *) 0 ;
6482  int val1 ;
6483  int ecode1 = 0 ;
6484  PLINT temp2 ;
6485  int res2 = SWIG_TMPOBJ ;
6486  PLINT temp3 ;
6487  int res3 = SWIG_TMPOBJ ;
6488  PLINT temp4 ;
6489  int res4 = SWIG_TMPOBJ ;
6490  PyObject * obj0 = 0 ;
6491 
6492  arg2 = &temp2;
6493  arg3 = &temp3;
6494  arg4 = &temp4;
6495  if (!PyArg_ParseTuple(args,(char *)"O:plgcol0",&obj0)) SWIG_fail;
6496  ecode1 = SWIG_AsVal_int(obj0, &val1);
6497  if (!SWIG_IsOK(ecode1)) {
6498  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6499  }
6500  arg1 = (PLINT)(val1);
6501  plgcol0(arg1,arg2,arg3,arg4);
6502  resultobj = SWIG_Py_Void();
6503  if (SWIG_IsTmpObj(res2)) {
6504  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6505  } else {
6506  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6507  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6508  }
6509  if (SWIG_IsTmpObj(res3)) {
6510  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6511  } else {
6512  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6513  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6514  }
6515  if (SWIG_IsTmpObj(res4)) {
6516  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6517  } else {
6518  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6519  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6520  }
6521  return resultobj;
6522 fail:
6523  return NULL;
6524 }
6525 
6526 
6527 SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6528  PyObject *resultobj = 0;
6529  PLINT arg1 ;
6530  PLINT *arg2 = (PLINT *) 0 ;
6531  PLINT *arg3 = (PLINT *) 0 ;
6532  PLINT *arg4 = (PLINT *) 0 ;
6533  PLFLT *arg5 = (PLFLT *) 0 ;
6534  int val1 ;
6535  int ecode1 = 0 ;
6536  PLINT temp2 ;
6537  int res2 = SWIG_TMPOBJ ;
6538  PLINT temp3 ;
6539  int res3 = SWIG_TMPOBJ ;
6540  PLINT temp4 ;
6541  int res4 = SWIG_TMPOBJ ;
6542  PLFLT temp5 ;
6543  int res5 = SWIG_TMPOBJ ;
6544  PyObject * obj0 = 0 ;
6545 
6546  arg2 = &temp2;
6547  arg3 = &temp3;
6548  arg4 = &temp4;
6549  arg5 = &temp5;
6550  if (!PyArg_ParseTuple(args,(char *)"O:plgcol0a",&obj0)) SWIG_fail;
6551  ecode1 = SWIG_AsVal_int(obj0, &val1);
6552  if (!SWIG_IsOK(ecode1)) {
6553  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6554  }
6555  arg1 = (PLINT)(val1);
6556  plgcol0a(arg1,arg2,arg3,arg4,arg5);
6557  resultobj = SWIG_Py_Void();
6558  if (SWIG_IsTmpObj(res2)) {
6559  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6560  } else {
6561  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6562  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6563  }
6564  if (SWIG_IsTmpObj(res3)) {
6565  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6566  } else {
6567  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6568  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6569  }
6570  if (SWIG_IsTmpObj(res4)) {
6571  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6572  } else {
6573  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6574  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6575  }
6576  if (SWIG_IsTmpObj(res5)) {
6577  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6578  } else {
6579  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6580  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6581  }
6582  return resultobj;
6583 fail:
6584  return NULL;
6585 }
6586 
6587 
6588 SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6589  PyObject *resultobj = 0;
6590  PLINT *arg1 = (PLINT *) 0 ;
6591  PLINT *arg2 = (PLINT *) 0 ;
6592  PLINT *arg3 = (PLINT *) 0 ;
6593  PLINT temp1 ;
6594  int res1 = SWIG_TMPOBJ ;
6595  PLINT temp2 ;
6596  int res2 = SWIG_TMPOBJ ;
6597  PLINT temp3 ;
6598  int res3 = SWIG_TMPOBJ ;
6599 
6600  arg1 = &temp1;
6601  arg2 = &temp2;
6602  arg3 = &temp3;
6603  if (!PyArg_ParseTuple(args,(char *)":plgcolbg")) SWIG_fail;
6604  plgcolbg(arg1,arg2,arg3);
6605  resultobj = SWIG_Py_Void();
6606  if (SWIG_IsTmpObj(res1)) {
6607  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6608  } else {
6609  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6610  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6611  }
6612  if (SWIG_IsTmpObj(res2)) {
6613  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6614  } else {
6615  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6616  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6617  }
6618  if (SWIG_IsTmpObj(res3)) {
6619  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6620  } else {
6621  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6622  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6623  }
6624  return resultobj;
6625 fail:
6626  return NULL;
6627 }
6628 
6629 
6630 SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6631  PyObject *resultobj = 0;
6632  PLINT *arg1 = (PLINT *) 0 ;
6633  PLINT *arg2 = (PLINT *) 0 ;
6634  PLINT *arg3 = (PLINT *) 0 ;
6635  PLFLT *arg4 = (PLFLT *) 0 ;
6636  PLINT temp1 ;
6637  int res1 = SWIG_TMPOBJ ;
6638  PLINT temp2 ;
6639  int res2 = SWIG_TMPOBJ ;
6640  PLINT temp3 ;
6641  int res3 = SWIG_TMPOBJ ;
6642  PLFLT temp4 ;
6643  int res4 = SWIG_TMPOBJ ;
6644 
6645  arg1 = &temp1;
6646  arg2 = &temp2;
6647  arg3 = &temp3;
6648  arg4 = &temp4;
6649  if (!PyArg_ParseTuple(args,(char *)":plgcolbga")) SWIG_fail;
6650  plgcolbga(arg1,arg2,arg3,arg4);
6651  resultobj = SWIG_Py_Void();
6652  if (SWIG_IsTmpObj(res1)) {
6653  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6654  } else {
6655  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6656  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6657  }
6658  if (SWIG_IsTmpObj(res2)) {
6659  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6660  } else {
6661  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6662  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6663  }
6664  if (SWIG_IsTmpObj(res3)) {
6665  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6666  } else {
6667  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6668  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6669  }
6670  if (SWIG_IsTmpObj(res4)) {
6671  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6672  } else {
6673  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6674  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6675  }
6676  return resultobj;
6677 fail:
6678  return NULL;
6679 }
6680 
6681 
6682 SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6683  PyObject *resultobj = 0;
6684  PLINT *arg1 = (PLINT *) 0 ;
6685  PLINT temp1 ;
6686  int res1 = SWIG_TMPOBJ ;
6687 
6688  arg1 = &temp1;
6689  if (!PyArg_ParseTuple(args,(char *)":plgcompression")) SWIG_fail;
6690  plgcompression(arg1);
6691  resultobj = SWIG_Py_Void();
6692  if (SWIG_IsTmpObj(res1)) {
6693  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6694  } else {
6695  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6696  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6697  }
6698  return resultobj;
6699 fail:
6700  return NULL;
6701 }
6702 
6703 
6704 SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6705  PyObject *resultobj = 0;
6706  char *arg1 = (char *) 0 ;
6707  char buff1[1000] ;
6708 
6709  {
6710  arg1 = buff1;
6711  }
6712  if (!PyArg_ParseTuple(args,(char *)":plgdev")) SWIG_fail;
6713  plgdev(arg1);
6714  resultobj = SWIG_Py_Void();
6715  {
6716  PyObject *o = PyString_FromString( arg1 );
6717  resultobj = t_output_helper( resultobj, o );
6718  }
6719  return resultobj;
6720 fail:
6721  return NULL;
6722 }
6723 
6724 
6725 SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6726  PyObject *resultobj = 0;
6727  PLFLT *arg1 = (PLFLT *) 0 ;
6728  PLFLT *arg2 = (PLFLT *) 0 ;
6729  PLFLT *arg3 = (PLFLT *) 0 ;
6730  PLFLT *arg4 = (PLFLT *) 0 ;
6731  PLFLT temp1 ;
6732  int res1 = SWIG_TMPOBJ ;
6733  PLFLT temp2 ;
6734  int res2 = SWIG_TMPOBJ ;
6735  PLFLT temp3 ;
6736  int res3 = SWIG_TMPOBJ ;
6737  PLFLT temp4 ;
6738  int res4 = SWIG_TMPOBJ ;
6739 
6740  arg1 = &temp1;
6741  arg2 = &temp2;
6742  arg3 = &temp3;
6743  arg4 = &temp4;
6744  if (!PyArg_ParseTuple(args,(char *)":plgdidev")) SWIG_fail;
6745  plgdidev(arg1,arg2,arg3,arg4);
6746  resultobj = SWIG_Py_Void();
6747  if (SWIG_IsTmpObj(res1)) {
6748  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6749  } else {
6750  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6751  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6752  }
6753  if (SWIG_IsTmpObj(res2)) {
6754  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6755  } else {
6756  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6757  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6758  }
6759  if (SWIG_IsTmpObj(res3)) {
6760  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6761  } else {
6762  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6763  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6764  }
6765  if (SWIG_IsTmpObj(res4)) {
6766  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6767  } else {
6768  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6769  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6770  }
6771  return resultobj;
6772 fail:
6773  return NULL;
6774 }
6775 
6776 
6777 SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6778  PyObject *resultobj = 0;
6779  PLFLT *arg1 = (PLFLT *) 0 ;
6780  PLFLT temp1 ;
6781  int res1 = SWIG_TMPOBJ ;
6782 
6783  arg1 = &temp1;
6784  if (!PyArg_ParseTuple(args,(char *)":plgdiori")) SWIG_fail;
6785  plgdiori(arg1);
6786  resultobj = SWIG_Py_Void();
6787  if (SWIG_IsTmpObj(res1)) {
6788  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6789  } else {
6790  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6791  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6792  }
6793  return resultobj;
6794 fail:
6795  return NULL;
6796 }
6797 
6798 
6799 SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6800  PyObject *resultobj = 0;
6801  PLFLT *arg1 = (PLFLT *) 0 ;
6802  PLFLT *arg2 = (PLFLT *) 0 ;
6803  PLFLT *arg3 = (PLFLT *) 0 ;
6804  PLFLT *arg4 = (PLFLT *) 0 ;
6805  PLFLT temp1 ;
6806  int res1 = SWIG_TMPOBJ ;
6807  PLFLT temp2 ;
6808  int res2 = SWIG_TMPOBJ ;
6809  PLFLT temp3 ;
6810  int res3 = SWIG_TMPOBJ ;
6811  PLFLT temp4 ;
6812  int res4 = SWIG_TMPOBJ ;
6813 
6814  arg1 = &temp1;
6815  arg2 = &temp2;
6816  arg3 = &temp3;
6817  arg4 = &temp4;
6818  if (!PyArg_ParseTuple(args,(char *)":plgdiplt")) SWIG_fail;
6819  plgdiplt(arg1,arg2,arg3,arg4);
6820  resultobj = SWIG_Py_Void();
6821  if (SWIG_IsTmpObj(res1)) {
6822  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6823  } else {
6824  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6825  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6826  }
6827  if (SWIG_IsTmpObj(res2)) {
6828  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6829  } else {
6830  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6831  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6832  }
6833  if (SWIG_IsTmpObj(res3)) {
6834  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6835  } else {
6836  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6837  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6838  }
6839  if (SWIG_IsTmpObj(res4)) {
6840  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6841  } else {
6842  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6843  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6844  }
6845  return resultobj;
6846 fail:
6847  return NULL;
6848 }
6849 
6850 
6851 SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6852  PyObject *resultobj = 0;
6853  PLINT *arg1 = (PLINT *) 0 ;
6854  PLINT *arg2 = (PLINT *) 0 ;
6855  PLINT *arg3 = (PLINT *) 0 ;
6856  PLINT temp1 ;
6857  int res1 = SWIG_TMPOBJ ;
6858  PLINT temp2 ;
6859  int res2 = SWIG_TMPOBJ ;
6860  PLINT temp3 ;
6861  int res3 = SWIG_TMPOBJ ;
6862 
6863  arg1 = &temp1;
6864  arg2 = &temp2;
6865  arg3 = &temp3;
6866  if (!PyArg_ParseTuple(args,(char *)":plgfam")) SWIG_fail;
6867  plgfam(arg1,arg2,arg3);
6868  resultobj = SWIG_Py_Void();
6869  if (SWIG_IsTmpObj(res1)) {
6870  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6871  } else {
6872  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6873  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6874  }
6875  if (SWIG_IsTmpObj(res2)) {
6876  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6877  } else {
6878  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6879  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6880  }
6881  if (SWIG_IsTmpObj(res3)) {
6882  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6883  } else {
6884  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6885  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6886  }
6887  return resultobj;
6888 fail:
6889  return NULL;
6890 }
6891 
6892 
6893 SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6894  PyObject *resultobj = 0;
6895  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
6896  PLUNICODE temp1 ;
6897  int res1 = SWIG_TMPOBJ ;
6898 
6899  arg1 = &temp1;
6900  if (!PyArg_ParseTuple(args,(char *)":plgfci")) SWIG_fail;
6901  plgfci(arg1);
6902  resultobj = SWIG_Py_Void();
6903  if (SWIG_IsTmpObj(res1)) {
6904  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
6905  } else {
6906  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6907  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
6908  }
6909  return resultobj;
6910 fail:
6911  return NULL;
6912 }
6913 
6914 
6915 SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6916  PyObject *resultobj = 0;
6917  char *arg1 = (char *) 0 ;
6918  char buff1[1000] ;
6919 
6920  {
6921  arg1 = buff1;
6922  }
6923  if (!PyArg_ParseTuple(args,(char *)":plgfnam")) SWIG_fail;
6924  plgfnam(arg1);
6925  resultobj = SWIG_Py_Void();
6926  {
6927  PyObject *o = PyString_FromString( arg1 );
6928  resultobj = t_output_helper( resultobj, o );
6929  }
6930  return resultobj;
6931 fail:
6932  return NULL;
6933 }
6934 
6935 
6936 SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6937  PyObject *resultobj = 0;
6938  PLINT *arg1 = (PLINT *) 0 ;
6939  PLINT *arg2 = (PLINT *) 0 ;
6940  PLINT *arg3 = (PLINT *) 0 ;
6941  PLINT temp1 ;
6942  int res1 = SWIG_TMPOBJ ;
6943  PLINT temp2 ;
6944  int res2 = SWIG_TMPOBJ ;
6945  PLINT temp3 ;
6946  int res3 = SWIG_TMPOBJ ;
6947 
6948  arg1 = &temp1;
6949  arg2 = &temp2;
6950  arg3 = &temp3;
6951  if (!PyArg_ParseTuple(args,(char *)":plgfont")) SWIG_fail;
6952  plgfont(arg1,arg2,arg3);
6953  resultobj = SWIG_Py_Void();
6954  if (SWIG_IsTmpObj(res1)) {
6955  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6956  } else {
6957  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6958  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6959  }
6960  if (SWIG_IsTmpObj(res2)) {
6961  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6962  } else {
6963  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6964  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6965  }
6966  if (SWIG_IsTmpObj(res3)) {
6967  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6968  } else {
6969  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6970  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6971  }
6972  return resultobj;
6973 fail:
6974  return NULL;
6975 }
6976 
6977 
6978 SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6979  PyObject *resultobj = 0;
6980  PLINT *arg1 = (PLINT *) 0 ;
6981  PLINT temp1 ;
6982  int res1 = SWIG_TMPOBJ ;
6983 
6984  arg1 = &temp1;
6985  if (!PyArg_ParseTuple(args,(char *)":plglevel")) SWIG_fail;
6986  plglevel(arg1);
6987  resultobj = SWIG_Py_Void();
6988  if (SWIG_IsTmpObj(res1)) {
6989  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6990  } else {
6991  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6992  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6993  }
6994  return resultobj;
6995 fail:
6996  return NULL;
6997 }
6998 
6999 
7000 SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7001  PyObject *resultobj = 0;
7002  PLFLT *arg1 = (PLFLT *) 0 ;
7003  PLFLT *arg2 = (PLFLT *) 0 ;
7004  PLINT *arg3 = (PLINT *) 0 ;
7005  PLINT *arg4 = (PLINT *) 0 ;
7006  PLINT *arg5 = (PLINT *) 0 ;
7007  PLINT *arg6 = (PLINT *) 0 ;
7008  PLFLT temp1 ;
7009  int res1 = SWIG_TMPOBJ ;
7010  PLFLT temp2 ;
7011  int res2 = SWIG_TMPOBJ ;
7012  PLINT temp3 ;
7013  int res3 = SWIG_TMPOBJ ;
7014  PLINT temp4 ;
7015  int res4 = SWIG_TMPOBJ ;
7016  PLINT temp5 ;
7017  int res5 = SWIG_TMPOBJ ;
7018  PLINT temp6 ;
7019  int res6 = SWIG_TMPOBJ ;
7020 
7021  arg1 = &temp1;
7022  arg2 = &temp2;
7023  arg3 = &temp3;
7024  arg4 = &temp4;
7025  arg5 = &temp5;
7026  arg6 = &temp6;
7027  if (!PyArg_ParseTuple(args,(char *)":plgpage")) SWIG_fail;
7028  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7029  resultobj = SWIG_Py_Void();
7030  if (SWIG_IsTmpObj(res1)) {
7031  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7032  } else {
7033  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7034  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7035  }
7036  if (SWIG_IsTmpObj(res2)) {
7037  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7038  } else {
7039  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7040  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7041  }
7042  if (SWIG_IsTmpObj(res3)) {
7043  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7044  } else {
7045  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7046  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7047  }
7048  if (SWIG_IsTmpObj(res4)) {
7049  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
7050  } else {
7051  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7052  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
7053  }
7054  if (SWIG_IsTmpObj(res5)) {
7055  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
7056  } else {
7057  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7058  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
7059  }
7060  if (SWIG_IsTmpObj(res6)) {
7061  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
7062  } else {
7063  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7064  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
7065  }
7066  return resultobj;
7067 fail:
7068  return NULL;
7069 }
7070 
7071 
7072 SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7073  PyObject *resultobj = 0;
7074 
7075  if (!PyArg_ParseTuple(args,(char *)":plgra")) SWIG_fail;
7076  plgra();
7077  resultobj = SWIG_Py_Void();
7078  return resultobj;
7079 fail:
7080  return NULL;
7081 }
7082 
7083 
7084 SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7085  PyObject *resultobj = 0;
7086  PLFLT *arg1 = (PLFLT *) 0 ;
7087  PLFLT *arg2 = (PLFLT *) 0 ;
7088  PLFLT *arg3 = (PLFLT *) 0 ;
7089  PLINT arg4 ;
7090  PLFLT *arg5 = (PLFLT *) 0 ;
7091  PLINT arg6 ;
7092  PLFLT *arg7 = (PLFLT *) 0 ;
7093  PLINT arg8 ;
7094  PLFLT **arg9 = (PLFLT **) 0 ;
7095  PLINT arg10 ;
7096  PLFLT arg11 ;
7097  PyArrayObject *tmp1 ;
7098  PyArrayObject *tmp2 ;
7099  PyArrayObject *tmp3 ;
7100  PyArrayObject *tmp5 ;
7101  PyArrayObject *tmp7 ;
7102  PyObject *array7 = NULL ;
7103  int val10 ;
7104  int ecode10 = 0 ;
7105  double val11 ;
7106  int ecode11 = 0 ;
7107  PyObject * obj0 = 0 ;
7108  PyObject * obj1 = 0 ;
7109  PyObject * obj2 = 0 ;
7110  PyObject * obj3 = 0 ;
7111  PyObject * obj4 = 0 ;
7112  PyObject * obj5 = 0 ;
7113  PyObject * obj6 = 0 ;
7114 
7115  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
7116  {
7117  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7118  if ( tmp1 == NULL )
7119  return NULL;
7120  Alen = PyArray_DIMS( tmp1 )[0];
7121  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7122  }
7123  {
7124  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
7125  if ( tmp2 == NULL )
7126  return NULL;
7127  if ( PyArray_DIMS( tmp2 )[0] != Alen )
7128  {
7129  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7130  return NULL;
7131  }
7132  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7133  }
7134  {
7135  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
7136  if ( tmp3 == NULL )
7137  return NULL;
7138  if ( PyArray_DIMS( tmp3 )[0] != Alen )
7139  {
7140  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7141  return NULL;
7142  }
7143  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7144  arg4 = PyArray_DIMS( tmp3 )[0];
7145  }
7146  {
7147  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
7148  if ( tmp5 == NULL )
7149  return NULL;
7150  Xlen = PyArray_DIMS( tmp5 )[0];
7151  arg6 = Xlen;
7152  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7153  }
7154  {
7155  int i, size;
7156  npy_intp dims[2];
7157  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
7158  if ( tmp7 == NULL )
7159  return NULL;
7160  Ylen = PyArray_DIMS( tmp7 )[0];
7161  arg8 = Ylen;
7162  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7163  // Make created 2D array7 have dimensions from prior ArrayX in the argument
7164  // list and this ArrayY.
7165  dims[0] = Xlen;
7166  dims[1] = Ylen;
7167  array7 = PyArray_SimpleNew( 2, dims, NPY_DOUBLE );
7168  if ( !array7 )
7169  return NULL;
7170  size = (int) ( sizeof ( double ) * Ylen );
7171  arg9 = (double **) malloc( sizeof ( double * ) * Xlen );
7172  for ( i = 0; i < Xlen; i++ )
7173  arg9[i] = (double *) ( PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7174  }
7175  ecode10 = SWIG_AsVal_int(obj5, &val10);
7176  if (!SWIG_IsOK(ecode10)) {
7177  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7178  }
7179  arg10 = (PLINT)(val10);
7180  ecode11 = SWIG_AsVal_double(obj6, &val11);
7181  if (!SWIG_IsOK(ecode11)) {
7182  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7183  }
7184  arg11 = (PLFLT)(val11);
7185  plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7186  resultobj = SWIG_Py_Void();
7187  {
7188  resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
7189  }
7190  {
7191  Py_DECREF( tmp1 );
7192  }
7193  {
7194  Py_DECREF( tmp2 );
7195  }
7196  {
7197  Py_DECREF( tmp3 );
7198  }
7199  {
7200  Py_DECREF( tmp5 );
7201  }
7202  {
7203  Py_DECREF( tmp7 );
7204  free( arg9 );
7205  }
7206  return resultobj;
7207 fail:
7208  {
7209  Py_DECREF( tmp1 );
7210  }
7211  {
7212  Py_DECREF( tmp2 );
7213  }
7214  {
7215  Py_DECREF( tmp3 );
7216  }
7217  {
7218  Py_DECREF( tmp5 );
7219  }
7220  {
7221  Py_DECREF( tmp7 );
7222  free( arg9 );
7223  }
7224  return NULL;
7225 }
7226 
7227 
7228 SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7229  PyObject *resultobj = 0;
7230  PLFLT *arg1 = (PLFLT *) 0 ;
7231  PLFLT *arg2 = (PLFLT *) 0 ;
7232  PLFLT *arg3 = (PLFLT *) 0 ;
7233  PLFLT *arg4 = (PLFLT *) 0 ;
7234  PLFLT temp1 ;
7235  int res1 = SWIG_TMPOBJ ;
7236  PLFLT temp2 ;
7237  int res2 = SWIG_TMPOBJ ;
7238  PLFLT temp3 ;
7239  int res3 = SWIG_TMPOBJ ;
7240  PLFLT temp4 ;
7241  int res4 = SWIG_TMPOBJ ;
7242 
7243  arg1 = &temp1;
7244  arg2 = &temp2;
7245  arg3 = &temp3;
7246  arg4 = &temp4;
7247  if (!PyArg_ParseTuple(args,(char *)":plgspa")) SWIG_fail;
7248  plgspa(arg1,arg2,arg3,arg4);
7249  resultobj = SWIG_Py_Void();
7250  if (SWIG_IsTmpObj(res1)) {
7251  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7252  } else {
7253  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7254  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7255  }
7256  if (SWIG_IsTmpObj(res2)) {
7257  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7258  } else {
7259  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7260  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7261  }
7262  if (SWIG_IsTmpObj(res3)) {
7263  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7264  } else {
7265  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7266  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7267  }
7268  if (SWIG_IsTmpObj(res4)) {
7269  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7270  } else {
7271  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7272  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7273  }
7274  return resultobj;
7275 fail:
7276  return NULL;
7277 }
7278 
7279 
7280 SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7281  PyObject *resultobj = 0;
7282  PLINT *arg1 = (PLINT *) 0 ;
7283  PLINT temp1 ;
7284  int res1 = SWIG_TMPOBJ ;
7285 
7286  arg1 = &temp1;
7287  if (!PyArg_ParseTuple(args,(char *)":plgstrm")) SWIG_fail;
7288  plgstrm(arg1);
7289  resultobj = SWIG_Py_Void();
7290  if (SWIG_IsTmpObj(res1)) {
7291  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7292  } else {
7293  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7294  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7295  }
7296  return resultobj;
7297 fail:
7298  return NULL;
7299 }
7300 
7301 
7302 SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7303  PyObject *resultobj = 0;
7304  char *arg1 = (char *) 0 ;
7305  char buff1[1000] ;
7306 
7307  {
7308  arg1 = buff1;
7309  }
7310  if (!PyArg_ParseTuple(args,(char *)":plgver")) SWIG_fail;
7311  plgver(arg1);
7312  resultobj = SWIG_Py_Void();
7313  {
7314  PyObject *o = PyString_FromString( arg1 );
7315  resultobj = t_output_helper( resultobj, o );
7316  }
7317  return resultobj;
7318 fail:
7319  return NULL;
7320 }
7321 
7322 
7323 SWIGINTERN PyObject *_wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7324  PyObject *resultobj = 0;
7325  PLFLT *arg1 = (PLFLT *) 0 ;
7326  PLFLT *arg2 = (PLFLT *) 0 ;
7327  PLFLT *arg3 = (PLFLT *) 0 ;
7328  PLFLT *arg4 = (PLFLT *) 0 ;
7329  PLFLT temp1 ;
7330  int res1 = SWIG_TMPOBJ ;
7331  PLFLT temp2 ;
7332  int res2 = SWIG_TMPOBJ ;
7333  PLFLT temp3 ;
7334  int res3 = SWIG_TMPOBJ ;
7335  PLFLT temp4 ;
7336  int res4 = SWIG_TMPOBJ ;
7337 
7338  arg1 = &temp1;
7339  arg2 = &temp2;
7340  arg3 = &temp3;
7341  arg4 = &temp4;
7342  if (!PyArg_ParseTuple(args,(char *)":plgvpd")) SWIG_fail;
7343  plgvpd(arg1,arg2,arg3,arg4);
7344  resultobj = SWIG_Py_Void();
7345  if (SWIG_IsTmpObj(res1)) {
7346  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7347  } else {
7348  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7349  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7350  }
7351  if (SWIG_IsTmpObj(res2)) {
7352  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7353  } else {
7354  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7355  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7356  }
7357  if (SWIG_IsTmpObj(res3)) {
7358  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7359  } else {
7360  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7361  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7362  }
7363  if (SWIG_IsTmpObj(res4)) {
7364  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7365  } else {
7366  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7367  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7368  }
7369  return resultobj;
7370 fail:
7371  return NULL;
7372 }
7373 
7374 
7375 SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7376  PyObject *resultobj = 0;
7377  PLFLT *arg1 = (PLFLT *) 0 ;
7378  PLFLT *arg2 = (PLFLT *) 0 ;
7379  PLFLT *arg3 = (PLFLT *) 0 ;
7380  PLFLT *arg4 = (PLFLT *) 0 ;
7381  PLFLT temp1 ;
7382  int res1 = SWIG_TMPOBJ ;
7383  PLFLT temp2 ;
7384  int res2 = SWIG_TMPOBJ ;
7385  PLFLT temp3 ;
7386  int res3 = SWIG_TMPOBJ ;
7387  PLFLT temp4 ;
7388  int res4 = SWIG_TMPOBJ ;
7389 
7390  arg1 = &temp1;
7391  arg2 = &temp2;
7392  arg3 = &temp3;
7393  arg4 = &temp4;
7394  if (!PyArg_ParseTuple(args,(char *)":plgvpw")) SWIG_fail;
7395  plgvpw(arg1,arg2,arg3,arg4);
7396  resultobj = SWIG_Py_Void();
7397  if (SWIG_IsTmpObj(res1)) {
7398  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7399  } else {
7400  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7401  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7402  }
7403  if (SWIG_IsTmpObj(res2)) {
7404  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7405  } else {
7406  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7407  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7408  }
7409  if (SWIG_IsTmpObj(res3)) {
7410  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7411  } else {
7412  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7413  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7414  }
7415  if (SWIG_IsTmpObj(res4)) {
7416  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7417  } else {
7418  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7419  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7420  }
7421  return resultobj;
7422 fail:
7423  return NULL;
7424 }
7425 
7426 
7427 SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7428  PyObject *resultobj = 0;
7429  PLINT *arg1 = (PLINT *) 0 ;
7430  PLINT *arg2 = (PLINT *) 0 ;
7431  PLINT temp1 ;
7432  int res1 = SWIG_TMPOBJ ;
7433  PLINT temp2 ;
7434  int res2 = SWIG_TMPOBJ ;
7435 
7436  arg1 = &temp1;
7437  arg2 = &temp2;
7438  if (!PyArg_ParseTuple(args,(char *)":plgxax")) SWIG_fail;
7439  plgxax(arg1,arg2);
7440  resultobj = SWIG_Py_Void();
7441  if (SWIG_IsTmpObj(res1)) {
7442  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7443  } else {
7444  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7445  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7446  }
7447  if (SWIG_IsTmpObj(res2)) {
7448  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7449  } else {
7450  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7451  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7452  }
7453  return resultobj;
7454 fail:
7455  return NULL;
7456 }
7457 
7458 
7459 SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7460  PyObject *resultobj = 0;
7461  PLINT *arg1 = (PLINT *) 0 ;
7462  PLINT *arg2 = (PLINT *) 0 ;
7463  PLINT temp1 ;
7464  int res1 = SWIG_TMPOBJ ;
7465  PLINT temp2 ;
7466  int res2 = SWIG_TMPOBJ ;
7467 
7468  arg1 = &temp1;
7469  arg2 = &temp2;
7470  if (!PyArg_ParseTuple(args,(char *)":plgyax")) SWIG_fail;
7471  plgyax(arg1,arg2);
7472  resultobj = SWIG_Py_Void();
7473  if (SWIG_IsTmpObj(res1)) {
7474  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7475  } else {
7476  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7477  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7478  }
7479  if (SWIG_IsTmpObj(res2)) {
7480  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7481  } else {
7482  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7483  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7484  }
7485  return resultobj;
7486 fail:
7487  return NULL;
7488 }
7489 
7490 
7491 SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7492  PyObject *resultobj = 0;
7493  PLINT *arg1 = (PLINT *) 0 ;
7494  PLINT *arg2 = (PLINT *) 0 ;
7495  PLINT temp1 ;
7496  int res1 = SWIG_TMPOBJ ;
7497  PLINT temp2 ;
7498  int res2 = SWIG_TMPOBJ ;
7499 
7500  arg1 = &temp1;
7501  arg2 = &temp2;
7502  if (!PyArg_ParseTuple(args,(char *)":plgzax")) SWIG_fail;
7503  plgzax(arg1,arg2);
7504  resultobj = SWIG_Py_Void();
7505  if (SWIG_IsTmpObj(res1)) {
7506  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7507  } else {
7508  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7509  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7510  }
7511  if (SWIG_IsTmpObj(res2)) {
7512  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7513  } else {
7514  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7515  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7516  }
7517  return resultobj;
7518 fail:
7519  return NULL;
7520 }
7521 
7522 
7523 SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7524  PyObject *resultobj = 0;
7525  PLINT arg1 ;
7526  PLFLT *arg2 = (PLFLT *) 0 ;
7527  PLFLT arg3 ;
7528  PLFLT arg4 ;
7529  PLINT arg5 ;
7530  PLINT arg6 ;
7531  PyArrayObject *tmp1 ;
7532  double val3 ;
7533  int ecode3 = 0 ;
7534  double val4 ;
7535  int ecode4 = 0 ;
7536  int val5 ;
7537  int ecode5 = 0 ;
7538  int val6 ;
7539  int ecode6 = 0 ;
7540  PyObject * obj0 = 0 ;
7541  PyObject * obj1 = 0 ;
7542  PyObject * obj2 = 0 ;
7543  PyObject * obj3 = 0 ;
7544  PyObject * obj4 = 0 ;
7545 
7546  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7547  {
7548  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7549  if ( tmp1 == NULL )
7550  return NULL;
7551  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7552  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7553  }
7554  ecode3 = SWIG_AsVal_double(obj1, &val3);
7555  if (!SWIG_IsOK(ecode3)) {
7556  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7557  }
7558  arg3 = (PLFLT)(val3);
7559  ecode4 = SWIG_AsVal_double(obj2, &val4);
7560  if (!SWIG_IsOK(ecode4)) {
7561  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7562  }
7563  arg4 = (PLFLT)(val4);
7564  ecode5 = SWIG_AsVal_int(obj3, &val5);
7565  if (!SWIG_IsOK(ecode5)) {
7566  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7567  }
7568  arg5 = (PLINT)(val5);
7569  ecode6 = SWIG_AsVal_int(obj4, &val6);
7570  if (!SWIG_IsOK(ecode6)) {
7571  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7572  }
7573  arg6 = (PLINT)(val6);
7574  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7575  resultobj = SWIG_Py_Void();
7576  {
7577  Py_DECREF( tmp1 );
7578  }
7579  return resultobj;
7580 fail:
7581  {
7582  Py_DECREF( tmp1 );
7583  }
7584  return NULL;
7585 }
7586 
7587 
7588 SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7589  PyObject *resultobj = 0;
7590  PLFLT arg1 ;
7591  PLFLT arg2 ;
7592  PLFLT arg3 ;
7593  PLFLT *arg4 = (PLFLT *) 0 ;
7594  PLFLT *arg5 = (PLFLT *) 0 ;
7595  PLFLT *arg6 = (PLFLT *) 0 ;
7596  double val1 ;
7597  int ecode1 = 0 ;
7598  double val2 ;
7599  int ecode2 = 0 ;
7600  double val3 ;
7601  int ecode3 = 0 ;
7602  PLFLT temp4 ;
7603  int res4 = SWIG_TMPOBJ ;
7604  PLFLT temp5 ;
7605  int res5 = SWIG_TMPOBJ ;
7606  PLFLT temp6 ;
7607  int res6 = SWIG_TMPOBJ ;
7608  PyObject * obj0 = 0 ;
7609  PyObject * obj1 = 0 ;
7610  PyObject * obj2 = 0 ;
7611 
7612  arg4 = &temp4;
7613  arg5 = &temp5;
7614  arg6 = &temp6;
7615  if (!PyArg_ParseTuple(args,(char *)"OOO:plhlsrgb",&obj0,&obj1,&obj2)) SWIG_fail;
7616  ecode1 = SWIG_AsVal_double(obj0, &val1);
7617  if (!SWIG_IsOK(ecode1)) {
7618  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7619  }
7620  arg1 = (PLFLT)(val1);
7621  ecode2 = SWIG_AsVal_double(obj1, &val2);
7622  if (!SWIG_IsOK(ecode2)) {
7623  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7624  }
7625  arg2 = (PLFLT)(val2);
7626  ecode3 = SWIG_AsVal_double(obj2, &val3);
7627  if (!SWIG_IsOK(ecode3)) {
7628  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7629  }
7630  arg3 = (PLFLT)(val3);
7631  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7632  resultobj = SWIG_Py_Void();
7633  if (SWIG_IsTmpObj(res4)) {
7634  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7635  } else {
7636  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7637  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7638  }
7639  if (SWIG_IsTmpObj(res5)) {
7640  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7641  } else {
7642  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7643  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7644  }
7645  if (SWIG_IsTmpObj(res6)) {
7646  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7647  } else {
7648  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7649  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7650  }
7651  return resultobj;
7652 fail:
7653  return NULL;
7654 }
7655 
7656 
7657 SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7658  PyObject *resultobj = 0;
7659 
7660  if (!PyArg_ParseTuple(args,(char *)":plinit")) SWIG_fail;
7661  plinit();
7662  resultobj = SWIG_Py_Void();
7663  return resultobj;
7664 fail:
7665  return NULL;
7666 }
7667 
7668 
7669 SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7670  PyObject *resultobj = 0;
7671  PLFLT arg1 ;
7672  PLFLT arg2 ;
7673  PLFLT arg3 ;
7674  PLFLT arg4 ;
7675  double val1 ;
7676  int ecode1 = 0 ;
7677  double val2 ;
7678  int ecode2 = 0 ;
7679  double val3 ;
7680  int ecode3 = 0 ;
7681  double val4 ;
7682  int ecode4 = 0 ;
7683  PyObject * obj0 = 0 ;
7684  PyObject * obj1 = 0 ;
7685  PyObject * obj2 = 0 ;
7686  PyObject * obj3 = 0 ;
7687 
7688  if (!PyArg_ParseTuple(args,(char *)"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7689  ecode1 = SWIG_AsVal_double(obj0, &val1);
7690  if (!SWIG_IsOK(ecode1)) {
7691  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
7692  }
7693  arg1 = (PLFLT)(val1);
7694  ecode2 = SWIG_AsVal_double(obj1, &val2);
7695  if (!SWIG_IsOK(ecode2)) {
7696  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
7697  }
7698  arg2 = (PLFLT)(val2);
7699  ecode3 = SWIG_AsVal_double(obj2, &val3);
7700  if (!SWIG_IsOK(ecode3)) {
7701  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
7702  }
7703  arg3 = (PLFLT)(val3);
7704  ecode4 = SWIG_AsVal_double(obj3, &val4);
7705  if (!SWIG_IsOK(ecode4)) {
7706  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
7707  }
7708  arg4 = (PLFLT)(val4);
7709  pljoin(arg1,arg2,arg3,arg4);
7710  resultobj = SWIG_Py_Void();
7711  return resultobj;
7712 fail:
7713  return NULL;
7714 }
7715 
7716 
7717 SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7718  PyObject *resultobj = 0;
7719  char *arg1 = (char *) 0 ;
7720  char *arg2 = (char *) 0 ;
7721  char *arg3 = (char *) 0 ;
7722  int res1 ;
7723  char *buf1 = 0 ;
7724  int alloc1 = 0 ;
7725  int res2 ;
7726  char *buf2 = 0 ;
7727  int alloc2 = 0 ;
7728  int res3 ;
7729  char *buf3 = 0 ;
7730  int alloc3 = 0 ;
7731  PyObject * obj0 = 0 ;
7732  PyObject * obj1 = 0 ;
7733  PyObject * obj2 = 0 ;
7734 
7735  if (!PyArg_ParseTuple(args,(char *)"OOO:pllab",&obj0,&obj1,&obj2)) SWIG_fail;
7736  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
7737  if (!SWIG_IsOK(res1)) {
7738  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
7739  }
7740  arg1 = (char *)(buf1);
7741  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7742  if (!SWIG_IsOK(res2)) {
7743  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
7744  }
7745  arg2 = (char *)(buf2);
7746  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
7747  if (!SWIG_IsOK(res3)) {
7748  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
7749  }
7750  arg3 = (char *)(buf3);
7751  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
7752  resultobj = SWIG_Py_Void();
7753  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7754  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7755  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7756  return resultobj;
7757 fail:
7758  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7759  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7760  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7761  return NULL;
7762 }
7763 
7764 
7765 SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7766  PyObject *resultobj = 0;
7767  PLFLT *arg1 = (PLFLT *) 0 ;
7768  PLFLT *arg2 = (PLFLT *) 0 ;
7769  PLINT arg3 ;
7770  PLINT arg4 ;
7771  PLFLT arg5 ;
7772  PLFLT arg6 ;
7773  PLFLT arg7 ;
7774  PLINT arg8 ;
7775  PLINT arg9 ;
7776  PLINT arg10 ;
7777  PLINT arg11 ;
7778  PLINT arg12 ;
7779  PLINT arg13 ;
7780  PLINT *arg14 = (PLINT *) 0 ;
7781  PLFLT arg15 ;
7782  PLFLT arg16 ;
7783  PLFLT arg17 ;
7784  PLFLT arg18 ;
7785  PLINT *arg19 = (PLINT *) 0 ;
7786  char **arg20 = (char **) 0 ;
7787  PLINT *arg21 = (PLINT *) 0 ;
7788  PLINT *arg22 = (PLINT *) 0 ;
7789  PLFLT *arg23 = (PLFLT *) 0 ;
7790  PLFLT *arg24 = (PLFLT *) 0 ;
7791  PLINT *arg25 = (PLINT *) 0 ;
7792  PLINT *arg26 = (PLINT *) 0 ;
7793  PLFLT *arg27 = (PLFLT *) 0 ;
7794  PLINT *arg28 = (PLINT *) 0 ;
7795  PLFLT *arg29 = (PLFLT *) 0 ;
7796  PLINT *arg30 = (PLINT *) 0 ;
7797  char **arg31 = (char **) 0 ;
7798  PLFLT temp1 ;
7799  int res1 = SWIG_TMPOBJ ;
7800  PLFLT temp2 ;
7801  int res2 = SWIG_TMPOBJ ;
7802  int val3 ;
7803  int ecode3 = 0 ;
7804  int val4 ;
7805  int ecode4 = 0 ;
7806  double val5 ;
7807  int ecode5 = 0 ;
7808  double val6 ;
7809  int ecode6 = 0 ;
7810  double val7 ;
7811  int ecode7 = 0 ;
7812  int val8 ;
7813  int ecode8 = 0 ;
7814  int val9 ;
7815  int ecode9 = 0 ;
7816  int val10 ;
7817  int ecode10 = 0 ;
7818  int val11 ;
7819  int ecode11 = 0 ;
7820  int val12 ;
7821  int ecode12 = 0 ;
7822  PyArrayObject *tmp13 ;
7823  double val15 ;
7824  int ecode15 = 0 ;
7825  double val16 ;
7826  int ecode16 = 0 ;
7827  double val17 ;
7828  int ecode17 = 0 ;
7829  double val18 ;
7830  int ecode18 = 0 ;
7831  PyArrayObject *tmp19 ;
7832  PyArrayObject *tmp20 ;
7833  PyArrayObject *tmp21 ;
7834  PyArrayObject *tmp22 ;
7835  PyArrayObject *tmp23 ;
7836  PyArrayObject *tmp24 ;
7837  PyArrayObject *tmp25 ;
7838  PyArrayObject *tmp26 ;
7839  PyArrayObject *tmp27 ;
7840  PyArrayObject *tmp28 ;
7841  PyArrayObject *tmp29 ;
7842  PyArrayObject *tmp30 ;
7843  PyArrayObject *tmp31 ;
7844  PyObject * obj0 = 0 ;
7845  PyObject * obj1 = 0 ;
7846  PyObject * obj2 = 0 ;
7847  PyObject * obj3 = 0 ;
7848  PyObject * obj4 = 0 ;
7849  PyObject * obj5 = 0 ;
7850  PyObject * obj6 = 0 ;
7851  PyObject * obj7 = 0 ;
7852  PyObject * obj8 = 0 ;
7853  PyObject * obj9 = 0 ;
7854  PyObject * obj10 = 0 ;
7855  PyObject * obj11 = 0 ;
7856  PyObject * obj12 = 0 ;
7857  PyObject * obj13 = 0 ;
7858  PyObject * obj14 = 0 ;
7859  PyObject * obj15 = 0 ;
7860  PyObject * obj16 = 0 ;
7861  PyObject * obj17 = 0 ;
7862  PyObject * obj18 = 0 ;
7863  PyObject * obj19 = 0 ;
7864  PyObject * obj20 = 0 ;
7865  PyObject * obj21 = 0 ;
7866  PyObject * obj22 = 0 ;
7867  PyObject * obj23 = 0 ;
7868  PyObject * obj24 = 0 ;
7869  PyObject * obj25 = 0 ;
7870  PyObject * obj26 = 0 ;
7871  PyObject * obj27 = 0 ;
7872 
7873  arg1 = &temp1;
7874  arg2 = &temp2;
7875  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;
7876  ecode3 = SWIG_AsVal_int(obj0, &val3);
7877  if (!SWIG_IsOK(ecode3)) {
7878  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
7879  }
7880  arg3 = (PLINT)(val3);
7881  ecode4 = SWIG_AsVal_int(obj1, &val4);
7882  if (!SWIG_IsOK(ecode4)) {
7883  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
7884  }
7885  arg4 = (PLINT)(val4);
7886  ecode5 = SWIG_AsVal_double(obj2, &val5);
7887  if (!SWIG_IsOK(ecode5)) {
7888  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
7889  }
7890  arg5 = (PLFLT)(val5);
7891  ecode6 = SWIG_AsVal_double(obj3, &val6);
7892  if (!SWIG_IsOK(ecode6)) {
7893  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
7894  }
7895  arg6 = (PLFLT)(val6);
7896  ecode7 = SWIG_AsVal_double(obj4, &val7);
7897  if (!SWIG_IsOK(ecode7)) {
7898  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
7899  }
7900  arg7 = (PLFLT)(val7);
7901  ecode8 = SWIG_AsVal_int(obj5, &val8);
7902  if (!SWIG_IsOK(ecode8)) {
7903  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
7904  }
7905  arg8 = (PLINT)(val8);
7906  ecode9 = SWIG_AsVal_int(obj6, &val9);
7907  if (!SWIG_IsOK(ecode9)) {
7908  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
7909  }
7910  arg9 = (PLINT)(val9);
7911  ecode10 = SWIG_AsVal_int(obj7, &val10);
7912  if (!SWIG_IsOK(ecode10)) {
7913  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
7914  }
7915  arg10 = (PLINT)(val10);
7916  ecode11 = SWIG_AsVal_int(obj8, &val11);
7917  if (!SWIG_IsOK(ecode11)) {
7918  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
7919  }
7920  arg11 = (PLINT)(val11);
7921  ecode12 = SWIG_AsVal_int(obj9, &val12);
7922  if (!SWIG_IsOK(ecode12)) {
7923  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
7924  }
7925  arg12 = (PLINT)(val12);
7926  {
7927  tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj10, NPY_PLINT, 1, 1 );
7928  if ( tmp13 == NULL )
7929  return NULL;
7930  arg13 = Alen = PyArray_DIMS( tmp13 )[0];
7931  arg14 = (PLINT *) PyArray_DATA( tmp13 );
7932  }
7933  ecode15 = SWIG_AsVal_double(obj11, &val15);
7934  if (!SWIG_IsOK(ecode15)) {
7935  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
7936  }
7937  arg15 = (PLFLT)(val15);
7938  ecode16 = SWIG_AsVal_double(obj12, &val16);
7939  if (!SWIG_IsOK(ecode16)) {
7940  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
7941  }
7942  arg16 = (PLFLT)(val16);
7943  ecode17 = SWIG_AsVal_double(obj13, &val17);
7944  if (!SWIG_IsOK(ecode17)) {
7945  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
7946  }
7947  arg17 = (PLFLT)(val17);
7948  ecode18 = SWIG_AsVal_double(obj14, &val18);
7949  if (!SWIG_IsOK(ecode18)) {
7950  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
7951  }
7952  arg18 = (PLFLT)(val18);
7953  {
7954  tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj15, NPY_PLINT, 1, 1 );
7955  if ( tmp19 == NULL )
7956  return NULL;
7957  if ( PyArray_DIMS( tmp19 )[0] != Alen )
7958  {
7959  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7960  return NULL;
7961  }
7962  arg19 = (PLINT *) PyArray_DATA( tmp19 );
7963  }
7964  {
7965  int i;
7966  tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 );
7967  if ( tmp20 == NULL )
7968  return NULL;
7969  if ( PyArray_DIMS( tmp20 )[0] != Alen )
7970  {
7971  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7972  return NULL;
7973  }
7974  arg20 = (char **) malloc( sizeof ( char* ) * Alen );
7975  for ( i = 0; i < Alen; i++ )
7976  {
7977  arg20[i] = PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
7978  if ( arg20[i] == NULL )
7979  {
7980  free( arg20 );
7981  return NULL;
7982  }
7983  }
7984  }
7985  {
7986  tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
7987  if ( tmp21 == NULL )
7988  return NULL;
7989  if ( PyArray_DIMS( tmp21 )[0] != Alen )
7990  {
7991  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7992  return NULL;
7993  }
7994  arg21 = (PLINT *) PyArray_DATA( tmp21 );
7995  }
7996  {
7997  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
7998  if ( tmp22 == NULL )
7999  return NULL;
8000  if ( PyArray_DIMS( tmp22 )[0] != Alen )
8001  {
8002  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8003  return NULL;
8004  }
8005  arg22 = (PLINT *) PyArray_DATA( tmp22 );
8006  }
8007  {
8008  tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 1, 1 );
8009  if ( tmp23 == NULL )
8010  return NULL;
8011  if ( PyArray_DIMS( tmp23 )[0] != Alen )
8012  {
8013  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8014  return NULL;
8015  }
8016  arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8017  }
8018  {
8019  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj20, NPY_PLFLT, 1, 1 );
8020  if ( tmp24 == NULL )
8021  return NULL;
8022  if ( PyArray_DIMS( tmp24 )[0] != Alen )
8023  {
8024  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8025  return NULL;
8026  }
8027  arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8028  }
8029  {
8030  tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj21, NPY_PLINT, 1, 1 );
8031  if ( tmp25 == NULL )
8032  return NULL;
8033  if ( PyArray_DIMS( tmp25 )[0] != Alen )
8034  {
8035  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8036  return NULL;
8037  }
8038  arg25 = (PLINT *) PyArray_DATA( tmp25 );
8039  }
8040  {
8041  tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj22, NPY_PLINT, 1, 1 );
8042  if ( tmp26 == NULL )
8043  return NULL;
8044  if ( PyArray_DIMS( tmp26 )[0] != Alen )
8045  {
8046  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8047  return NULL;
8048  }
8049  arg26 = (PLINT *) PyArray_DATA( tmp26 );
8050  }
8051  {
8052  tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( obj23, NPY_PLFLT, 1, 1 );
8053  if ( tmp27 == NULL )
8054  return NULL;
8055  if ( PyArray_DIMS( tmp27 )[0] != Alen )
8056  {
8057  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8058  return NULL;
8059  }
8060  arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8061  }
8062  {
8063  tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj24, NPY_PLINT, 1, 1 );
8064  if ( tmp28 == NULL )
8065  return NULL;
8066  if ( PyArray_DIMS( tmp28 )[0] != Alen )
8067  {
8068  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8069  return NULL;
8070  }
8071  arg28 = (PLINT *) PyArray_DATA( tmp28 );
8072  }
8073  {
8074  tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( obj25, NPY_PLFLT, 1, 1 );
8075  if ( tmp29 == NULL )
8076  return NULL;
8077  if ( PyArray_DIMS( tmp29 )[0] != Alen )
8078  {
8079  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8080  return NULL;
8081  }
8082  arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8083  }
8084  {
8085  tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj26, NPY_PLINT, 1, 1 );
8086  if ( tmp30 == NULL )
8087  return NULL;
8088  if ( PyArray_DIMS( tmp30 )[0] != Alen )
8089  {
8090  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8091  return NULL;
8092  }
8093  arg30 = (PLINT *) PyArray_DATA( tmp30 );
8094  }
8095  {
8096  int i;
8097  tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 );
8098  if ( tmp31 == NULL )
8099  return NULL;
8100  if ( PyArray_DIMS( tmp31 )[0] != Alen )
8101  {
8102  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8103  return NULL;
8104  }
8105  arg31 = (char **) malloc( sizeof ( char* ) * Alen );
8106  for ( i = 0; i < Alen; i++ )
8107  {
8108  arg31[i] = PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8109  if ( arg31[i] == NULL )
8110  {
8111  free( arg31 );
8112  return NULL;
8113  }
8114  }
8115  }
8116  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);
8117  resultobj = SWIG_Py_Void();
8118  if (SWIG_IsTmpObj(res1)) {
8119  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8120  } else {
8121  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8122  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8123  }
8124  if (SWIG_IsTmpObj(res2)) {
8125  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8126  } else {
8127  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8128  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8129  }
8130  {
8131  Py_DECREF( tmp13 );
8132  }
8133  {
8134  Py_DECREF( tmp19 );
8135  }
8136  {
8137  Py_DECREF( tmp20 ); free( arg20 );
8138  }
8139  {
8140  Py_DECREF( tmp21 );
8141  }
8142  {
8143  Py_DECREF( tmp22 );
8144  }
8145  {
8146  Py_DECREF( tmp23 );
8147  }
8148  {
8149  Py_DECREF( tmp24 );
8150  }
8151  {
8152  Py_DECREF( tmp25 );
8153  }
8154  {
8155  Py_DECREF( tmp26 );
8156  }
8157  {
8158  Py_DECREF( tmp27 );
8159  }
8160  {
8161  Py_DECREF( tmp28 );
8162  }
8163  {
8164  Py_DECREF( tmp29 );
8165  }
8166  {
8167  Py_DECREF( tmp30 );
8168  }
8169  {
8170  Py_DECREF( tmp31 ); free( arg31 );
8171  }
8172  return resultobj;
8173 fail:
8174  {
8175  Py_DECREF( tmp13 );
8176  }
8177  {
8178  Py_DECREF( tmp19 );
8179  }
8180  {
8181  Py_DECREF( tmp20 ); free( arg20 );
8182  }
8183  {
8184  Py_DECREF( tmp21 );
8185  }
8186  {
8187  Py_DECREF( tmp22 );
8188  }
8189  {
8190  Py_DECREF( tmp23 );
8191  }
8192  {
8193  Py_DECREF( tmp24 );
8194  }
8195  {
8196  Py_DECREF( tmp25 );
8197  }
8198  {
8199  Py_DECREF( tmp26 );
8200  }
8201  {
8202  Py_DECREF( tmp27 );
8203  }
8204  {
8205  Py_DECREF( tmp28 );
8206  }
8207  {
8208  Py_DECREF( tmp29 );
8209  }
8210  {
8211  Py_DECREF( tmp30 );
8212  }
8213  {
8214  Py_DECREF( tmp31 ); free( arg31 );
8215  }
8216  return NULL;
8217 }
8218 
8219 
8220 SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8221  PyObject *resultobj = 0;
8222  PLFLT *arg1 = (PLFLT *) 0 ;
8223  PLFLT *arg2 = (PLFLT *) 0 ;
8224  PLINT arg3 ;
8225  PLINT arg4 ;
8226  PLFLT arg5 ;
8227  PLFLT arg6 ;
8228  PLFLT arg7 ;
8229  PLFLT arg8 ;
8230  PLINT arg9 ;
8231  PLINT arg10 ;
8232  PLINT arg11 ;
8233  PLFLT arg12 ;
8234  PLFLT arg13 ;
8235  PLINT arg14 ;
8236  PLFLT arg15 ;
8237  PLINT arg16 ;
8238  PLINT *arg17 = (PLINT *) 0 ;
8239  char **arg18 = (char **) 0 ;
8240  PLINT arg19 ;
8241  char **arg20 = (char **) 0 ;
8242  PLFLT *arg21 = (PLFLT *) 0 ;
8243  PLINT *arg22 = (PLINT *) 0 ;
8244  PLINT *arg23 = (PLINT *) 0 ;
8245  PLFLT **arg24 = (PLFLT **) 0 ;
8246  PLFLT temp1 ;
8247  int res1 = SWIG_TMPOBJ ;
8248  PLFLT temp2 ;
8249  int res2 = SWIG_TMPOBJ ;
8250  int val3 ;
8251  int ecode3 = 0 ;
8252  int val4 ;
8253  int ecode4 = 0 ;
8254  double val5 ;
8255  int ecode5 = 0 ;
8256  double val6 ;
8257  int ecode6 = 0 ;
8258  double val7 ;
8259  int ecode7 = 0 ;
8260  double val8 ;
8261  int ecode8 = 0 ;
8262  int val9 ;
8263  int ecode9 = 0 ;
8264  int val10 ;
8265  int ecode10 = 0 ;
8266  int val11 ;
8267  int ecode11 = 0 ;
8268  double val12 ;
8269  int ecode12 = 0 ;
8270  double val13 ;
8271  int ecode13 = 0 ;
8272  int val14 ;
8273  int ecode14 = 0 ;
8274  double val15 ;
8275  int ecode15 = 0 ;
8276  PyArrayObject *tmp16 ;
8277  PyArrayObject *tmp18 ;
8278  PyArrayObject *tmp19 ;
8279  PyArrayObject *tmp21 ;
8280  PyArrayObject *tmp22 ;
8281  PyArrayObject *tmp23 ;
8282  PyArrayObject *tmp24 ;
8283  PyObject * obj0 = 0 ;
8284  PyObject * obj1 = 0 ;
8285  PyObject * obj2 = 0 ;
8286  PyObject * obj3 = 0 ;
8287  PyObject * obj4 = 0 ;
8288  PyObject * obj5 = 0 ;
8289  PyObject * obj6 = 0 ;
8290  PyObject * obj7 = 0 ;
8291  PyObject * obj8 = 0 ;
8292  PyObject * obj9 = 0 ;
8293  PyObject * obj10 = 0 ;
8294  PyObject * obj11 = 0 ;
8295  PyObject * obj12 = 0 ;
8296  PyObject * obj13 = 0 ;
8297  PyObject * obj14 = 0 ;
8298  PyObject * obj15 = 0 ;
8299  PyObject * obj16 = 0 ;
8300  PyObject * obj17 = 0 ;
8301  PyObject * obj18 = 0 ;
8302  PyObject * obj19 = 0 ;
8303 
8304  arg1 = &temp1;
8305  arg2 = &temp2;
8306  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;
8307  ecode3 = SWIG_AsVal_int(obj0, &val3);
8308  if (!SWIG_IsOK(ecode3)) {
8309  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8310  }
8311  arg3 = (PLINT)(val3);
8312  ecode4 = SWIG_AsVal_int(obj1, &val4);
8313  if (!SWIG_IsOK(ecode4)) {
8314  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8315  }
8316  arg4 = (PLINT)(val4);
8317  ecode5 = SWIG_AsVal_double(obj2, &val5);
8318  if (!SWIG_IsOK(ecode5)) {
8319  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8320  }
8321  arg5 = (PLFLT)(val5);
8322  ecode6 = SWIG_AsVal_double(obj3, &val6);
8323  if (!SWIG_IsOK(ecode6)) {
8324  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8325  }
8326  arg6 = (PLFLT)(val6);
8327  ecode7 = SWIG_AsVal_double(obj4, &val7);
8328  if (!SWIG_IsOK(ecode7)) {
8329  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8330  }
8331  arg7 = (PLFLT)(val7);
8332  ecode8 = SWIG_AsVal_double(obj5, &val8);
8333  if (!SWIG_IsOK(ecode8)) {
8334  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8335  }
8336  arg8 = (PLFLT)(val8);
8337  ecode9 = SWIG_AsVal_int(obj6, &val9);
8338  if (!SWIG_IsOK(ecode9)) {
8339  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8340  }
8341  arg9 = (PLINT)(val9);
8342  ecode10 = SWIG_AsVal_int(obj7, &val10);
8343  if (!SWIG_IsOK(ecode10)) {
8344  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8345  }
8346  arg10 = (PLINT)(val10);
8347  ecode11 = SWIG_AsVal_int(obj8, &val11);
8348  if (!SWIG_IsOK(ecode11)) {
8349  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8350  }
8351  arg11 = (PLINT)(val11);
8352  ecode12 = SWIG_AsVal_double(obj9, &val12);
8353  if (!SWIG_IsOK(ecode12)) {
8354  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8355  }
8356  arg12 = (PLFLT)(val12);
8357  ecode13 = SWIG_AsVal_double(obj10, &val13);
8358  if (!SWIG_IsOK(ecode13)) {
8359  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8360  }
8361  arg13 = (PLFLT)(val13);
8362  ecode14 = SWIG_AsVal_int(obj11, &val14);
8363  if (!SWIG_IsOK(ecode14)) {
8364  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8365  }
8366  arg14 = (PLINT)(val14);
8367  ecode15 = SWIG_AsVal_double(obj12, &val15);
8368  if (!SWIG_IsOK(ecode15)) {
8369  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8370  }
8371  arg15 = (PLFLT)(val15);
8372  {
8373  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
8374  if ( tmp16 == NULL )
8375  return NULL;
8376  arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8377  arg17 = (PLINT *) PyArray_DATA( tmp16 );
8378  }
8379  {
8380  int i;
8381  tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( obj14, NPY_STRING, 1, 1 );
8382  if ( tmp18 == NULL )
8383  return NULL;
8384  if ( PyArray_DIMS( tmp18 )[0] != Alen )
8385  {
8386  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8387  return NULL;
8388  }
8389  arg18 = (char **) malloc( sizeof ( char* ) * Alen );
8390  for ( i = 0; i < Alen; i++ )
8391  {
8392  arg18[i] = PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8393  if ( arg18[i] == NULL )
8394  {
8395  free( arg18 );
8396  return NULL;
8397  }
8398  }
8399  }
8400  {
8401  int i;
8402  tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( obj15, NPY_STRING, 1, 1 );
8403  if ( tmp19 == NULL )
8404  return NULL;
8405  Alen = PyArray_DIMS( tmp19 )[0];
8406  arg19 = Alen;
8407  arg20 = (char **) malloc( sizeof ( char* ) * Alen );
8408  for ( i = 0; i < Alen; i++ )
8409  {
8410  arg20[i] = PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8411  if ( arg20[i] == NULL )
8412  {
8413  free( arg20 );
8414  return NULL;
8415  }
8416  }
8417  }
8418  {
8419  tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( obj16, NPY_PLFLT, 1, 1 );
8420  if ( tmp21 == NULL )
8421  return NULL;
8422  if ( PyArray_DIMS( tmp21 )[0] != Alen )
8423  {
8424  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8425  return NULL;
8426  }
8427  arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8428  }
8429  {
8430  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
8431  if ( tmp22 == NULL )
8432  return NULL;
8433  if ( PyArray_DIMS( tmp22 )[0] != Alen )
8434  {
8435  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8436  return NULL;
8437  }
8438  arg22 = (PLINT *) PyArray_DATA( tmp22 );
8439  }
8440  {
8441  int i;
8442  tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
8443  if ( tmp23 == NULL )
8444  return NULL;
8445  if ( PyArray_DIMS( tmp23 )[0] != Alen )
8446  {
8447  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8448  return NULL;
8449  }
8450  Xlen = PyArray_DIMS( tmp23 )[0];
8451  arg23 = (PLINT *) PyArray_DATA( tmp23 );
8452  Ylen = -1;
8453  for ( i = 0; i < Xlen; i++ )
8454  if ( arg23[i] > Ylen )
8455  Ylen = arg23[i];
8456  }
8457  {
8458  int i, size;
8459  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 2, 2 );
8460  if ( tmp24 == NULL )
8461  return NULL;
8462  if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8463  {
8464  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8465  return NULL;
8466  }
8467  size = sizeof ( PLFLT ) * Ylen;
8468  arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * Xlen );
8469  for ( i = 0; i < Xlen; i++ )
8470  arg24[i] = (PLFLT *) ( PyArray_DATA( tmp24 ) + i * size );
8471  }
8472  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);
8473  resultobj = SWIG_Py_Void();
8474  if (SWIG_IsTmpObj(res1)) {
8475  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8476  } else {
8477  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8478  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8479  }
8480  if (SWIG_IsTmpObj(res2)) {
8481  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8482  } else {
8483  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8484  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8485  }
8486  {
8487  Py_DECREF( tmp16 );
8488  }
8489  {
8490  Py_DECREF( tmp18 ); free( arg18 );
8491  }
8492  {
8493  Py_DECREF( tmp19 ); free( arg20 );
8494  }
8495  {
8496  Py_DECREF( tmp21 );
8497  }
8498  {
8499  Py_DECREF( tmp22 );
8500  }
8501  {
8502  Py_DECREF( tmp23 );
8503  }
8504  {
8505  Py_DECREF( tmp24 );
8506  free( arg24 );
8507  }
8508  return resultobj;
8509 fail:
8510  {
8511  Py_DECREF( tmp16 );
8512  }
8513  {
8514  Py_DECREF( tmp18 ); free( arg18 );
8515  }
8516  {
8517  Py_DECREF( tmp19 ); free( arg20 );
8518  }
8519  {
8520  Py_DECREF( tmp21 );
8521  }
8522  {
8523  Py_DECREF( tmp22 );
8524  }
8525  {
8526  Py_DECREF( tmp23 );
8527  }
8528  {
8529  Py_DECREF( tmp24 );
8530  free( arg24 );
8531  }
8532  return NULL;
8533 }
8534 
8535 
8536 SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8537  PyObject *resultobj = 0;
8538  PLFLT arg1 ;
8539  PLFLT arg2 ;
8540  PLFLT arg3 ;
8541  double val1 ;
8542  int ecode1 = 0 ;
8543  double val2 ;
8544  int ecode2 = 0 ;
8545  double val3 ;
8546  int ecode3 = 0 ;
8547  PyObject * obj0 = 0 ;
8548  PyObject * obj1 = 0 ;
8549  PyObject * obj2 = 0 ;
8550 
8551  if (!PyArg_ParseTuple(args,(char *)"OOO:pllightsource",&obj0,&obj1,&obj2)) SWIG_fail;
8552  ecode1 = SWIG_AsVal_double(obj0, &val1);
8553  if (!SWIG_IsOK(ecode1)) {
8554  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8555  }
8556  arg1 = (PLFLT)(val1);
8557  ecode2 = SWIG_AsVal_double(obj1, &val2);
8558  if (!SWIG_IsOK(ecode2)) {
8559  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8560  }
8561  arg2 = (PLFLT)(val2);
8562  ecode3 = SWIG_AsVal_double(obj2, &val3);
8563  if (!SWIG_IsOK(ecode3)) {
8564  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8565  }
8566  arg3 = (PLFLT)(val3);
8567  pllightsource(arg1,arg2,arg3);
8568  resultobj = SWIG_Py_Void();
8569  return resultobj;
8570 fail:
8571  return NULL;
8572 }
8573 
8574 
8575 SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8576  PyObject *resultobj = 0;
8577  PLINT arg1 ;
8578  PLFLT *arg2 = (PLFLT *) 0 ;
8579  PLFLT *arg3 = (PLFLT *) 0 ;
8580  PyArrayObject *tmp1 ;
8581  PyArrayObject *tmp3 ;
8582  PyObject * obj0 = 0 ;
8583  PyObject * obj1 = 0 ;
8584 
8585  if (!PyArg_ParseTuple(args,(char *)"OO:plline",&obj0,&obj1)) SWIG_fail;
8586  {
8587  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8588  if ( tmp1 == NULL )
8589  return NULL;
8590  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8591  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8592  }
8593  {
8594  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8595  if ( tmp3 == NULL )
8596  return NULL;
8597  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8598  {
8599  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8600  return NULL;
8601  }
8602  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8603  }
8604  plline(arg1,(double const *)arg2,(double const *)arg3);
8605  resultobj = SWIG_Py_Void();
8606  {
8607  Py_DECREF( tmp1 );
8608  }
8609  {
8610  Py_DECREF( tmp3 );
8611  }
8612  return resultobj;
8613 fail:
8614  {
8615  Py_DECREF( tmp1 );
8616  }
8617  {
8618  Py_DECREF( tmp3 );
8619  }
8620  return NULL;
8621 }
8622 
8623 
8624 SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8625  PyObject *resultobj = 0;
8626  PLINT arg1 ;
8627  PLFLT *arg2 = (PLFLT *) 0 ;
8628  PLFLT *arg3 = (PLFLT *) 0 ;
8629  PLFLT *arg4 = (PLFLT *) 0 ;
8630  PyArrayObject *tmp1 ;
8631  PyArrayObject *tmp3 ;
8632  PyArrayObject *tmp4 ;
8633  PyObject * obj0 = 0 ;
8634  PyObject * obj1 = 0 ;
8635  PyObject * obj2 = 0 ;
8636 
8637  if (!PyArg_ParseTuple(args,(char *)"OOO:plline3",&obj0,&obj1,&obj2)) SWIG_fail;
8638  {
8639  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8640  if ( tmp1 == NULL )
8641  return NULL;
8642  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8643  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8644  }
8645  {
8646  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8647  if ( tmp3 == NULL )
8648  return NULL;
8649  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8650  {
8651  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8652  return NULL;
8653  }
8654  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8655  }
8656  {
8657  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
8658  if ( tmp4 == NULL )
8659  return NULL;
8660  if ( PyArray_DIMS( tmp4 )[0] != Alen )
8661  {
8662  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8663  return NULL;
8664  }
8665  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8666  }
8667  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8668  resultobj = SWIG_Py_Void();
8669  {
8670  Py_DECREF( tmp1 );
8671  }
8672  {
8673  Py_DECREF( tmp3 );
8674  }
8675  {
8676  Py_DECREF( tmp4 );
8677  }
8678  return resultobj;
8679 fail:
8680  {
8681  Py_DECREF( tmp1 );
8682  }
8683  {
8684  Py_DECREF( tmp3 );
8685  }
8686  {
8687  Py_DECREF( tmp4 );
8688  }
8689  return NULL;
8690 }
8691 
8692 
8693 SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8694  PyObject *resultobj = 0;
8695  PLINT arg1 ;
8696  int val1 ;
8697  int ecode1 = 0 ;
8698  PyObject * obj0 = 0 ;
8699 
8700  if (!PyArg_ParseTuple(args,(char *)"O:pllsty",&obj0)) SWIG_fail;
8701  ecode1 = SWIG_AsVal_int(obj0, &val1);
8702  if (!SWIG_IsOK(ecode1)) {
8703  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
8704  }
8705  arg1 = (PLINT)(val1);
8706  pllsty(arg1);
8707  resultobj = SWIG_Py_Void();
8708  return resultobj;
8709 fail:
8710  return NULL;
8711 }
8712 
8713 
8714 SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8715  PyObject *resultobj = 0;
8716  PLFLT *arg1 = (PLFLT *) 0 ;
8717  PLFLT *arg2 = (PLFLT *) 0 ;
8718  PLFLT **arg3 = (PLFLT **) 0 ;
8719  PLINT arg4 ;
8720  PLINT arg5 ;
8721  PLINT arg6 ;
8722  PyArrayObject *tmp1 ;
8723  PyArrayObject *tmp2 ;
8724  PyArrayObject *tmp3 ;
8725  int val6 ;
8726  int ecode6 = 0 ;
8727  PyObject * obj0 = 0 ;
8728  PyObject * obj1 = 0 ;
8729  PyObject * obj2 = 0 ;
8730  PyObject * obj3 = 0 ;
8731 
8732  if (!PyArg_ParseTuple(args,(char *)"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8733  {
8734  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8735  if ( tmp1 == NULL )
8736  return NULL;
8737  Xlen = PyArray_DIMS( tmp1 )[0];
8738  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8739  }
8740  {
8741  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8742  if ( tmp2 == NULL )
8743  return NULL;
8744  Ylen = PyArray_DIMS( tmp2 )[0];
8745  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8746  }
8747  {
8748  int i, size;
8749  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
8750  if ( tmp3 == NULL )
8751  return NULL;
8752  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8753  {
8754  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8755  return NULL;
8756  }
8757  arg4 = PyArray_DIMS( tmp3 )[0];
8758  arg5 = PyArray_DIMS( tmp3 )[1];
8759  size = sizeof ( PLFLT ) * arg5;
8760  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
8761  for ( i = 0; i < arg4; i++ )
8762  arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
8763  }
8764  ecode6 = SWIG_AsVal_int(obj3, &val6);
8765  if (!SWIG_IsOK(ecode6)) {
8766  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
8767  }
8768  arg6 = (PLINT)(val6);
8769  plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
8770  resultobj = SWIG_Py_Void();
8771  {
8772  Py_DECREF( tmp1 );
8773  }
8774  {
8775  Py_DECREF( tmp2 );
8776  }
8777  {
8778  Py_DECREF( tmp3 );
8779  free( arg3 );
8780  }
8781  return resultobj;
8782 fail:
8783  {
8784  Py_DECREF( tmp1 );
8785  }
8786  {
8787  Py_DECREF( tmp2 );
8788  }
8789  {
8790  Py_DECREF( tmp3 );
8791  free( arg3 );
8792  }
8793  return NULL;
8794 }
8795 
8796 
8797 SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8798  PyObject *resultobj = 0;
8799  PLFLT *arg1 = (PLFLT *) 0 ;
8800  PLFLT *arg2 = (PLFLT *) 0 ;
8801  PLFLT **arg3 = (PLFLT **) 0 ;
8802  PLINT arg4 ;
8803  PLINT arg5 ;
8804  PLINT arg6 ;
8805  PLFLT *arg7 = (PLFLT *) 0 ;
8806  PLINT arg8 ;
8807  PyArrayObject *tmp1 ;
8808  PyArrayObject *tmp2 ;
8809  PyArrayObject *tmp3 ;
8810  int val6 ;
8811  int ecode6 = 0 ;
8812  PyArrayObject *tmp7 ;
8813  PyObject * obj0 = 0 ;
8814  PyObject * obj1 = 0 ;
8815  PyObject * obj2 = 0 ;
8816  PyObject * obj3 = 0 ;
8817  PyObject * obj4 = 0 ;
8818 
8819  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8820  {
8821  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8822  if ( tmp1 == NULL )
8823  return NULL;
8824  Xlen = PyArray_DIMS( tmp1 )[0];
8825  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8826  }
8827  {
8828  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8829  if ( tmp2 == NULL )
8830  return NULL;
8831  Ylen = PyArray_DIMS( tmp2 )[0];
8832  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8833  }
8834  {
8835  int i, size;
8836  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
8837  if ( tmp3 == NULL )
8838  return NULL;
8839  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8840  {
8841  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8842  return NULL;
8843  }
8844  arg4 = PyArray_DIMS( tmp3 )[0];
8845  arg5 = PyArray_DIMS( tmp3 )[1];
8846  size = sizeof ( PLFLT ) * arg5;
8847  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
8848  for ( i = 0; i < arg4; i++ )
8849  arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
8850  }
8851  ecode6 = SWIG_AsVal_int(obj3, &val6);
8852  if (!SWIG_IsOK(ecode6)) {
8853  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
8854  }
8855  arg6 = (PLINT)(val6);
8856  {
8857  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
8858  if ( tmp7 == NULL )
8859  return NULL;
8860  arg8 = PyArray_DIMS( tmp7 )[0];
8861  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8862  }
8863  plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
8864  resultobj = SWIG_Py_Void();
8865  {
8866  Py_DECREF( tmp1 );
8867  }
8868  {
8869  Py_DECREF( tmp2 );
8870  }
8871  {
8872  Py_DECREF( tmp3 );
8873  free( arg3 );
8874  }
8875  {
8876  Py_DECREF( tmp7 );
8877  }
8878  return resultobj;
8879 fail:
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 NULL;
8894 }
8895 
8896 
8897 SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8898  PyObject *resultobj = 0;
8899  PLINT *arg1 = (PLINT *) 0 ;
8900  PLINT temp1 ;
8901  int res1 = SWIG_TMPOBJ ;
8902 
8903  arg1 = &temp1;
8904  if (!PyArg_ParseTuple(args,(char *)":plmkstrm")) SWIG_fail;
8905  plmkstrm(arg1);
8906  resultobj = SWIG_Py_Void();
8907  if (SWIG_IsTmpObj(res1)) {
8908  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
8909  } else {
8910  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8911  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8912  }
8913  return resultobj;
8914 fail:
8915  return NULL;
8916 }
8917 
8918 
8919 SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8920  PyObject *resultobj = 0;
8921  char *arg1 = (char *) 0 ;
8922  PLFLT arg2 ;
8923  PLFLT arg3 ;
8924  PLFLT arg4 ;
8925  char *arg5 = (char *) 0 ;
8926  int res1 ;
8927  char *buf1 = 0 ;
8928  int alloc1 = 0 ;
8929  double val2 ;
8930  int ecode2 = 0 ;
8931  double val3 ;
8932  int ecode3 = 0 ;
8933  double val4 ;
8934  int ecode4 = 0 ;
8935  int res5 ;
8936  char *buf5 = 0 ;
8937  int alloc5 = 0 ;
8938  PyObject * obj0 = 0 ;
8939  PyObject * obj1 = 0 ;
8940  PyObject * obj2 = 0 ;
8941  PyObject * obj3 = 0 ;
8942  PyObject * obj4 = 0 ;
8943 
8944  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8945  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
8946  if (!SWIG_IsOK(res1)) {
8947  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
8948  }
8949  arg1 = (char *)(buf1);
8950  ecode2 = SWIG_AsVal_double(obj1, &val2);
8951  if (!SWIG_IsOK(ecode2)) {
8952  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
8953  }
8954  arg2 = (PLFLT)(val2);
8955  ecode3 = SWIG_AsVal_double(obj2, &val3);
8956  if (!SWIG_IsOK(ecode3)) {
8957  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
8958  }
8959  arg3 = (PLFLT)(val3);
8960  ecode4 = SWIG_AsVal_double(obj3, &val4);
8961  if (!SWIG_IsOK(ecode4)) {
8962  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
8963  }
8964  arg4 = (PLFLT)(val4);
8965  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
8966  if (!SWIG_IsOK(res5)) {
8967  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
8968  }
8969  arg5 = (char *)(buf5);
8970  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
8971  resultobj = SWIG_Py_Void();
8972  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8973  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8974  return resultobj;
8975 fail:
8976  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8977  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8978  return NULL;
8979 }
8980 
8981 
8982 SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8983  PyObject *resultobj = 0;
8984  char *arg1 = (char *) 0 ;
8985  PLFLT arg2 ;
8986  PLFLT arg3 ;
8987  PLFLT arg4 ;
8988  char *arg5 = (char *) 0 ;
8989  int res1 ;
8990  char *buf1 = 0 ;
8991  int alloc1 = 0 ;
8992  double val2 ;
8993  int ecode2 = 0 ;
8994  double val3 ;
8995  int ecode3 = 0 ;
8996  double val4 ;
8997  int ecode4 = 0 ;
8998  int res5 ;
8999  char *buf5 = 0 ;
9000  int alloc5 = 0 ;
9001  PyObject * obj0 = 0 ;
9002  PyObject * obj1 = 0 ;
9003  PyObject * obj2 = 0 ;
9004  PyObject * obj3 = 0 ;
9005  PyObject * obj4 = 0 ;
9006 
9007  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9008  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
9009  if (!SWIG_IsOK(res1)) {
9010  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9011  }
9012  arg1 = (char *)(buf1);
9013  ecode2 = SWIG_AsVal_double(obj1, &val2);
9014  if (!SWIG_IsOK(ecode2)) {
9015  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9016  }
9017  arg2 = (PLFLT)(val2);
9018  ecode3 = SWIG_AsVal_double(obj2, &val3);
9019  if (!SWIG_IsOK(ecode3)) {
9020  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9021  }
9022  arg3 = (PLFLT)(val3);
9023  ecode4 = SWIG_AsVal_double(obj3, &val4);
9024  if (!SWIG_IsOK(ecode4)) {
9025  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9026  }
9027  arg4 = (PLFLT)(val4);
9028  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
9029  if (!SWIG_IsOK(res5)) {
9030  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9031  }
9032  arg5 = (char *)(buf5);
9033  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9034  resultobj = SWIG_Py_Void();
9035  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9036  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9037  return resultobj;
9038 fail:
9039  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9040  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9041  return NULL;
9042 }
9043 
9044 
9045 SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9046  PyObject *resultobj = 0;
9047  PLFLT *arg1 = (PLFLT *) 0 ;
9048  PLFLT *arg2 = (PLFLT *) 0 ;
9049  PLFLT **arg3 = (PLFLT **) 0 ;
9050  PLINT arg4 ;
9051  PLINT arg5 ;
9052  PLINT arg6 ;
9053  PLBOOL arg7 ;
9054  PyArrayObject *tmp1 ;
9055  PyArrayObject *tmp2 ;
9056  PyArrayObject *tmp3 ;
9057  int val6 ;
9058  int ecode6 = 0 ;
9059  int val7 ;
9060  int ecode7 = 0 ;
9061  PyObject * obj0 = 0 ;
9062  PyObject * obj1 = 0 ;
9063  PyObject * obj2 = 0 ;
9064  PyObject * obj3 = 0 ;
9065  PyObject * obj4 = 0 ;
9066 
9067  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9068  {
9069  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9070  if ( tmp1 == NULL )
9071  return NULL;
9072  Xlen = PyArray_DIMS( tmp1 )[0];
9073  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9074  }
9075  {
9076  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9077  if ( tmp2 == NULL )
9078  return NULL;
9079  Ylen = PyArray_DIMS( tmp2 )[0];
9080  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9081  }
9082  {
9083  int i, size;
9084  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9085  if ( tmp3 == NULL )
9086  return NULL;
9087  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9088  {
9089  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9090  return NULL;
9091  }
9092  arg4 = PyArray_DIMS( tmp3 )[0];
9093  arg5 = PyArray_DIMS( tmp3 )[1];
9094  size = sizeof ( PLFLT ) * arg5;
9095  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
9096  for ( i = 0; i < arg4; i++ )
9097  arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9098  }
9099  ecode6 = SWIG_AsVal_int(obj3, &val6);
9100  if (!SWIG_IsOK(ecode6)) {
9101  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9102  }
9103  arg6 = (PLINT)(val6);
9104  ecode7 = SWIG_AsVal_int(obj4, &val7);
9105  if (!SWIG_IsOK(ecode7)) {
9106  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9107  }
9108  arg7 = (PLBOOL)(val7);
9109  plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9110  resultobj = SWIG_Py_Void();
9111  {
9112  Py_DECREF( tmp1 );
9113  }
9114  {
9115  Py_DECREF( tmp2 );
9116  }
9117  {
9118  Py_DECREF( tmp3 );
9119  free( arg3 );
9120  }
9121  return resultobj;
9122 fail:
9123  {
9124  Py_DECREF( tmp1 );
9125  }
9126  {
9127  Py_DECREF( tmp2 );
9128  }
9129  {
9130  Py_DECREF( tmp3 );
9131  free( arg3 );
9132  }
9133  return NULL;
9134 }
9135 
9136 
9137 SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9138  PyObject *resultobj = 0;
9139  PLFLT *arg1 = (PLFLT *) 0 ;
9140  PLFLT *arg2 = (PLFLT *) 0 ;
9141  PLFLT **arg3 = (PLFLT **) 0 ;
9142  PLINT arg4 ;
9143  PLINT arg5 ;
9144  PLINT arg6 ;
9145  PLFLT *arg7 = (PLFLT *) 0 ;
9146  PLINT arg8 ;
9147  PyArrayObject *tmp1 ;
9148  PyArrayObject *tmp2 ;
9149  PyArrayObject *tmp3 ;
9150  int val6 ;
9151  int ecode6 = 0 ;
9152  PyArrayObject *tmp7 ;
9153  PyObject * obj0 = 0 ;
9154  PyObject * obj1 = 0 ;
9155  PyObject * obj2 = 0 ;
9156  PyObject * obj3 = 0 ;
9157  PyObject * obj4 = 0 ;
9158 
9159  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9160  {
9161  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9162  if ( tmp1 == NULL )
9163  return NULL;
9164  Xlen = PyArray_DIMS( tmp1 )[0];
9165  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9166  }
9167  {
9168  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9169  if ( tmp2 == NULL )
9170  return NULL;
9171  Ylen = PyArray_DIMS( tmp2 )[0];
9172  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9173  }
9174  {
9175  int i, size;
9176  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9177  if ( tmp3 == NULL )
9178  return NULL;
9179  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9180  {
9181  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9182  return NULL;
9183  }
9184  arg4 = PyArray_DIMS( tmp3 )[0];
9185  arg5 = PyArray_DIMS( tmp3 )[1];
9186  size = sizeof ( PLFLT ) * arg5;
9187  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
9188  for ( i = 0; i < arg4; i++ )
9189  arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9190  }
9191  ecode6 = SWIG_AsVal_int(obj3, &val6);
9192  if (!SWIG_IsOK(ecode6)) {
9193  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9194  }
9195  arg6 = (PLINT)(val6);
9196  {
9197  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9198  if ( tmp7 == NULL )
9199  return NULL;
9200  arg8 = PyArray_DIMS( tmp7 )[0];
9201  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9202  }
9203  plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9204  resultobj = SWIG_Py_Void();
9205  {
9206  Py_DECREF( tmp1 );
9207  }
9208  {
9209  Py_DECREF( tmp2 );
9210  }
9211  {
9212  Py_DECREF( tmp3 );
9213  free( arg3 );
9214  }
9215  {
9216  Py_DECREF( tmp7 );
9217  }
9218  return resultobj;
9219 fail:
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 NULL;
9234 }
9235 
9236 
9237 SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9238  PyObject *resultobj = 0;
9239  PLFLT *arg1 = (PLFLT *) 0 ;
9240  PLFLT *arg2 = (PLFLT *) 0 ;
9241  PLFLT **arg3 = (PLFLT **) 0 ;
9242  PLINT arg4 ;
9243  PLINT arg5 ;
9244  PLINT arg6 ;
9245  PLFLT *arg7 = (PLFLT *) 0 ;
9246  PLINT arg8 ;
9247  PLINT arg9 ;
9248  PLINT arg10 ;
9249  PLINT *arg11 = (PLINT *) 0 ;
9250  PLINT *arg12 = (PLINT *) 0 ;
9251  PyArrayObject *tmp1 ;
9252  PyArrayObject *tmp2 ;
9253  PyArrayObject *tmp3 ;
9254  int val6 ;
9255  int ecode6 = 0 ;
9256  PyArrayObject *tmp7 ;
9257  int val9 ;
9258  int ecode9 = 0 ;
9259  PyArrayObject *tmp10 ;
9260  PyArrayObject *tmp12 ;
9261  PyObject * obj0 = 0 ;
9262  PyObject * obj1 = 0 ;
9263  PyObject * obj2 = 0 ;
9264  PyObject * obj3 = 0 ;
9265  PyObject * obj4 = 0 ;
9266  PyObject * obj5 = 0 ;
9267  PyObject * obj6 = 0 ;
9268  PyObject * obj7 = 0 ;
9269 
9270  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9271  {
9272  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9273  if ( tmp1 == NULL )
9274  return NULL;
9275  Xlen = PyArray_DIMS( tmp1 )[0];
9276  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9277  }
9278  {
9279  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9280  if ( tmp2 == NULL )
9281  return NULL;
9282  Ylen = PyArray_DIMS( tmp2 )[0];
9283  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9284  }
9285  {
9286  int i, size;
9287  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9288  if ( tmp3 == NULL )
9289  return NULL;
9290  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9291  {
9292  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9293  return NULL;
9294  }
9295  arg4 = PyArray_DIMS( tmp3 )[0];
9296  arg5 = PyArray_DIMS( tmp3 )[1];
9297  size = sizeof ( PLFLT ) * arg5;
9298  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
9299  for ( i = 0; i < arg4; i++ )
9300  arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9301  }
9302  ecode6 = SWIG_AsVal_int(obj3, &val6);
9303  if (!SWIG_IsOK(ecode6)) {
9304  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9305  }
9306  arg6 = (PLINT)(val6);
9307  {
9308  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9309  if ( tmp7 == NULL )
9310  return NULL;
9311  arg8 = PyArray_DIMS( tmp7 )[0];
9312  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9313  }
9314  ecode9 = SWIG_AsVal_int(obj5, &val9);
9315  if (!SWIG_IsOK(ecode9)) {
9316  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9317  }
9318  arg9 = (PLINT)(val9);
9319  {
9320  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9321  if ( tmp10 == NULL )
9322  return NULL;
9323  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9324  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9325  }
9326  {
9327  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9328  if ( tmp12 == NULL )
9329  return NULL;
9330  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9331  {
9332  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9333  return NULL;
9334  }
9335  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9336  }
9337  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);
9338  resultobj = SWIG_Py_Void();
9339  {
9340  Py_DECREF( tmp1 );
9341  }
9342  {
9343  Py_DECREF( tmp2 );
9344  }
9345  {
9346  Py_DECREF( tmp3 );
9347  free( arg3 );
9348  }
9349  {
9350  Py_DECREF( tmp7 );
9351  }
9352  {
9353  Py_DECREF( tmp10 );
9354  }
9355  {
9356  Py_DECREF( tmp12 );
9357  }
9358  return resultobj;
9359 fail:
9360  {
9361  Py_DECREF( tmp1 );
9362  }
9363  {
9364  Py_DECREF( tmp2 );
9365  }
9366  {
9367  Py_DECREF( tmp3 );
9368  free( arg3 );
9369  }
9370  {
9371  Py_DECREF( tmp7 );
9372  }
9373  {
9374  Py_DECREF( tmp10 );
9375  }
9376  {
9377  Py_DECREF( tmp12 );
9378  }
9379  return NULL;
9380 }
9381 
9382 
9383 SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9384  PyObject *resultobj = 0;
9385  PLFLT *arg1 = (PLFLT *) 0 ;
9386  PLFLT *arg2 = (PLFLT *) 0 ;
9387  PLFLT **arg3 = (PLFLT **) 0 ;
9388  PLINT arg4 ;
9389  PLINT arg5 ;
9390  PLINT arg6 ;
9391  PLFLT *arg7 = (PLFLT *) 0 ;
9392  PLINT arg8 ;
9393  PyArrayObject *tmp1 ;
9394  PyArrayObject *tmp2 ;
9395  PyArrayObject *tmp3 ;
9396  int val6 ;
9397  int ecode6 = 0 ;
9398  PyArrayObject *tmp7 ;
9399  PyObject * obj0 = 0 ;
9400  PyObject * obj1 = 0 ;
9401  PyObject * obj2 = 0 ;
9402  PyObject * obj3 = 0 ;
9403  PyObject * obj4 = 0 ;
9404 
9405  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9406  {
9407  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9408  if ( tmp1 == NULL )
9409  return NULL;
9410  Xlen = PyArray_DIMS( tmp1 )[0];
9411  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9412  }
9413  {
9414  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9415  if ( tmp2 == NULL )
9416  return NULL;
9417  Ylen = PyArray_DIMS( tmp2 )[0];
9418  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9419  }
9420  {
9421  int i, size;
9422  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9423  if ( tmp3 == NULL )
9424  return NULL;
9425  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9426  {
9427  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9428  return NULL;
9429  }
9430  arg4 = PyArray_DIMS( tmp3 )[0];
9431  arg5 = PyArray_DIMS( tmp3 )[1];
9432  size = sizeof ( PLFLT ) * arg5;
9433  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
9434  for ( i = 0; i < arg4; i++ )
9435  arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9436  }
9437  ecode6 = SWIG_AsVal_int(obj3, &val6);
9438  if (!SWIG_IsOK(ecode6)) {
9439  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9440  }
9441  arg6 = (PLINT)(val6);
9442  {
9443  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9444  if ( tmp7 == NULL )
9445  return NULL;
9446  arg8 = PyArray_DIMS( tmp7 )[0];
9447  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9448  }
9449  plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9450  resultobj = SWIG_Py_Void();
9451  {
9452  Py_DECREF( tmp1 );
9453  }
9454  {
9455  Py_DECREF( tmp2 );
9456  }
9457  {
9458  Py_DECREF( tmp3 );
9459  free( arg3 );
9460  }
9461  {
9462  Py_DECREF( tmp7 );
9463  }
9464  return resultobj;
9465 fail:
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 NULL;
9480 }
9481 
9482 
9483 SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9484  PyObject *resultobj = 0;
9485  PLFLT *arg1 = (PLFLT *) 0 ;
9486  PLFLT *arg2 = (PLFLT *) 0 ;
9487  PLFLT **arg3 = (PLFLT **) 0 ;
9488  PLINT arg4 ;
9489  PLINT arg5 ;
9490  PLINT arg6 ;
9491  PLFLT *arg7 = (PLFLT *) 0 ;
9492  PLINT arg8 ;
9493  PLINT arg9 ;
9494  PLINT arg10 ;
9495  PLINT *arg11 = (PLINT *) 0 ;
9496  PLINT *arg12 = (PLINT *) 0 ;
9497  PyArrayObject *tmp1 ;
9498  PyArrayObject *tmp2 ;
9499  PyArrayObject *tmp3 ;
9500  int val6 ;
9501  int ecode6 = 0 ;
9502  PyArrayObject *tmp7 ;
9503  int val9 ;
9504  int ecode9 = 0 ;
9505  PyArrayObject *tmp10 ;
9506  PyArrayObject *tmp12 ;
9507  PyObject * obj0 = 0 ;
9508  PyObject * obj1 = 0 ;
9509  PyObject * obj2 = 0 ;
9510  PyObject * obj3 = 0 ;
9511  PyObject * obj4 = 0 ;
9512  PyObject * obj5 = 0 ;
9513  PyObject * obj6 = 0 ;
9514  PyObject * obj7 = 0 ;
9515 
9516  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9517  {
9518  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9519  if ( tmp1 == NULL )
9520  return NULL;
9521  Xlen = PyArray_DIMS( tmp1 )[0];
9522  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9523  }
9524  {
9525  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9526  if ( tmp2 == NULL )
9527  return NULL;
9528  Ylen = PyArray_DIMS( tmp2 )[0];
9529  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9530  }
9531  {
9532  int i, size;
9533  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9534  if ( tmp3 == NULL )
9535  return NULL;
9536  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9537  {
9538  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9539  return NULL;
9540  }
9541  arg4 = PyArray_DIMS( tmp3 )[0];
9542  arg5 = PyArray_DIMS( tmp3 )[1];
9543  size = sizeof ( PLFLT ) * arg5;
9544  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
9545  for ( i = 0; i < arg4; i++ )
9546  arg3[i] = (PLFLT *) ( PyArray_DATA( tmp3 ) + i * size );
9547  }
9548  ecode6 = SWIG_AsVal_int(obj3, &val6);
9549  if (!SWIG_IsOK(ecode6)) {
9550  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9551  }
9552  arg6 = (PLINT)(val6);
9553  {
9554  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9555  if ( tmp7 == NULL )
9556  return NULL;
9557  arg8 = PyArray_DIMS( tmp7 )[0];
9558  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9559  }
9560  ecode9 = SWIG_AsVal_int(obj5, &val9);
9561  if (!SWIG_IsOK(ecode9)) {
9562  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9563  }
9564  arg9 = (PLINT)(val9);
9565  {
9566  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9567  if ( tmp10 == NULL )
9568  return NULL;
9569  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9570  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9571  }
9572  {
9573  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9574  if ( tmp12 == NULL )
9575  return NULL;
9576  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9577  {
9578  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9579  return NULL;
9580  }
9581  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9582  }
9583  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);
9584  resultobj = SWIG_Py_Void();
9585  {
9586  Py_DECREF( tmp1 );
9587  }
9588  {
9589  Py_DECREF( tmp2 );
9590  }
9591  {
9592  Py_DECREF( tmp3 );
9593  free( arg3 );
9594  }
9595  {
9596  Py_DECREF( tmp7 );
9597  }
9598  {
9599  Py_DECREF( tmp10 );
9600  }
9601  {
9602  Py_DECREF( tmp12 );
9603  }
9604  return resultobj;
9605 fail:
9606  {
9607  Py_DECREF( tmp1 );
9608  }
9609  {
9610  Py_DECREF( tmp2 );
9611  }
9612  {
9613  Py_DECREF( tmp3 );
9614  free( arg3 );
9615  }
9616  {
9617  Py_DECREF( tmp7 );
9618  }
9619  {
9620  Py_DECREF( tmp10 );
9621  }
9622  {
9623  Py_DECREF( tmp12 );
9624  }
9625  return NULL;
9626 }
9627 
9628 
9629 SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9630  PyObject *resultobj = 0;
9631  int *arg1 = (int *) 0 ;
9632  char **arg2 = (char **) 0 ;
9633  PLINT arg3 ;
9634  int tmp1 ;
9635  int val3 ;
9636  int ecode3 = 0 ;
9637  PyObject * obj0 = 0 ;
9638  PyObject * obj1 = 0 ;
9639  PLINT result;
9640 
9641  if (!PyArg_ParseTuple(args,(char *)"OO:plparseopts",&obj0,&obj1)) SWIG_fail;
9642  {
9643  int i;
9644  if ( !PyList_Check( obj0 ) )
9645  {
9646  PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9647  return NULL;
9648  }
9649  tmp1 = PyList_Size( obj0 );
9650  arg1 = &tmp1;
9651  arg2 = (char **) malloc( ( tmp1 + 1 ) * sizeof ( char * ) );
9652  for ( i = 0; i < tmp1; i++ )
9653  {
9654  PyObject *s = PyList_GetItem( obj0, i );
9655  if ( !PyString_Check( s ) )
9656  {
9657  free( arg2 );
9658  PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9659  return NULL;
9660  }
9661  arg2[i] = PyString_AsString( s );
9662  }
9663  arg2[i] = 0;
9664  }
9665  ecode3 = SWIG_AsVal_int(obj1, &val3);
9666  if (!SWIG_IsOK(ecode3)) {
9667  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9668  }
9669  arg3 = (PLINT)(val3);
9670  result = (PLINT)plparseopts(arg1,(char const **)arg2,arg3);
9671  resultobj = SWIG_From_int((int)(result));
9672  {
9673  if ( arg2 )
9674  free( arg2 );
9675  }
9676  return resultobj;
9677 fail:
9678  {
9679  if ( arg2 )
9680  free( arg2 );
9681  }
9682  return NULL;
9683 }
9684 
9685 
9686 SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9687  PyObject *resultobj = 0;
9688  PLINT arg1 ;
9689  PLINT *arg2 = (PLINT *) 0 ;
9690  PLINT *arg3 = (PLINT *) 0 ;
9691  PyArrayObject *tmp1 ;
9692  PyArrayObject *tmp3 ;
9693  PyObject * obj0 = 0 ;
9694  PyObject * obj1 = 0 ;
9695 
9696  if (!PyArg_ParseTuple(args,(char *)"OO:plpat",&obj0,&obj1)) SWIG_fail;
9697  {
9698  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
9699  if ( tmp1 == NULL )
9700  return NULL;
9701  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9702  arg2 = (PLINT *) PyArray_DATA( tmp1 );
9703  }
9704  {
9705  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
9706  if ( tmp3 == NULL )
9707  return NULL;
9708  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9709  {
9710  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9711  return NULL;
9712  }
9713  arg3 = (PLINT *) PyArray_DATA( tmp3 );
9714  }
9715  plpat(arg1,(int const *)arg2,(int const *)arg3);
9716  resultobj = SWIG_Py_Void();
9717  {
9718  Py_DECREF( tmp1 );
9719  }
9720  {
9721  Py_DECREF( tmp3 );
9722  }
9723  return resultobj;
9724 fail:
9725  {
9726  Py_DECREF( tmp1 );
9727  }
9728  {
9729  Py_DECREF( tmp3 );
9730  }
9731  return NULL;
9732 }
9733 
9734 
9735 SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9736  PyObject *resultobj = 0;
9737  PLINT arg1 ;
9738  PLFLT *arg2 = (PLFLT *) 0 ;
9739  PLFLT *arg3 = (PLFLT *) 0 ;
9740  PLINT arg4 ;
9741  PyArrayObject *tmp1 ;
9742  PyArrayObject *tmp3 ;
9743  int val4 ;
9744  int ecode4 = 0 ;
9745  PyObject * obj0 = 0 ;
9746  PyObject * obj1 = 0 ;
9747  PyObject * obj2 = 0 ;
9748 
9749  if (!PyArg_ParseTuple(args,(char *)"OOO:plpoin",&obj0,&obj1,&obj2)) SWIG_fail;
9750  {
9751  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9752  if ( tmp1 == NULL )
9753  return NULL;
9754  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9755  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9756  }
9757  {
9758  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9759  if ( tmp3 == NULL )
9760  return NULL;
9761  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9762  {
9763  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9764  return NULL;
9765  }
9766  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9767  }
9768  ecode4 = SWIG_AsVal_int(obj2, &val4);
9769  if (!SWIG_IsOK(ecode4)) {
9770  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
9771  }
9772  arg4 = (PLINT)(val4);
9773  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
9774  resultobj = SWIG_Py_Void();
9775  {
9776  Py_DECREF( tmp1 );
9777  }
9778  {
9779  Py_DECREF( tmp3 );
9780  }
9781  return resultobj;
9782 fail:
9783  {
9784  Py_DECREF( tmp1 );
9785  }
9786  {
9787  Py_DECREF( tmp3 );
9788  }
9789  return NULL;
9790 }
9791 
9792 
9793 SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9794  PyObject *resultobj = 0;
9795  PLINT arg1 ;
9796  PLFLT *arg2 = (PLFLT *) 0 ;
9797  PLFLT *arg3 = (PLFLT *) 0 ;
9798  PLFLT *arg4 = (PLFLT *) 0 ;
9799  PLINT arg5 ;
9800  PyArrayObject *tmp1 ;
9801  PyArrayObject *tmp3 ;
9802  PyArrayObject *tmp4 ;
9803  int val5 ;
9804  int ecode5 = 0 ;
9805  PyObject * obj0 = 0 ;
9806  PyObject * obj1 = 0 ;
9807  PyObject * obj2 = 0 ;
9808  PyObject * obj3 = 0 ;
9809 
9810  if (!PyArg_ParseTuple(args,(char *)"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9811  {
9812  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9813  if ( tmp1 == NULL )
9814  return NULL;
9815  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9816  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9817  }
9818  {
9819  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9820  if ( tmp3 == NULL )
9821  return NULL;
9822  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9823  {
9824  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9825  return NULL;
9826  }
9827  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9828  }
9829  {
9830  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
9831  if ( tmp4 == NULL )
9832  return NULL;
9833  if ( PyArray_DIMS( tmp4 )[0] != Alen )
9834  {
9835  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9836  return NULL;
9837  }
9838  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9839  }
9840  ecode5 = SWIG_AsVal_int(obj3, &val5);
9841  if (!SWIG_IsOK(ecode5)) {
9842  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
9843  }
9844  arg5 = (PLINT)(val5);
9845  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
9846  resultobj = SWIG_Py_Void();
9847  {
9848  Py_DECREF( tmp1 );
9849  }
9850  {
9851  Py_DECREF( tmp3 );
9852  }
9853  {
9854  Py_DECREF( tmp4 );
9855  }
9856  return resultobj;
9857 fail:
9858  {
9859  Py_DECREF( tmp1 );
9860  }
9861  {
9862  Py_DECREF( tmp3 );
9863  }
9864  {
9865  Py_DECREF( tmp4 );
9866  }
9867  return NULL;
9868 }
9869 
9870 
9871 SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9872  PyObject *resultobj = 0;
9873  PLINT arg1 ;
9874  PLFLT *arg2 = (PLFLT *) 0 ;
9875  PLFLT *arg3 = (PLFLT *) 0 ;
9876  PLFLT *arg4 = (PLFLT *) 0 ;
9877  PLBOOL *arg5 = (PLBOOL *) 0 ;
9878  PLBOOL arg6 ;
9879  PyArrayObject *tmp1 ;
9880  PyArrayObject *tmp3 ;
9881  PyArrayObject *tmp4 ;
9882  PyArrayObject *tmp5 ;
9883  int val6 ;
9884  int ecode6 = 0 ;
9885  PyObject * obj0 = 0 ;
9886  PyObject * obj1 = 0 ;
9887  PyObject * obj2 = 0 ;
9888  PyObject * obj3 = 0 ;
9889  PyObject * obj4 = 0 ;
9890 
9891  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9892  {
9893  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9894  if ( tmp1 == NULL )
9895  return NULL;
9896  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9897  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9898  }
9899  {
9900  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9901  if ( tmp3 == NULL )
9902  return NULL;
9903  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9904  {
9905  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9906  return NULL;
9907  }
9908  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9909  }
9910  {
9911  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
9912  if ( tmp4 == NULL )
9913  return NULL;
9914  if ( PyArray_DIMS( tmp4 )[0] != Alen )
9915  {
9916  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9917  return NULL;
9918  }
9919  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9920  }
9921  {
9922  tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj3, NPY_PLINT, 1, 1 );
9923  if ( tmp5 == NULL )
9924  return NULL;
9925  if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
9926  {
9927  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
9928  return NULL;
9929  }
9930  arg5 = (PLINT *) PyArray_DATA( tmp5 );
9931  }
9932  ecode6 = SWIG_AsVal_int(obj4, &val6);
9933  if (!SWIG_IsOK(ecode6)) {
9934  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
9935  }
9936  arg6 = (PLBOOL)(val6);
9937  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
9938  resultobj = SWIG_Py_Void();
9939  {
9940  Py_DECREF( tmp1 );
9941  }
9942  {
9943  Py_DECREF( tmp3 );
9944  }
9945  {
9946  Py_DECREF( tmp4 );
9947  }
9948  {
9949  Py_DECREF( tmp5 );
9950  }
9951  return resultobj;
9952 fail:
9953  {
9954  Py_DECREF( tmp1 );
9955  }
9956  {
9957  Py_DECREF( tmp3 );
9958  }
9959  {
9960  Py_DECREF( tmp4 );
9961  }
9962  {
9963  Py_DECREF( tmp5 );
9964  }
9965  return NULL;
9966 }
9967 
9968 
9969 SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9970  PyObject *resultobj = 0;
9971  PLINT arg1 ;
9972  PLINT arg2 ;
9973  int val1 ;
9974  int ecode1 = 0 ;
9975  int val2 ;
9976  int ecode2 = 0 ;
9977  PyObject * obj0 = 0 ;
9978  PyObject * obj1 = 0 ;
9979 
9980  if (!PyArg_ParseTuple(args,(char *)"OO:plprec",&obj0,&obj1)) SWIG_fail;
9981  ecode1 = SWIG_AsVal_int(obj0, &val1);
9982  if (!SWIG_IsOK(ecode1)) {
9983  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
9984  }
9985  arg1 = (PLINT)(val1);
9986  ecode2 = SWIG_AsVal_int(obj1, &val2);
9987  if (!SWIG_IsOK(ecode2)) {
9988  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
9989  }
9990  arg2 = (PLINT)(val2);
9991  plprec(arg1,arg2);
9992  resultobj = SWIG_Py_Void();
9993  return resultobj;
9994 fail:
9995  return NULL;
9996 }
9997 
9998 
9999 SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10000  PyObject *resultobj = 0;
10001  PLINT arg1 ;
10002  int val1 ;
10003  int ecode1 = 0 ;
10004  PyObject * obj0 = 0 ;
10005 
10006  if (!PyArg_ParseTuple(args,(char *)"O:plpsty",&obj0)) SWIG_fail;
10007  ecode1 = SWIG_AsVal_int(obj0, &val1);
10008  if (!SWIG_IsOK(ecode1)) {
10009  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10010  }
10011  arg1 = (PLINT)(val1);
10012  plpsty(arg1);
10013  resultobj = SWIG_Py_Void();
10014  return resultobj;
10015 fail:
10016  return NULL;
10017 }
10018 
10019 
10020 SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10021  PyObject *resultobj = 0;
10022  PLFLT arg1 ;
10023  PLFLT arg2 ;
10024  PLFLT arg3 ;
10025  PLFLT arg4 ;
10026  PLFLT arg5 ;
10027  char *arg6 = (char *) 0 ;
10028  double val1 ;
10029  int ecode1 = 0 ;
10030  double val2 ;
10031  int ecode2 = 0 ;
10032  double val3 ;
10033  int ecode3 = 0 ;
10034  double val4 ;
10035  int ecode4 = 0 ;
10036  double val5 ;
10037  int ecode5 = 0 ;
10038  int res6 ;
10039  char *buf6 = 0 ;
10040  int alloc6 = 0 ;
10041  PyObject * obj0 = 0 ;
10042  PyObject * obj1 = 0 ;
10043  PyObject * obj2 = 0 ;
10044  PyObject * obj3 = 0 ;
10045  PyObject * obj4 = 0 ;
10046  PyObject * obj5 = 0 ;
10047 
10048  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10049  ecode1 = SWIG_AsVal_double(obj0, &val1);
10050  if (!SWIG_IsOK(ecode1)) {
10051  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10052  }
10053  arg1 = (PLFLT)(val1);
10054  ecode2 = SWIG_AsVal_double(obj1, &val2);
10055  if (!SWIG_IsOK(ecode2)) {
10056  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10057  }
10058  arg2 = (PLFLT)(val2);
10059  ecode3 = SWIG_AsVal_double(obj2, &val3);
10060  if (!SWIG_IsOK(ecode3)) {
10061  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10062  }
10063  arg3 = (PLFLT)(val3);
10064  ecode4 = SWIG_AsVal_double(obj3, &val4);
10065  if (!SWIG_IsOK(ecode4)) {
10066  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10067  }
10068  arg4 = (PLFLT)(val4);
10069  ecode5 = SWIG_AsVal_double(obj4, &val5);
10070  if (!SWIG_IsOK(ecode5)) {
10071  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10072  }
10073  arg5 = (PLFLT)(val5);
10074  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
10075  if (!SWIG_IsOK(res6)) {
10076  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10077  }
10078  arg6 = (char *)(buf6);
10079  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10080  resultobj = SWIG_Py_Void();
10081  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10082  return resultobj;
10083 fail:
10084  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10085  return NULL;
10086 }
10087 
10088 
10089 SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10090  PyObject *resultobj = 0;
10091  PLFLT arg1 ;
10092  PLFLT arg2 ;
10093  PLFLT arg3 ;
10094  PLFLT arg4 ;
10095  PLFLT arg5 ;
10096  PLFLT arg6 ;
10097  PLFLT arg7 ;
10098  PLFLT arg8 ;
10099  PLFLT arg9 ;
10100  PLFLT arg10 ;
10101  char *arg11 = (char *) 0 ;
10102  double val1 ;
10103  int ecode1 = 0 ;
10104  double val2 ;
10105  int ecode2 = 0 ;
10106  double val3 ;
10107  int ecode3 = 0 ;
10108  double val4 ;
10109  int ecode4 = 0 ;
10110  double val5 ;
10111  int ecode5 = 0 ;
10112  double val6 ;
10113  int ecode6 = 0 ;
10114  double val7 ;
10115  int ecode7 = 0 ;
10116  double val8 ;
10117  int ecode8 = 0 ;
10118  double val9 ;
10119  int ecode9 = 0 ;
10120  double val10 ;
10121  int ecode10 = 0 ;
10122  int res11 ;
10123  char *buf11 = 0 ;
10124  int alloc11 = 0 ;
10125  PyObject * obj0 = 0 ;
10126  PyObject * obj1 = 0 ;
10127  PyObject * obj2 = 0 ;
10128  PyObject * obj3 = 0 ;
10129  PyObject * obj4 = 0 ;
10130  PyObject * obj5 = 0 ;
10131  PyObject * obj6 = 0 ;
10132  PyObject * obj7 = 0 ;
10133  PyObject * obj8 = 0 ;
10134  PyObject * obj9 = 0 ;
10135  PyObject * obj10 = 0 ;
10136 
10137  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
10138  ecode1 = SWIG_AsVal_double(obj0, &val1);
10139  if (!SWIG_IsOK(ecode1)) {
10140  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10141  }
10142  arg1 = (PLFLT)(val1);
10143  ecode2 = SWIG_AsVal_double(obj1, &val2);
10144  if (!SWIG_IsOK(ecode2)) {
10145  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10146  }
10147  arg2 = (PLFLT)(val2);
10148  ecode3 = SWIG_AsVal_double(obj2, &val3);
10149  if (!SWIG_IsOK(ecode3)) {
10150  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10151  }
10152  arg3 = (PLFLT)(val3);
10153  ecode4 = SWIG_AsVal_double(obj3, &val4);
10154  if (!SWIG_IsOK(ecode4)) {
10155  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10156  }
10157  arg4 = (PLFLT)(val4);
10158  ecode5 = SWIG_AsVal_double(obj4, &val5);
10159  if (!SWIG_IsOK(ecode5)) {
10160  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10161  }
10162  arg5 = (PLFLT)(val5);
10163  ecode6 = SWIG_AsVal_double(obj5, &val6);
10164  if (!SWIG_IsOK(ecode6)) {
10165  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10166  }
10167  arg6 = (PLFLT)(val6);
10168  ecode7 = SWIG_AsVal_double(obj6, &val7);
10169  if (!SWIG_IsOK(ecode7)) {
10170  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10171  }
10172  arg7 = (PLFLT)(val7);
10173  ecode8 = SWIG_AsVal_double(obj7, &val8);
10174  if (!SWIG_IsOK(ecode8)) {
10175  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10176  }
10177  arg8 = (PLFLT)(val8);
10178  ecode9 = SWIG_AsVal_double(obj8, &val9);
10179  if (!SWIG_IsOK(ecode9)) {
10180  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10181  }
10182  arg9 = (PLFLT)(val9);
10183  ecode10 = SWIG_AsVal_double(obj9, &val10);
10184  if (!SWIG_IsOK(ecode10)) {
10185  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10186  }
10187  arg10 = (PLFLT)(val10);
10188  res11 = SWIG_AsCharPtrAndSize(obj10, &buf11, NULL, &alloc11);
10189  if (!SWIG_IsOK(res11)) {
10190  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10191  }
10192  arg11 = (char *)(buf11);
10193  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10194  resultobj = SWIG_Py_Void();
10195  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10196  return resultobj;
10197 fail:
10198  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10199  return NULL;
10200 }
10201 
10202 
10203 SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10204  PyObject *resultobj = 0;
10205  PLFLT result;
10206 
10207  if (!PyArg_ParseTuple(args,(char *)":plrandd")) SWIG_fail;
10208  result = (PLFLT)plrandd();
10209  resultobj = SWIG_From_double((double)(result));
10210  return resultobj;
10211 fail:
10212  return NULL;
10213 }
10214 
10215 
10216 SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10217  PyObject *resultobj = 0;
10218 
10219  if (!PyArg_ParseTuple(args,(char *)":plreplot")) SWIG_fail;
10220  plreplot();
10221  resultobj = SWIG_Py_Void();
10222  return resultobj;
10223 fail:
10224  return NULL;
10225 }
10226 
10227 
10228 SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10229  PyObject *resultobj = 0;
10230  PLFLT arg1 ;
10231  PLFLT arg2 ;
10232  PLFLT arg3 ;
10233  PLFLT *arg4 = (PLFLT *) 0 ;
10234  PLFLT *arg5 = (PLFLT *) 0 ;
10235  PLFLT *arg6 = (PLFLT *) 0 ;
10236  double val1 ;
10237  int ecode1 = 0 ;
10238  double val2 ;
10239  int ecode2 = 0 ;
10240  double val3 ;
10241  int ecode3 = 0 ;
10242  PLFLT temp4 ;
10243  int res4 = SWIG_TMPOBJ ;
10244  PLFLT temp5 ;
10245  int res5 = SWIG_TMPOBJ ;
10246  PLFLT temp6 ;
10247  int res6 = SWIG_TMPOBJ ;
10248  PyObject * obj0 = 0 ;
10249  PyObject * obj1 = 0 ;
10250  PyObject * obj2 = 0 ;
10251 
10252  arg4 = &temp4;
10253  arg5 = &temp5;
10254  arg6 = &temp6;
10255  if (!PyArg_ParseTuple(args,(char *)"OOO:plrgbhls",&obj0,&obj1,&obj2)) SWIG_fail;
10256  ecode1 = SWIG_AsVal_double(obj0, &val1);
10257  if (!SWIG_IsOK(ecode1)) {
10258  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10259  }
10260  arg1 = (PLFLT)(val1);
10261  ecode2 = SWIG_AsVal_double(obj1, &val2);
10262  if (!SWIG_IsOK(ecode2)) {
10263  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10264  }
10265  arg2 = (PLFLT)(val2);
10266  ecode3 = SWIG_AsVal_double(obj2, &val3);
10267  if (!SWIG_IsOK(ecode3)) {
10268  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10269  }
10270  arg3 = (PLFLT)(val3);
10271  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10272  resultobj = SWIG_Py_Void();
10273  if (SWIG_IsTmpObj(res4)) {
10274  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
10275  } else {
10276  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10277  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
10278  }
10279  if (SWIG_IsTmpObj(res5)) {
10280  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
10281  } else {
10282  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10283  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10284  }
10285  if (SWIG_IsTmpObj(res6)) {
10286  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10287  } else {
10288  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10289  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10290  }
10291  return resultobj;
10292 fail:
10293  return NULL;
10294 }
10295 
10296 
10297 SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10298  PyObject *resultobj = 0;
10299  PLFLT arg1 ;
10300  PLFLT arg2 ;
10301  double val1 ;
10302  int ecode1 = 0 ;
10303  double val2 ;
10304  int ecode2 = 0 ;
10305  PyObject * obj0 = 0 ;
10306  PyObject * obj1 = 0 ;
10307 
10308  if (!PyArg_ParseTuple(args,(char *)"OO:plschr",&obj0,&obj1)) SWIG_fail;
10309  ecode1 = SWIG_AsVal_double(obj0, &val1);
10310  if (!SWIG_IsOK(ecode1)) {
10311  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10312  }
10313  arg1 = (PLFLT)(val1);
10314  ecode2 = SWIG_AsVal_double(obj1, &val2);
10315  if (!SWIG_IsOK(ecode2)) {
10316  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10317  }
10318  arg2 = (PLFLT)(val2);
10319  plschr(arg1,arg2);
10320  resultobj = SWIG_Py_Void();
10321  return resultobj;
10322 fail:
10323  return NULL;
10324 }
10325 
10326 
10327 SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10328  PyObject *resultobj = 0;
10329  PLINT *arg1 = (PLINT *) 0 ;
10330  PLINT *arg2 = (PLINT *) 0 ;
10331  PLINT *arg3 = (PLINT *) 0 ;
10332  PLINT arg4 ;
10333  PyArrayObject *tmp1 ;
10334  PyArrayObject *tmp2 ;
10335  PyArrayObject *tmp3 ;
10336  PyObject * obj0 = 0 ;
10337  PyObject * obj1 = 0 ;
10338  PyObject * obj2 = 0 ;
10339 
10340  if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap0",&obj0,&obj1,&obj2)) SWIG_fail;
10341  {
10342  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10343  if ( tmp1 == NULL )
10344  return NULL;
10345  Alen = PyArray_DIMS( tmp1 )[0];
10346  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10347  }
10348  {
10349  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10350  if ( tmp2 == NULL )
10351  return NULL;
10352  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10353  {
10354  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10355  return NULL;
10356  }
10357  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10358  }
10359  {
10360  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10361  if ( tmp3 == NULL )
10362  return NULL;
10363  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10364  {
10365  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10366  return NULL;
10367  }
10368  arg4 = PyArray_DIMS( tmp3 )[0];
10369  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10370  }
10371  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10372  resultobj = SWIG_Py_Void();
10373  {
10374  Py_DECREF( tmp1 );
10375  }
10376  {
10377  Py_DECREF( tmp2 );
10378  }
10379  {
10380  Py_DECREF( tmp3 );
10381  }
10382  return resultobj;
10383 fail:
10384  {
10385  Py_DECREF( tmp1 );
10386  }
10387  {
10388  Py_DECREF( tmp2 );
10389  }
10390  {
10391  Py_DECREF( tmp3 );
10392  }
10393  return NULL;
10394 }
10395 
10396 
10397 SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10398  PyObject *resultobj = 0;
10399  PLINT *arg1 = (PLINT *) 0 ;
10400  PLINT *arg2 = (PLINT *) 0 ;
10401  PLINT *arg3 = (PLINT *) 0 ;
10402  PLFLT *arg4 = (PLFLT *) 0 ;
10403  PLINT arg5 ;
10404  PyArrayObject *tmp1 ;
10405  PyArrayObject *tmp2 ;
10406  PyArrayObject *tmp3 ;
10407  PyArrayObject *tmp4 ;
10408  PyObject * obj0 = 0 ;
10409  PyObject * obj1 = 0 ;
10410  PyObject * obj2 = 0 ;
10411  PyObject * obj3 = 0 ;
10412 
10413  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10414  {
10415  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10416  if ( tmp1 == NULL )
10417  return NULL;
10418  Alen = PyArray_DIMS( tmp1 )[0];
10419  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10420  }
10421  {
10422  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10423  if ( tmp2 == NULL )
10424  return NULL;
10425  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10426  {
10427  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10428  return NULL;
10429  }
10430  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10431  }
10432  {
10433  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10434  if ( tmp3 == NULL )
10435  return NULL;
10436  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10437  {
10438  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10439  return NULL;
10440  }
10441  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10442  }
10443  {
10444  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10445  if ( tmp4 == NULL )
10446  return NULL;
10447  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10448  {
10449  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10450  return NULL;
10451  }
10452  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10453  arg5 = PyArray_DIMS( tmp4 )[0];
10454  }
10455  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10456  resultobj = SWIG_Py_Void();
10457  {
10458  Py_DECREF( tmp1 );
10459  }
10460  {
10461  Py_DECREF( tmp2 );
10462  }
10463  {
10464  Py_DECREF( tmp3 );
10465  }
10466  {
10467  Py_DECREF( tmp4 );
10468  }
10469  return resultobj;
10470 fail:
10471  {
10472  Py_DECREF( tmp1 );
10473  }
10474  {
10475  Py_DECREF( tmp2 );
10476  }
10477  {
10478  Py_DECREF( tmp3 );
10479  }
10480  {
10481  Py_DECREF( tmp4 );
10482  }
10483  return NULL;
10484 }
10485 
10486 
10487 SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10488  PyObject *resultobj = 0;
10489  PLINT arg1 ;
10490  int val1 ;
10491  int ecode1 = 0 ;
10492  PyObject * obj0 = 0 ;
10493 
10494  if (!PyArg_ParseTuple(args,(char *)"O:plscmap0n",&obj0)) SWIG_fail;
10495  ecode1 = SWIG_AsVal_int(obj0, &val1);
10496  if (!SWIG_IsOK(ecode1)) {
10497  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10498  }
10499  arg1 = (PLINT)(val1);
10500  plscmap0n(arg1);
10501  resultobj = SWIG_Py_Void();
10502  return resultobj;
10503 fail:
10504  return NULL;
10505 }
10506 
10507 
10508 SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10509  PyObject *resultobj = 0;
10510  PLINT *arg1 = (PLINT *) 0 ;
10511  PLINT *arg2 = (PLINT *) 0 ;
10512  PLINT *arg3 = (PLINT *) 0 ;
10513  PLINT arg4 ;
10514  PyArrayObject *tmp1 ;
10515  PyArrayObject *tmp2 ;
10516  PyArrayObject *tmp3 ;
10517  PyObject * obj0 = 0 ;
10518  PyObject * obj1 = 0 ;
10519  PyObject * obj2 = 0 ;
10520 
10521  if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap1",&obj0,&obj1,&obj2)) SWIG_fail;
10522  {
10523  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10524  if ( tmp1 == NULL )
10525  return NULL;
10526  Alen = PyArray_DIMS( tmp1 )[0];
10527  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10528  }
10529  {
10530  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10531  if ( tmp2 == NULL )
10532  return NULL;
10533  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10534  {
10535  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10536  return NULL;
10537  }
10538  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10539  }
10540  {
10541  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10542  if ( tmp3 == NULL )
10543  return NULL;
10544  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10545  {
10546  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10547  return NULL;
10548  }
10549  arg4 = PyArray_DIMS( tmp3 )[0];
10550  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10551  }
10552  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10553  resultobj = SWIG_Py_Void();
10554  {
10555  Py_DECREF( tmp1 );
10556  }
10557  {
10558  Py_DECREF( tmp2 );
10559  }
10560  {
10561  Py_DECREF( tmp3 );
10562  }
10563  return resultobj;
10564 fail:
10565  {
10566  Py_DECREF( tmp1 );
10567  }
10568  {
10569  Py_DECREF( tmp2 );
10570  }
10571  {
10572  Py_DECREF( tmp3 );
10573  }
10574  return NULL;
10575 }
10576 
10577 
10578 SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10579  PyObject *resultobj = 0;
10580  PLINT *arg1 = (PLINT *) 0 ;
10581  PLINT *arg2 = (PLINT *) 0 ;
10582  PLINT *arg3 = (PLINT *) 0 ;
10583  PLFLT *arg4 = (PLFLT *) 0 ;
10584  PLINT arg5 ;
10585  PyArrayObject *tmp1 ;
10586  PyArrayObject *tmp2 ;
10587  PyArrayObject *tmp3 ;
10588  PyArrayObject *tmp4 ;
10589  PyObject * obj0 = 0 ;
10590  PyObject * obj1 = 0 ;
10591  PyObject * obj2 = 0 ;
10592  PyObject * obj3 = 0 ;
10593 
10594  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10595  {
10596  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10597  if ( tmp1 == NULL )
10598  return NULL;
10599  Alen = PyArray_DIMS( tmp1 )[0];
10600  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10601  }
10602  {
10603  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10604  if ( tmp2 == NULL )
10605  return NULL;
10606  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10607  {
10608  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10609  return NULL;
10610  }
10611  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10612  }
10613  {
10614  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10615  if ( tmp3 == NULL )
10616  return NULL;
10617  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10618  {
10619  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10620  return NULL;
10621  }
10622  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10623  }
10624  {
10625  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10626  if ( tmp4 == NULL )
10627  return NULL;
10628  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10629  {
10630  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10631  return NULL;
10632  }
10633  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10634  arg5 = PyArray_DIMS( tmp4 )[0];
10635  }
10636  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10637  resultobj = SWIG_Py_Void();
10638  {
10639  Py_DECREF( tmp1 );
10640  }
10641  {
10642  Py_DECREF( tmp2 );
10643  }
10644  {
10645  Py_DECREF( tmp3 );
10646  }
10647  {
10648  Py_DECREF( tmp4 );
10649  }
10650  return resultobj;
10651 fail:
10652  {
10653  Py_DECREF( tmp1 );
10654  }
10655  {
10656  Py_DECREF( tmp2 );
10657  }
10658  {
10659  Py_DECREF( tmp3 );
10660  }
10661  {
10662  Py_DECREF( tmp4 );
10663  }
10664  return NULL;
10665 }
10666 
10667 
10668 SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10669  PyObject *resultobj = 0;
10670  PLBOOL arg1 ;
10671  PLINT arg2 ;
10672  PLFLT *arg3 = (PLFLT *) 0 ;
10673  PLFLT *arg4 = (PLFLT *) 0 ;
10674  PLFLT *arg5 = (PLFLT *) 0 ;
10675  PLFLT *arg6 = (PLFLT *) 0 ;
10676  PLBOOL *arg7 = (PLBOOL *) 0 ;
10677  int val1 ;
10678  int ecode1 = 0 ;
10679  PyArrayObject *tmp2 ;
10680  PyArrayObject *tmp4 ;
10681  PyArrayObject *tmp5 ;
10682  PyArrayObject *tmp6 ;
10683  PyArrayObject *tmp7 ;
10684  PyObject * obj0 = 0 ;
10685  PyObject * obj1 = 0 ;
10686  PyObject * obj2 = 0 ;
10687  PyObject * obj3 = 0 ;
10688  PyObject * obj4 = 0 ;
10689  PyObject * obj5 = 0 ;
10690 
10691  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10692  ecode1 = SWIG_AsVal_int(obj0, &val1);
10693  if (!SWIG_IsOK(ecode1)) {
10694  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10695  }
10696  arg1 = (PLBOOL)(val1);
10697  {
10698  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10699  if ( tmp2 == NULL )
10700  return NULL;
10701  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10702  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10703  }
10704  {
10705  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10706  if ( tmp4 == NULL )
10707  return NULL;
10708  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10709  {
10710  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10711  return NULL;
10712  }
10713  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10714  }
10715  {
10716  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10717  if ( tmp5 == NULL )
10718  return NULL;
10719  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10720  {
10721  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10722  return NULL;
10723  }
10724  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10725  }
10726  {
10727  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
10728  if ( tmp6 == NULL )
10729  return NULL;
10730  if ( PyArray_DIMS( tmp6 )[0] != Alen )
10731  {
10732  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10733  return NULL;
10734  }
10735  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10736  }
10737  {
10738  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj5, NPY_PLINT, 1, 1 );
10739  if ( tmp7 == NULL )
10740  return NULL;
10741  if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10742  {
10743  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10744  return NULL;
10745  }
10746  arg7 = (PLINT *) PyArray_DATA( tmp7 );
10747  }
10748  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
10749  resultobj = SWIG_Py_Void();
10750  {
10751  Py_DECREF( tmp2 );
10752  }
10753  {
10754  Py_DECREF( tmp4 );
10755  }
10756  {
10757  Py_DECREF( tmp5 );
10758  }
10759  {
10760  Py_DECREF( tmp6 );
10761  }
10762  {
10763  Py_DECREF( tmp7 );
10764  }
10765  return resultobj;
10766 fail:
10767  {
10768  Py_DECREF( tmp2 );
10769  }
10770  {
10771  Py_DECREF( tmp4 );
10772  }
10773  {
10774  Py_DECREF( tmp5 );
10775  }
10776  {
10777  Py_DECREF( tmp6 );
10778  }
10779  {
10780  Py_DECREF( tmp7 );
10781  }
10782  return NULL;
10783 }
10784 
10785 
10786 SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10787  PyObject *resultobj = 0;
10788  PLBOOL arg1 ;
10789  PLINT arg2 ;
10790  PLFLT *arg3 = (PLFLT *) 0 ;
10791  PLFLT *arg4 = (PLFLT *) 0 ;
10792  PLFLT *arg5 = (PLFLT *) 0 ;
10793  PLFLT *arg6 = (PLFLT *) 0 ;
10794  PLFLT *arg7 = (PLFLT *) 0 ;
10795  PLBOOL *arg8 = (PLBOOL *) 0 ;
10796  int val1 ;
10797  int ecode1 = 0 ;
10798  PyArrayObject *tmp2 ;
10799  PyArrayObject *tmp4 ;
10800  PyArrayObject *tmp5 ;
10801  PyArrayObject *tmp6 ;
10802  PyArrayObject *tmp7 ;
10803  PyArrayObject *tmp8 ;
10804  PyObject * obj0 = 0 ;
10805  PyObject * obj1 = 0 ;
10806  PyObject * obj2 = 0 ;
10807  PyObject * obj3 = 0 ;
10808  PyObject * obj4 = 0 ;
10809  PyObject * obj5 = 0 ;
10810  PyObject * obj6 = 0 ;
10811 
10812  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10813  ecode1 = SWIG_AsVal_int(obj0, &val1);
10814  if (!SWIG_IsOK(ecode1)) {
10815  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
10816  }
10817  arg1 = (PLBOOL)(val1);
10818  {
10819  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10820  if ( tmp2 == NULL )
10821  return NULL;
10822  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10823  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10824  }
10825  {
10826  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10827  if ( tmp4 == NULL )
10828  return NULL;
10829  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10830  {
10831  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10832  return NULL;
10833  }
10834  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10835  }
10836  {
10837  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10838  if ( tmp5 == NULL )
10839  return NULL;
10840  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10841  {
10842  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10843  return NULL;
10844  }
10845  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10846  }
10847  {
10848  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
10849  if ( tmp6 == NULL )
10850  return NULL;
10851  if ( PyArray_DIMS( tmp6 )[0] != Alen )
10852  {
10853  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10854  return NULL;
10855  }
10856  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10857  }
10858  {
10859  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
10860  if ( tmp7 == NULL )
10861  return NULL;
10862  if ( PyArray_DIMS( tmp7 )[0] != Alen )
10863  {
10864  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10865  return NULL;
10866  }
10867  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
10868  }
10869  {
10870  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
10871  if ( tmp8 == NULL )
10872  return NULL;
10873  if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
10874  {
10875  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10876  return NULL;
10877  }
10878  arg8 = (PLINT *) PyArray_DATA( tmp8 );
10879  }
10880  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
10881  resultobj = SWIG_Py_Void();
10882  {
10883  Py_DECREF( tmp2 );
10884  }
10885  {
10886  Py_DECREF( tmp4 );
10887  }
10888  {
10889  Py_DECREF( tmp5 );
10890  }
10891  {
10892  Py_DECREF( tmp6 );
10893  }
10894  {
10895  Py_DECREF( tmp7 );
10896  }
10897  {
10898  Py_DECREF( tmp8 );
10899  }
10900  return resultobj;
10901 fail:
10902  {
10903  Py_DECREF( tmp2 );
10904  }
10905  {
10906  Py_DECREF( tmp4 );
10907  }
10908  {
10909  Py_DECREF( tmp5 );
10910  }
10911  {
10912  Py_DECREF( tmp6 );
10913  }
10914  {
10915  Py_DECREF( tmp7 );
10916  }
10917  {
10918  Py_DECREF( tmp8 );
10919  }
10920  return NULL;
10921 }
10922 
10923 
10924 SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10925  PyObject *resultobj = 0;
10926  PLINT arg1 ;
10927  int val1 ;
10928  int ecode1 = 0 ;
10929  PyObject * obj0 = 0 ;
10930 
10931  if (!PyArg_ParseTuple(args,(char *)"O:plscmap1n",&obj0)) SWIG_fail;
10932  ecode1 = SWIG_AsVal_int(obj0, &val1);
10933  if (!SWIG_IsOK(ecode1)) {
10934  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
10935  }
10936  arg1 = (PLINT)(val1);
10937  plscmap1n(arg1);
10938  resultobj = SWIG_Py_Void();
10939  return resultobj;
10940 fail:
10941  return NULL;
10942 }
10943 
10944 
10945 SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10946  PyObject *resultobj = 0;
10947  PLFLT arg1 ;
10948  PLFLT arg2 ;
10949  double val1 ;
10950  int ecode1 = 0 ;
10951  double val2 ;
10952  int ecode2 = 0 ;
10953  PyObject * obj0 = 0 ;
10954  PyObject * obj1 = 0 ;
10955 
10956  if (!PyArg_ParseTuple(args,(char *)"OO:plscmap1_range",&obj0,&obj1)) SWIG_fail;
10957  ecode1 = SWIG_AsVal_double(obj0, &val1);
10958  if (!SWIG_IsOK(ecode1)) {
10959  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
10960  }
10961  arg1 = (PLFLT)(val1);
10962  ecode2 = SWIG_AsVal_double(obj1, &val2);
10963  if (!SWIG_IsOK(ecode2)) {
10964  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
10965  }
10966  arg2 = (PLFLT)(val2);
10967  plscmap1_range(arg1,arg2);
10968  resultobj = SWIG_Py_Void();
10969  return resultobj;
10970 fail:
10971  return NULL;
10972 }
10973 
10974 
10975 SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10976  PyObject *resultobj = 0;
10977  PLFLT *arg1 = (PLFLT *) 0 ;
10978  PLFLT *arg2 = (PLFLT *) 0 ;
10979  PLFLT temp1 ;
10980  int res1 = SWIG_TMPOBJ ;
10981  PLFLT temp2 ;
10982  int res2 = SWIG_TMPOBJ ;
10983 
10984  arg1 = &temp1;
10985  arg2 = &temp2;
10986  if (!PyArg_ParseTuple(args,(char *)":plgcmap1_range")) SWIG_fail;
10987  plgcmap1_range(arg1,arg2);
10988  resultobj = SWIG_Py_Void();
10989  if (SWIG_IsTmpObj(res1)) {
10990  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
10991  } else {
10992  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10993  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
10994  }
10995  if (SWIG_IsTmpObj(res2)) {
10996  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
10997  } else {
10998  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10999  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11000  }
11001  return resultobj;
11002 fail:
11003  return NULL;
11004 }
11005 
11006 
11007 SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11008  PyObject *resultobj = 0;
11009  PLINT arg1 ;
11010  PLINT arg2 ;
11011  PLINT arg3 ;
11012  PLINT arg4 ;
11013  int val1 ;
11014  int ecode1 = 0 ;
11015  int val2 ;
11016  int ecode2 = 0 ;
11017  int val3 ;
11018  int ecode3 = 0 ;
11019  int val4 ;
11020  int ecode4 = 0 ;
11021  PyObject * obj0 = 0 ;
11022  PyObject * obj1 = 0 ;
11023  PyObject * obj2 = 0 ;
11024  PyObject * obj3 = 0 ;
11025 
11026  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11027  ecode1 = SWIG_AsVal_int(obj0, &val1);
11028  if (!SWIG_IsOK(ecode1)) {
11029  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11030  }
11031  arg1 = (PLINT)(val1);
11032  ecode2 = SWIG_AsVal_int(obj1, &val2);
11033  if (!SWIG_IsOK(ecode2)) {
11034  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11035  }
11036  arg2 = (PLINT)(val2);
11037  ecode3 = SWIG_AsVal_int(obj2, &val3);
11038  if (!SWIG_IsOK(ecode3)) {
11039  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11040  }
11041  arg3 = (PLINT)(val3);
11042  ecode4 = SWIG_AsVal_int(obj3, &val4);
11043  if (!SWIG_IsOK(ecode4)) {
11044  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11045  }
11046  arg4 = (PLINT)(val4);
11047  plscol0(arg1,arg2,arg3,arg4);
11048  resultobj = SWIG_Py_Void();
11049  return resultobj;
11050 fail:
11051  return NULL;
11052 }
11053 
11054 
11055 SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11056  PyObject *resultobj = 0;
11057  PLINT arg1 ;
11058  PLINT arg2 ;
11059  PLINT arg3 ;
11060  PLINT arg4 ;
11061  PLFLT arg5 ;
11062  int val1 ;
11063  int ecode1 = 0 ;
11064  int val2 ;
11065  int ecode2 = 0 ;
11066  int val3 ;
11067  int ecode3 = 0 ;
11068  int val4 ;
11069  int ecode4 = 0 ;
11070  double val5 ;
11071  int ecode5 = 0 ;
11072  PyObject * obj0 = 0 ;
11073  PyObject * obj1 = 0 ;
11074  PyObject * obj2 = 0 ;
11075  PyObject * obj3 = 0 ;
11076  PyObject * obj4 = 0 ;
11077 
11078  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11079  ecode1 = SWIG_AsVal_int(obj0, &val1);
11080  if (!SWIG_IsOK(ecode1)) {
11081  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11082  }
11083  arg1 = (PLINT)(val1);
11084  ecode2 = SWIG_AsVal_int(obj1, &val2);
11085  if (!SWIG_IsOK(ecode2)) {
11086  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11087  }
11088  arg2 = (PLINT)(val2);
11089  ecode3 = SWIG_AsVal_int(obj2, &val3);
11090  if (!SWIG_IsOK(ecode3)) {
11091  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11092  }
11093  arg3 = (PLINT)(val3);
11094  ecode4 = SWIG_AsVal_int(obj3, &val4);
11095  if (!SWIG_IsOK(ecode4)) {
11096  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11097  }
11098  arg4 = (PLINT)(val4);
11099  ecode5 = SWIG_AsVal_double(obj4, &val5);
11100  if (!SWIG_IsOK(ecode5)) {
11101  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11102  }
11103  arg5 = (PLFLT)(val5);
11104  plscol0a(arg1,arg2,arg3,arg4,arg5);
11105  resultobj = SWIG_Py_Void();
11106  return resultobj;
11107 fail:
11108  return NULL;
11109 }
11110 
11111 
11112 SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11113  PyObject *resultobj = 0;
11114  PLINT arg1 ;
11115  PLINT arg2 ;
11116  PLINT arg3 ;
11117  int val1 ;
11118  int ecode1 = 0 ;
11119  int val2 ;
11120  int ecode2 = 0 ;
11121  int val3 ;
11122  int ecode3 = 0 ;
11123  PyObject * obj0 = 0 ;
11124  PyObject * obj1 = 0 ;
11125  PyObject * obj2 = 0 ;
11126 
11127  if (!PyArg_ParseTuple(args,(char *)"OOO:plscolbg",&obj0,&obj1,&obj2)) SWIG_fail;
11128  ecode1 = SWIG_AsVal_int(obj0, &val1);
11129  if (!SWIG_IsOK(ecode1)) {
11130  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11131  }
11132  arg1 = (PLINT)(val1);
11133  ecode2 = SWIG_AsVal_int(obj1, &val2);
11134  if (!SWIG_IsOK(ecode2)) {
11135  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11136  }
11137  arg2 = (PLINT)(val2);
11138  ecode3 = SWIG_AsVal_int(obj2, &val3);
11139  if (!SWIG_IsOK(ecode3)) {
11140  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11141  }
11142  arg3 = (PLINT)(val3);
11143  plscolbg(arg1,arg2,arg3);
11144  resultobj = SWIG_Py_Void();
11145  return resultobj;
11146 fail:
11147  return NULL;
11148 }
11149 
11150 
11151 SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11152  PyObject *resultobj = 0;
11153  PLINT arg1 ;
11154  PLINT arg2 ;
11155  PLINT arg3 ;
11156  PLFLT arg4 ;
11157  int val1 ;
11158  int ecode1 = 0 ;
11159  int val2 ;
11160  int ecode2 = 0 ;
11161  int val3 ;
11162  int ecode3 = 0 ;
11163  double val4 ;
11164  int ecode4 = 0 ;
11165  PyObject * obj0 = 0 ;
11166  PyObject * obj1 = 0 ;
11167  PyObject * obj2 = 0 ;
11168  PyObject * obj3 = 0 ;
11169 
11170  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11171  ecode1 = SWIG_AsVal_int(obj0, &val1);
11172  if (!SWIG_IsOK(ecode1)) {
11173  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11174  }
11175  arg1 = (PLINT)(val1);
11176  ecode2 = SWIG_AsVal_int(obj1, &val2);
11177  if (!SWIG_IsOK(ecode2)) {
11178  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11179  }
11180  arg2 = (PLINT)(val2);
11181  ecode3 = SWIG_AsVal_int(obj2, &val3);
11182  if (!SWIG_IsOK(ecode3)) {
11183  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11184  }
11185  arg3 = (PLINT)(val3);
11186  ecode4 = SWIG_AsVal_double(obj3, &val4);
11187  if (!SWIG_IsOK(ecode4)) {
11188  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11189  }
11190  arg4 = (PLFLT)(val4);
11191  plscolbga(arg1,arg2,arg3,arg4);
11192  resultobj = SWIG_Py_Void();
11193  return resultobj;
11194 fail:
11195  return NULL;
11196 }
11197 
11198 
11199 SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11200  PyObject *resultobj = 0;
11201  PLINT arg1 ;
11202  int val1 ;
11203  int ecode1 = 0 ;
11204  PyObject * obj0 = 0 ;
11205 
11206  if (!PyArg_ParseTuple(args,(char *)"O:plscolor",&obj0)) SWIG_fail;
11207  ecode1 = SWIG_AsVal_int(obj0, &val1);
11208  if (!SWIG_IsOK(ecode1)) {
11209  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11210  }
11211  arg1 = (PLINT)(val1);
11212  plscolor(arg1);
11213  resultobj = SWIG_Py_Void();
11214  return resultobj;
11215 fail:
11216  return NULL;
11217 }
11218 
11219 
11220 SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11221  PyObject *resultobj = 0;
11222  PLINT arg1 ;
11223  int val1 ;
11224  int ecode1 = 0 ;
11225  PyObject * obj0 = 0 ;
11226 
11227  if (!PyArg_ParseTuple(args,(char *)"O:plscompression",&obj0)) SWIG_fail;
11228  ecode1 = SWIG_AsVal_int(obj0, &val1);
11229  if (!SWIG_IsOK(ecode1)) {
11230  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11231  }
11232  arg1 = (PLINT)(val1);
11233  plscompression(arg1);
11234  resultobj = SWIG_Py_Void();
11235  return resultobj;
11236 fail:
11237  return NULL;
11238 }
11239 
11240 
11241 SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11242  PyObject *resultobj = 0;
11243  char *arg1 = (char *) 0 ;
11244  int res1 ;
11245  char *buf1 = 0 ;
11246  int alloc1 = 0 ;
11247  PyObject * obj0 = 0 ;
11248 
11249  if (!PyArg_ParseTuple(args,(char *)"O:plsdev",&obj0)) SWIG_fail;
11250  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11251  if (!SWIG_IsOK(res1)) {
11252  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11253  }
11254  arg1 = (char *)(buf1);
11255  plsdev((char const *)arg1);
11256  resultobj = SWIG_Py_Void();
11257  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11258  return resultobj;
11259 fail:
11260  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11261  return NULL;
11262 }
11263 
11264 
11265 SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11266  PyObject *resultobj = 0;
11267  PLFLT arg1 ;
11268  PLFLT arg2 ;
11269  PLFLT arg3 ;
11270  PLFLT arg4 ;
11271  double val1 ;
11272  int ecode1 = 0 ;
11273  double val2 ;
11274  int ecode2 = 0 ;
11275  double val3 ;
11276  int ecode3 = 0 ;
11277  double val4 ;
11278  int ecode4 = 0 ;
11279  PyObject * obj0 = 0 ;
11280  PyObject * obj1 = 0 ;
11281  PyObject * obj2 = 0 ;
11282  PyObject * obj3 = 0 ;
11283 
11284  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11285  ecode1 = SWIG_AsVal_double(obj0, &val1);
11286  if (!SWIG_IsOK(ecode1)) {
11287  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11288  }
11289  arg1 = (PLFLT)(val1);
11290  ecode2 = SWIG_AsVal_double(obj1, &val2);
11291  if (!SWIG_IsOK(ecode2)) {
11292  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11293  }
11294  arg2 = (PLFLT)(val2);
11295  ecode3 = SWIG_AsVal_double(obj2, &val3);
11296  if (!SWIG_IsOK(ecode3)) {
11297  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11298  }
11299  arg3 = (PLFLT)(val3);
11300  ecode4 = SWIG_AsVal_double(obj3, &val4);
11301  if (!SWIG_IsOK(ecode4)) {
11302  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11303  }
11304  arg4 = (PLFLT)(val4);
11305  plsdidev(arg1,arg2,arg3,arg4);
11306  resultobj = SWIG_Py_Void();
11307  return resultobj;
11308 fail:
11309  return NULL;
11310 }
11311 
11312 
11313 SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11314  PyObject *resultobj = 0;
11315  PLINT arg1 ;
11316  PLINT arg2 ;
11317  PLINT arg3 ;
11318  PLINT arg4 ;
11319  PLFLT arg5 ;
11320  PLFLT arg6 ;
11321  int val1 ;
11322  int ecode1 = 0 ;
11323  int val2 ;
11324  int ecode2 = 0 ;
11325  int val3 ;
11326  int ecode3 = 0 ;
11327  int val4 ;
11328  int ecode4 = 0 ;
11329  double val5 ;
11330  int ecode5 = 0 ;
11331  double val6 ;
11332  int ecode6 = 0 ;
11333  PyObject * obj0 = 0 ;
11334  PyObject * obj1 = 0 ;
11335  PyObject * obj2 = 0 ;
11336  PyObject * obj3 = 0 ;
11337  PyObject * obj4 = 0 ;
11338  PyObject * obj5 = 0 ;
11339 
11340  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
11341  ecode1 = SWIG_AsVal_int(obj0, &val1);
11342  if (!SWIG_IsOK(ecode1)) {
11343  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11344  }
11345  arg1 = (PLINT)(val1);
11346  ecode2 = SWIG_AsVal_int(obj1, &val2);
11347  if (!SWIG_IsOK(ecode2)) {
11348  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11349  }
11350  arg2 = (PLINT)(val2);
11351  ecode3 = SWIG_AsVal_int(obj2, &val3);
11352  if (!SWIG_IsOK(ecode3)) {
11353  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11354  }
11355  arg3 = (PLINT)(val3);
11356  ecode4 = SWIG_AsVal_int(obj3, &val4);
11357  if (!SWIG_IsOK(ecode4)) {
11358  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11359  }
11360  arg4 = (PLINT)(val4);
11361  ecode5 = SWIG_AsVal_double(obj4, &val5);
11362  if (!SWIG_IsOK(ecode5)) {
11363  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11364  }
11365  arg5 = (PLFLT)(val5);
11366  ecode6 = SWIG_AsVal_double(obj5, &val6);
11367  if (!SWIG_IsOK(ecode6)) {
11368  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11369  }
11370  arg6 = (PLFLT)(val6);
11371  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11372  resultobj = SWIG_Py_Void();
11373  return resultobj;
11374 fail:
11375  return NULL;
11376 }
11377 
11378 
11379 SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11380  PyObject *resultobj = 0;
11381  PLFLT arg1 ;
11382  double val1 ;
11383  int ecode1 = 0 ;
11384  PyObject * obj0 = 0 ;
11385 
11386  if (!PyArg_ParseTuple(args,(char *)"O:plsdiori",&obj0)) SWIG_fail;
11387  ecode1 = SWIG_AsVal_double(obj0, &val1);
11388  if (!SWIG_IsOK(ecode1)) {
11389  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11390  }
11391  arg1 = (PLFLT)(val1);
11392  plsdiori(arg1);
11393  resultobj = SWIG_Py_Void();
11394  return resultobj;
11395 fail:
11396  return NULL;
11397 }
11398 
11399 
11400 SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11401  PyObject *resultobj = 0;
11402  PLFLT arg1 ;
11403  PLFLT arg2 ;
11404  PLFLT arg3 ;
11405  PLFLT arg4 ;
11406  double val1 ;
11407  int ecode1 = 0 ;
11408  double val2 ;
11409  int ecode2 = 0 ;
11410  double val3 ;
11411  int ecode3 = 0 ;
11412  double val4 ;
11413  int ecode4 = 0 ;
11414  PyObject * obj0 = 0 ;
11415  PyObject * obj1 = 0 ;
11416  PyObject * obj2 = 0 ;
11417  PyObject * obj3 = 0 ;
11418 
11419  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11420  ecode1 = SWIG_AsVal_double(obj0, &val1);
11421  if (!SWIG_IsOK(ecode1)) {
11422  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11423  }
11424  arg1 = (PLFLT)(val1);
11425  ecode2 = SWIG_AsVal_double(obj1, &val2);
11426  if (!SWIG_IsOK(ecode2)) {
11427  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11428  }
11429  arg2 = (PLFLT)(val2);
11430  ecode3 = SWIG_AsVal_double(obj2, &val3);
11431  if (!SWIG_IsOK(ecode3)) {
11432  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11433  }
11434  arg3 = (PLFLT)(val3);
11435  ecode4 = SWIG_AsVal_double(obj3, &val4);
11436  if (!SWIG_IsOK(ecode4)) {
11437  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11438  }
11439  arg4 = (PLFLT)(val4);
11440  plsdiplt(arg1,arg2,arg3,arg4);
11441  resultobj = SWIG_Py_Void();
11442  return resultobj;
11443 fail:
11444  return NULL;
11445 }
11446 
11447 
11448 SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11449  PyObject *resultobj = 0;
11450  PLFLT arg1 ;
11451  PLFLT arg2 ;
11452  PLFLT arg3 ;
11453  PLFLT arg4 ;
11454  double val1 ;
11455  int ecode1 = 0 ;
11456  double val2 ;
11457  int ecode2 = 0 ;
11458  double val3 ;
11459  int ecode3 = 0 ;
11460  double val4 ;
11461  int ecode4 = 0 ;
11462  PyObject * obj0 = 0 ;
11463  PyObject * obj1 = 0 ;
11464  PyObject * obj2 = 0 ;
11465  PyObject * obj3 = 0 ;
11466 
11467  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11468  ecode1 = SWIG_AsVal_double(obj0, &val1);
11469  if (!SWIG_IsOK(ecode1)) {
11470  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11471  }
11472  arg1 = (PLFLT)(val1);
11473  ecode2 = SWIG_AsVal_double(obj1, &val2);
11474  if (!SWIG_IsOK(ecode2)) {
11475  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11476  }
11477  arg2 = (PLFLT)(val2);
11478  ecode3 = SWIG_AsVal_double(obj2, &val3);
11479  if (!SWIG_IsOK(ecode3)) {
11480  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11481  }
11482  arg3 = (PLFLT)(val3);
11483  ecode4 = SWIG_AsVal_double(obj3, &val4);
11484  if (!SWIG_IsOK(ecode4)) {
11485  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11486  }
11487  arg4 = (PLFLT)(val4);
11488  plsdiplz(arg1,arg2,arg3,arg4);
11489  resultobj = SWIG_Py_Void();
11490  return resultobj;
11491 fail:
11492  return NULL;
11493 }
11494 
11495 
11496 SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11497  PyObject *resultobj = 0;
11498  unsigned int arg1 ;
11499  unsigned int val1 ;
11500  int ecode1 = 0 ;
11501  PyObject * obj0 = 0 ;
11502 
11503  if (!PyArg_ParseTuple(args,(char *)"O:plseed",&obj0)) SWIG_fail;
11504  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11505  if (!SWIG_IsOK(ecode1)) {
11506  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11507  }
11508  arg1 = (unsigned int)(val1);
11509  plseed(arg1);
11510  resultobj = SWIG_Py_Void();
11511  return resultobj;
11512 fail:
11513  return NULL;
11514 }
11515 
11516 
11517 SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11518  PyObject *resultobj = 0;
11519  char arg1 ;
11520  char val1 ;
11521  int ecode1 = 0 ;
11522  PyObject * obj0 = 0 ;
11523 
11524  if (!PyArg_ParseTuple(args,(char *)"O:plsesc",&obj0)) SWIG_fail;
11525  ecode1 = SWIG_AsVal_char(obj0, &val1);
11526  if (!SWIG_IsOK(ecode1)) {
11527  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11528  }
11529  arg1 = (char)(val1);
11530  plsesc(arg1);
11531  resultobj = SWIG_Py_Void();
11532  return resultobj;
11533 fail:
11534  return NULL;
11535 }
11536 
11537 
11538 SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11539  PyObject *resultobj = 0;
11540  char *arg1 = (char *) 0 ;
11541  char *arg2 = (char *) 0 ;
11542  int res1 ;
11543  char *buf1 = 0 ;
11544  int alloc1 = 0 ;
11545  int res2 ;
11546  char *buf2 = 0 ;
11547  int alloc2 = 0 ;
11548  PyObject * obj0 = 0 ;
11549  PyObject * obj1 = 0 ;
11550  PLINT result;
11551 
11552  if (!PyArg_ParseTuple(args,(char *)"OO:plsetopt",&obj0,&obj1)) SWIG_fail;
11553  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11554  if (!SWIG_IsOK(res1)) {
11555  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11556  }
11557  arg1 = (char *)(buf1);
11558  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11559  if (!SWIG_IsOK(res2)) {
11560  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11561  }
11562  arg2 = (char *)(buf2);
11563  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11564  resultobj = SWIG_From_int((int)(result));
11565  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11566  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11567  return resultobj;
11568 fail:
11569  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11570  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11571  return NULL;
11572 }
11573 
11574 
11575 SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11576  PyObject *resultobj = 0;
11577  PLINT arg1 ;
11578  PLINT arg2 ;
11579  PLINT arg3 ;
11580  int val1 ;
11581  int ecode1 = 0 ;
11582  int val2 ;
11583  int ecode2 = 0 ;
11584  int val3 ;
11585  int ecode3 = 0 ;
11586  PyObject * obj0 = 0 ;
11587  PyObject * obj1 = 0 ;
11588  PyObject * obj2 = 0 ;
11589 
11590  if (!PyArg_ParseTuple(args,(char *)"OOO:plsfam",&obj0,&obj1,&obj2)) SWIG_fail;
11591  ecode1 = SWIG_AsVal_int(obj0, &val1);
11592  if (!SWIG_IsOK(ecode1)) {
11593  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11594  }
11595  arg1 = (PLINT)(val1);
11596  ecode2 = SWIG_AsVal_int(obj1, &val2);
11597  if (!SWIG_IsOK(ecode2)) {
11598  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11599  }
11600  arg2 = (PLINT)(val2);
11601  ecode3 = SWIG_AsVal_int(obj2, &val3);
11602  if (!SWIG_IsOK(ecode3)) {
11603  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11604  }
11605  arg3 = (PLINT)(val3);
11606  plsfam(arg1,arg2,arg3);
11607  resultobj = SWIG_Py_Void();
11608  return resultobj;
11609 fail:
11610  return NULL;
11611 }
11612 
11613 
11614 SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11615  PyObject *resultobj = 0;
11616  PLUNICODE arg1 ;
11617  unsigned int val1 ;
11618  int ecode1 = 0 ;
11619  PyObject * obj0 = 0 ;
11620 
11621  if (!PyArg_ParseTuple(args,(char *)"O:plsfci",&obj0)) SWIG_fail;
11622  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11623  if (!SWIG_IsOK(ecode1)) {
11624  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11625  }
11626  arg1 = (PLUNICODE)(val1);
11627  plsfci(arg1);
11628  resultobj = SWIG_Py_Void();
11629  return resultobj;
11630 fail:
11631  return NULL;
11632 }
11633 
11634 
11635 SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11636  PyObject *resultobj = 0;
11637  char *arg1 = (char *) 0 ;
11638  int res1 ;
11639  char *buf1 = 0 ;
11640  int alloc1 = 0 ;
11641  PyObject * obj0 = 0 ;
11642 
11643  if (!PyArg_ParseTuple(args,(char *)"O:plsfnam",&obj0)) SWIG_fail;
11644  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11645  if (!SWIG_IsOK(res1)) {
11646  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11647  }
11648  arg1 = (char *)(buf1);
11649  plsfnam((char const *)arg1);
11650  resultobj = SWIG_Py_Void();
11651  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11652  return resultobj;
11653 fail:
11654  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11655  return NULL;
11656 }
11657 
11658 
11659 SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11660  PyObject *resultobj = 0;
11661  PLINT arg1 ;
11662  PLINT arg2 ;
11663  PLINT arg3 ;
11664  int val1 ;
11665  int ecode1 = 0 ;
11666  int val2 ;
11667  int ecode2 = 0 ;
11668  int val3 ;
11669  int ecode3 = 0 ;
11670  PyObject * obj0 = 0 ;
11671  PyObject * obj1 = 0 ;
11672  PyObject * obj2 = 0 ;
11673 
11674  if (!PyArg_ParseTuple(args,(char *)"OOO:plsfont",&obj0,&obj1,&obj2)) SWIG_fail;
11675  ecode1 = SWIG_AsVal_int(obj0, &val1);
11676  if (!SWIG_IsOK(ecode1)) {
11677  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11678  }
11679  arg1 = (PLINT)(val1);
11680  ecode2 = SWIG_AsVal_int(obj1, &val2);
11681  if (!SWIG_IsOK(ecode2)) {
11682  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11683  }
11684  arg2 = (PLINT)(val2);
11685  ecode3 = SWIG_AsVal_int(obj2, &val3);
11686  if (!SWIG_IsOK(ecode3)) {
11687  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11688  }
11689  arg3 = (PLINT)(val3);
11690  plsfont(arg1,arg2,arg3);
11691  resultobj = SWIG_Py_Void();
11692  return resultobj;
11693 fail:
11694  return NULL;
11695 }
11696 
11697 
11698 SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11699  PyObject *resultobj = 0;
11700  PLFLT **arg1 = (PLFLT **) 0 ;
11701  PLINT arg2 ;
11702  PLINT arg3 ;
11703  defined_func arg4 = (defined_func) 0 ;
11704  PLFLT arg5 ;
11705  PLFLT arg6 ;
11706  PLFLT arg7 ;
11707  PLFLT arg8 ;
11708  PLFLT *arg9 = (PLFLT *) 0 ;
11709  PLINT arg10 ;
11710  PLFLT arg11 ;
11711  PLINT arg12 ;
11712  PLFLT arg13 ;
11713  fill_func arg14 = (fill_func) 0 ;
11714  PLBOOL arg15 ;
11715  pltr_func arg16 = (pltr_func) 0 ;
11716  PLPointer arg17 = (PLPointer) 0 ;
11717  PyArrayObject *tmp1 ;
11718  double val5 ;
11719  int ecode5 = 0 ;
11720  double val6 ;
11721  int ecode6 = 0 ;
11722  double val7 ;
11723  int ecode7 = 0 ;
11724  double val8 ;
11725  int ecode8 = 0 ;
11726  PyArrayObject *tmp9 ;
11727  double val11 ;
11728  int ecode11 = 0 ;
11729  int val12 ;
11730  int ecode12 = 0 ;
11731  double val13 ;
11732  int ecode13 = 0 ;
11733  int val15 ;
11734  int ecode15 = 0 ;
11735  PyObject * obj0 = 0 ;
11736  PyObject * obj1 = 0 ;
11737  PyObject * obj2 = 0 ;
11738  PyObject * obj3 = 0 ;
11739  PyObject * obj4 = 0 ;
11740  PyObject * obj5 = 0 ;
11741  PyObject * obj6 = 0 ;
11742  PyObject * obj7 = 0 ;
11743  PyObject * obj8 = 0 ;
11744  PyObject * obj9 = 0 ;
11745  PyObject * obj10 = 0 ;
11746  PyObject * obj11 = 0 ;
11747 
11748  {
11749  python_pltr = 0;
11750  arg16 = NULL;
11751  }
11752  {
11753  arg17 = NULL;
11754  }
11755  {
11756  arg4 = NULL;
11757  }
11758  {
11759  arg14 = plfill;
11760  }
11761  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
11762  {
11763  int i, size;
11764  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
11765  if ( tmp1 == NULL )
11766  return NULL;
11767  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11768  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11769  size = sizeof ( PLFLT ) * arg3;
11770  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
11771  for ( i = 0; i < arg2; i++ )
11772  arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
11773  }
11774  ecode5 = SWIG_AsVal_double(obj1, &val5);
11775  if (!SWIG_IsOK(ecode5)) {
11776  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
11777  }
11778  arg5 = (PLFLT)(val5);
11779  ecode6 = SWIG_AsVal_double(obj2, &val6);
11780  if (!SWIG_IsOK(ecode6)) {
11781  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
11782  }
11783  arg6 = (PLFLT)(val6);
11784  ecode7 = SWIG_AsVal_double(obj3, &val7);
11785  if (!SWIG_IsOK(ecode7)) {
11786  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
11787  }
11788  arg7 = (PLFLT)(val7);
11789  ecode8 = SWIG_AsVal_double(obj4, &val8);
11790  if (!SWIG_IsOK(ecode8)) {
11791  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
11792  }
11793  arg8 = (PLFLT)(val8);
11794  {
11795  tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
11796  if ( tmp9 == NULL )
11797  return NULL;
11798  arg10 = PyArray_DIMS( tmp9 )[0];
11799  arg9 = (PLFLT *) PyArray_DATA( tmp9 );
11800  }
11801  ecode11 = SWIG_AsVal_double(obj6, &val11);
11802  if (!SWIG_IsOK(ecode11)) {
11803  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
11804  }
11805  arg11 = (PLFLT)(val11);
11806  ecode12 = SWIG_AsVal_int(obj7, &val12);
11807  if (!SWIG_IsOK(ecode12)) {
11808  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
11809  }
11810  arg12 = (PLINT)(val12);
11811  ecode13 = SWIG_AsVal_double(obj8, &val13);
11812  if (!SWIG_IsOK(ecode13)) {
11813  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
11814  }
11815  arg13 = (PLFLT)(val13);
11816  ecode15 = SWIG_AsVal_int(obj9, &val15);
11817  if (!SWIG_IsOK(ecode15)) {
11818  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
11819  }
11820  arg15 = (PLBOOL)(val15);
11821  if (obj10) {
11822  {
11823  // it must be a callable or None
11824  if ( obj10 == Py_None )
11825  {
11826  arg16 = NULL;
11827  }
11828  else
11829  {
11830  if ( !PyCallable_Check( (PyObject *) obj10 ) )
11831  {
11832  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11833  return NULL;
11834  }
11835  arg16 = marshal_pltr( obj10 );
11836  }
11837  }
11838  }
11839  if (obj11) {
11840  {
11841  if ( obj11 == Py_None )
11842  arg17 = NULL;
11843  else
11844  {
11845  arg17 = marshal_PLPointer( obj11, 0 );
11846  }
11847  }
11848  }
11849  plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11850  resultobj = SWIG_Py_Void();
11851  {
11852  Py_DECREF( tmp1 );
11853  free( arg1 );
11854  }
11855  {
11856  Py_DECREF( tmp9 );
11857  }
11858  {
11859  cleanup_pltr();
11860  }
11861  {
11863  }
11864  return resultobj;
11865 fail:
11866  {
11867  Py_DECREF( tmp1 );
11868  free( arg1 );
11869  }
11870  {
11871  Py_DECREF( tmp9 );
11872  }
11873  {
11874  cleanup_pltr();
11875  }
11876  {
11878  }
11879  return NULL;
11880 }
11881 
11882 
11883 SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11884  PyObject *resultobj = 0;
11885  PLFLT **arg1 = (PLFLT **) 0 ;
11886  PLINT arg2 ;
11887  PLINT arg3 ;
11888  defined_func arg4 = (defined_func) 0 ;
11889  PLFLT arg5 ;
11890  PLFLT arg6 ;
11891  PLFLT arg7 ;
11892  PLFLT arg8 ;
11893  PLFLT arg9 ;
11894  PLFLT arg10 ;
11895  PLINT arg11 ;
11896  PLFLT arg12 ;
11897  PLFLT arg13 ;
11898  PLINT arg14 ;
11899  PLFLT arg15 ;
11900  PLINT arg16 ;
11901  PLFLT arg17 ;
11902  fill_func arg18 = (fill_func) 0 ;
11903  PLBOOL arg19 ;
11904  pltr_func arg20 = (pltr_func) 0 ;
11905  PLPointer arg21 = (PLPointer) 0 ;
11906  PyArrayObject *tmp1 ;
11907  double val5 ;
11908  int ecode5 = 0 ;
11909  double val6 ;
11910  int ecode6 = 0 ;
11911  double val7 ;
11912  int ecode7 = 0 ;
11913  double val8 ;
11914  int ecode8 = 0 ;
11915  double val9 ;
11916  int ecode9 = 0 ;
11917  double val10 ;
11918  int ecode10 = 0 ;
11919  int val11 ;
11920  int ecode11 = 0 ;
11921  double val12 ;
11922  int ecode12 = 0 ;
11923  double val13 ;
11924  int ecode13 = 0 ;
11925  int val14 ;
11926  int ecode14 = 0 ;
11927  double val15 ;
11928  int ecode15 = 0 ;
11929  int val16 ;
11930  int ecode16 = 0 ;
11931  double val17 ;
11932  int ecode17 = 0 ;
11933  int val19 ;
11934  int ecode19 = 0 ;
11935  PyObject * obj0 = 0 ;
11936  PyObject * obj1 = 0 ;
11937  PyObject * obj2 = 0 ;
11938  PyObject * obj3 = 0 ;
11939  PyObject * obj4 = 0 ;
11940  PyObject * obj5 = 0 ;
11941  PyObject * obj6 = 0 ;
11942  PyObject * obj7 = 0 ;
11943  PyObject * obj8 = 0 ;
11944  PyObject * obj9 = 0 ;
11945  PyObject * obj10 = 0 ;
11946  PyObject * obj11 = 0 ;
11947  PyObject * obj12 = 0 ;
11948  PyObject * obj13 = 0 ;
11949  PyObject * obj14 = 0 ;
11950  PyObject * obj15 = 0 ;
11951  PyObject * obj16 = 0 ;
11952 
11953  {
11954  python_pltr = 0;
11955  arg20 = NULL;
11956  }
11957  {
11958  arg21 = NULL;
11959  }
11960  {
11961  arg4 = NULL;
11962  }
11963  {
11964  arg18 = plfill;
11965  }
11966  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;
11967  {
11968  int i, size;
11969  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
11970  if ( tmp1 == NULL )
11971  return NULL;
11972  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11973  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11974  size = sizeof ( PLFLT ) * arg3;
11975  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
11976  for ( i = 0; i < arg2; i++ )
11977  arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
11978  }
11979  ecode5 = SWIG_AsVal_double(obj1, &val5);
11980  if (!SWIG_IsOK(ecode5)) {
11981  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
11982  }
11983  arg5 = (PLFLT)(val5);
11984  ecode6 = SWIG_AsVal_double(obj2, &val6);
11985  if (!SWIG_IsOK(ecode6)) {
11986  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
11987  }
11988  arg6 = (PLFLT)(val6);
11989  ecode7 = SWIG_AsVal_double(obj3, &val7);
11990  if (!SWIG_IsOK(ecode7)) {
11991  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
11992  }
11993  arg7 = (PLFLT)(val7);
11994  ecode8 = SWIG_AsVal_double(obj4, &val8);
11995  if (!SWIG_IsOK(ecode8)) {
11996  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
11997  }
11998  arg8 = (PLFLT)(val8);
11999  ecode9 = SWIG_AsVal_double(obj5, &val9);
12000  if (!SWIG_IsOK(ecode9)) {
12001  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12002  }
12003  arg9 = (PLFLT)(val9);
12004  ecode10 = SWIG_AsVal_double(obj6, &val10);
12005  if (!SWIG_IsOK(ecode10)) {
12006  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12007  }
12008  arg10 = (PLFLT)(val10);
12009  ecode11 = SWIG_AsVal_int(obj7, &val11);
12010  if (!SWIG_IsOK(ecode11)) {
12011  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12012  }
12013  arg11 = (PLINT)(val11);
12014  ecode12 = SWIG_AsVal_double(obj8, &val12);
12015  if (!SWIG_IsOK(ecode12)) {
12016  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12017  }
12018  arg12 = (PLFLT)(val12);
12019  ecode13 = SWIG_AsVal_double(obj9, &val13);
12020  if (!SWIG_IsOK(ecode13)) {
12021  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12022  }
12023  arg13 = (PLFLT)(val13);
12024  ecode14 = SWIG_AsVal_int(obj10, &val14);
12025  if (!SWIG_IsOK(ecode14)) {
12026  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12027  }
12028  arg14 = (PLINT)(val14);
12029  ecode15 = SWIG_AsVal_double(obj11, &val15);
12030  if (!SWIG_IsOK(ecode15)) {
12031  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12032  }
12033  arg15 = (PLFLT)(val15);
12034  ecode16 = SWIG_AsVal_int(obj12, &val16);
12035  if (!SWIG_IsOK(ecode16)) {
12036  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12037  }
12038  arg16 = (PLINT)(val16);
12039  ecode17 = SWIG_AsVal_double(obj13, &val17);
12040  if (!SWIG_IsOK(ecode17)) {
12041  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12042  }
12043  arg17 = (PLFLT)(val17);
12044  ecode19 = SWIG_AsVal_int(obj14, &val19);
12045  if (!SWIG_IsOK(ecode19)) {
12046  SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12047  }
12048  arg19 = (PLBOOL)(val19);
12049  if (obj15) {
12050  {
12051  // it must be a callable or None
12052  if ( obj15 == Py_None )
12053  {
12054  arg20 = NULL;
12055  }
12056  else
12057  {
12058  if ( !PyCallable_Check( (PyObject *) obj15 ) )
12059  {
12060  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12061  return NULL;
12062  }
12063  arg20 = marshal_pltr( obj15 );
12064  }
12065  }
12066  }
12067  if (obj16) {
12068  {
12069  if ( obj16 == Py_None )
12070  arg21 = NULL;
12071  else
12072  {
12073  arg21 = marshal_PLPointer( obj16, 0 );
12074  }
12075  }
12076  }
12077  plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12078  resultobj = SWIG_Py_Void();
12079  {
12080  Py_DECREF( tmp1 );
12081  free( arg1 );
12082  }
12083  {
12084  cleanup_pltr();
12085  }
12086  {
12088  }
12089  return resultobj;
12090 fail:
12091  {
12092  Py_DECREF( tmp1 );
12093  free( arg1 );
12094  }
12095  {
12096  cleanup_pltr();
12097  }
12098  {
12100  }
12101  return NULL;
12102 }
12103 
12104 
12105 SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12106  PyObject *resultobj = 0;
12107  label_func arg1 = (label_func) 0 ;
12108  PLPointer arg2 = (PLPointer) 0 ;
12109  int res2 ;
12110  PyObject * obj0 = 0 ;
12111  PyObject * obj1 = 0 ;
12112 
12113  if (!PyArg_ParseTuple(args,(char *)"OO:plslabelfunc",&obj0,&obj1)) SWIG_fail;
12114  {
12115  // Release reference to previous function if applicable
12116  if ( python_label )
12117  {
12118  Py_XDECREF( python_label );
12119  python_label = 0;
12120  }
12121  // it must be a callable or None
12122  if ( obj0 == Py_None )
12123  {
12124  arg1 = NULL;
12125  }
12126  else
12127  {
12128  if ( !PyCallable_Check( (PyObject *) obj0 ) )
12129  {
12130  PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12131  return NULL;
12132  }
12133  // hold a reference to it
12134  Py_XINCREF( (PyObject *) obj0 );
12135  python_label = (PyObject *) obj0;
12136  // this function handles calling the python function
12137  arg1 = do_label_callback;
12138  }
12139  }
12140  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12141  if (!SWIG_IsOK(res2)) {
12142  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12143  }
12144  plslabelfunc(arg1,arg2);
12145  resultobj = SWIG_Py_Void();
12146  return resultobj;
12147 fail:
12148  return NULL;
12149 }
12150 
12151 
12152 SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12153  PyObject *resultobj = 0;
12154  PLFLT arg1 ;
12155  PLFLT arg2 ;
12156  double val1 ;
12157  int ecode1 = 0 ;
12158  double val2 ;
12159  int ecode2 = 0 ;
12160  PyObject * obj0 = 0 ;
12161  PyObject * obj1 = 0 ;
12162 
12163  if (!PyArg_ParseTuple(args,(char *)"OO:plsmaj",&obj0,&obj1)) SWIG_fail;
12164  ecode1 = SWIG_AsVal_double(obj0, &val1);
12165  if (!SWIG_IsOK(ecode1)) {
12166  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12167  }
12168  arg1 = (PLFLT)(val1);
12169  ecode2 = SWIG_AsVal_double(obj1, &val2);
12170  if (!SWIG_IsOK(ecode2)) {
12171  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12172  }
12173  arg2 = (PLFLT)(val2);
12174  plsmaj(arg1,arg2);
12175  resultobj = SWIG_Py_Void();
12176  return resultobj;
12177 fail:
12178  return NULL;
12179 }
12180 
12181 
12182 SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12183  PyObject *resultobj = 0;
12184  PLINT arg1 ;
12185  PLINT arg2 ;
12186  void *arg3 = (void *) 0 ;
12187  int val1 ;
12188  int ecode1 = 0 ;
12189  int val2 ;
12190  int ecode2 = 0 ;
12191  int res3 ;
12192  Py_ssize_t size3 = 0 ;
12193  void *buf3 = 0 ;
12194  PyObject * obj0 = 0 ;
12195  PyObject * obj1 = 0 ;
12196  PyObject * obj2 = 0 ;
12197 
12198  if (!PyArg_ParseTuple(args,(char *)"OOO:plsmem",&obj0,&obj1,&obj2)) SWIG_fail;
12199  ecode1 = SWIG_AsVal_int(obj0, &val1);
12200  if (!SWIG_IsOK(ecode1)) {
12201  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12202  }
12203  arg1 = (PLINT)(val1);
12204  ecode2 = SWIG_AsVal_int(obj1, &val2);
12205  if (!SWIG_IsOK(ecode2)) {
12206  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12207  }
12208  arg2 = (PLINT)(val2);
12209  {
12210  res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12211  if (res3<0) {
12212  PyErr_Clear();
12213  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12214  }
12215  arg3 = (void *) buf3;
12216  }
12217  plsmem(arg1,arg2,arg3);
12218  resultobj = SWIG_Py_Void();
12219  return resultobj;
12220 fail:
12221  return NULL;
12222 }
12223 
12224 
12225 SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12226  PyObject *resultobj = 0;
12227  PLINT arg1 ;
12228  PLINT arg2 ;
12229  void *arg3 = (void *) 0 ;
12230  int val1 ;
12231  int ecode1 = 0 ;
12232  int val2 ;
12233  int ecode2 = 0 ;
12234  int res3 ;
12235  Py_ssize_t size3 = 0 ;
12236  void *buf3 = 0 ;
12237  PyObject * obj0 = 0 ;
12238  PyObject * obj1 = 0 ;
12239  PyObject * obj2 = 0 ;
12240 
12241  if (!PyArg_ParseTuple(args,(char *)"OOO:plsmema",&obj0,&obj1,&obj2)) SWIG_fail;
12242  ecode1 = SWIG_AsVal_int(obj0, &val1);
12243  if (!SWIG_IsOK(ecode1)) {
12244  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12245  }
12246  arg1 = (PLINT)(val1);
12247  ecode2 = SWIG_AsVal_int(obj1, &val2);
12248  if (!SWIG_IsOK(ecode2)) {
12249  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12250  }
12251  arg2 = (PLINT)(val2);
12252  {
12253  res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12254  if (res3<0) {
12255  PyErr_Clear();
12256  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12257  }
12258  arg3 = (void *) buf3;
12259  }
12260  plsmema(arg1,arg2,arg3);
12261  resultobj = SWIG_Py_Void();
12262  return resultobj;
12263 fail:
12264  return NULL;
12265 }
12266 
12267 
12268 SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12269  PyObject *resultobj = 0;
12270  PLFLT arg1 ;
12271  PLFLT arg2 ;
12272  double val1 ;
12273  int ecode1 = 0 ;
12274  double val2 ;
12275  int ecode2 = 0 ;
12276  PyObject * obj0 = 0 ;
12277  PyObject * obj1 = 0 ;
12278 
12279  if (!PyArg_ParseTuple(args,(char *)"OO:plsmin",&obj0,&obj1)) SWIG_fail;
12280  ecode1 = SWIG_AsVal_double(obj0, &val1);
12281  if (!SWIG_IsOK(ecode1)) {
12282  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12283  }
12284  arg1 = (PLFLT)(val1);
12285  ecode2 = SWIG_AsVal_double(obj1, &val2);
12286  if (!SWIG_IsOK(ecode2)) {
12287  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12288  }
12289  arg2 = (PLFLT)(val2);
12290  plsmin(arg1,arg2);
12291  resultobj = SWIG_Py_Void();
12292  return resultobj;
12293 fail:
12294  return NULL;
12295 }
12296 
12297 
12298 SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12299  PyObject *resultobj = 0;
12300  PLINT arg1 ;
12301  int val1 ;
12302  int ecode1 = 0 ;
12303  PyObject * obj0 = 0 ;
12304 
12305  if (!PyArg_ParseTuple(args,(char *)"O:plsori",&obj0)) SWIG_fail;
12306  ecode1 = SWIG_AsVal_int(obj0, &val1);
12307  if (!SWIG_IsOK(ecode1)) {
12308  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12309  }
12310  arg1 = (PLINT)(val1);
12311  plsori(arg1);
12312  resultobj = SWIG_Py_Void();
12313  return resultobj;
12314 fail:
12315  return NULL;
12316 }
12317 
12318 
12319 SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12320  PyObject *resultobj = 0;
12321  PLFLT arg1 ;
12322  PLFLT arg2 ;
12323  PLINT arg3 ;
12324  PLINT arg4 ;
12325  PLINT arg5 ;
12326  PLINT arg6 ;
12327  double val1 ;
12328  int ecode1 = 0 ;
12329  double val2 ;
12330  int ecode2 = 0 ;
12331  int val3 ;
12332  int ecode3 = 0 ;
12333  int val4 ;
12334  int ecode4 = 0 ;
12335  int val5 ;
12336  int ecode5 = 0 ;
12337  int val6 ;
12338  int ecode6 = 0 ;
12339  PyObject * obj0 = 0 ;
12340  PyObject * obj1 = 0 ;
12341  PyObject * obj2 = 0 ;
12342  PyObject * obj3 = 0 ;
12343  PyObject * obj4 = 0 ;
12344  PyObject * obj5 = 0 ;
12345 
12346  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
12347  ecode1 = SWIG_AsVal_double(obj0, &val1);
12348  if (!SWIG_IsOK(ecode1)) {
12349  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12350  }
12351  arg1 = (PLFLT)(val1);
12352  ecode2 = SWIG_AsVal_double(obj1, &val2);
12353  if (!SWIG_IsOK(ecode2)) {
12354  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12355  }
12356  arg2 = (PLFLT)(val2);
12357  ecode3 = SWIG_AsVal_int(obj2, &val3);
12358  if (!SWIG_IsOK(ecode3)) {
12359  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12360  }
12361  arg3 = (PLINT)(val3);
12362  ecode4 = SWIG_AsVal_int(obj3, &val4);
12363  if (!SWIG_IsOK(ecode4)) {
12364  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12365  }
12366  arg4 = (PLINT)(val4);
12367  ecode5 = SWIG_AsVal_int(obj4, &val5);
12368  if (!SWIG_IsOK(ecode5)) {
12369  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12370  }
12371  arg5 = (PLINT)(val5);
12372  ecode6 = SWIG_AsVal_int(obj5, &val6);
12373  if (!SWIG_IsOK(ecode6)) {
12374  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12375  }
12376  arg6 = (PLINT)(val6);
12377  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12378  resultobj = SWIG_Py_Void();
12379  return resultobj;
12380 fail:
12381  return NULL;
12382 }
12383 
12384 
12385 SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12386  PyObject *resultobj = 0;
12387  char *arg1 = (char *) 0 ;
12388  int res1 ;
12389  char *buf1 = 0 ;
12390  int alloc1 = 0 ;
12391  PyObject * obj0 = 0 ;
12392 
12393  if (!PyArg_ParseTuple(args,(char *)"O:plspal0",&obj0)) SWIG_fail;
12394  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12395  if (!SWIG_IsOK(res1)) {
12396  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12397  }
12398  arg1 = (char *)(buf1);
12399  plspal0((char const *)arg1);
12400  resultobj = SWIG_Py_Void();
12401  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12402  return resultobj;
12403 fail:
12404  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12405  return NULL;
12406 }
12407 
12408 
12409 SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12410  PyObject *resultobj = 0;
12411  char *arg1 = (char *) 0 ;
12412  PLBOOL arg2 ;
12413  int res1 ;
12414  char *buf1 = 0 ;
12415  int alloc1 = 0 ;
12416  int val2 ;
12417  int ecode2 = 0 ;
12418  PyObject * obj0 = 0 ;
12419  PyObject * obj1 = 0 ;
12420 
12421  if (!PyArg_ParseTuple(args,(char *)"OO:plspal1",&obj0,&obj1)) SWIG_fail;
12422  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12423  if (!SWIG_IsOK(res1)) {
12424  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12425  }
12426  arg1 = (char *)(buf1);
12427  ecode2 = SWIG_AsVal_int(obj1, &val2);
12428  if (!SWIG_IsOK(ecode2)) {
12429  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12430  }
12431  arg2 = (PLBOOL)(val2);
12432  plspal1((char const *)arg1,arg2);
12433  resultobj = SWIG_Py_Void();
12434  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12435  return resultobj;
12436 fail:
12437  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12438  return NULL;
12439 }
12440 
12441 
12442 SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12443  PyObject *resultobj = 0;
12444  PLBOOL arg1 ;
12445  int val1 ;
12446  int ecode1 = 0 ;
12447  PyObject * obj0 = 0 ;
12448 
12449  if (!PyArg_ParseTuple(args,(char *)"O:plspause",&obj0)) SWIG_fail;
12450  ecode1 = SWIG_AsVal_int(obj0, &val1);
12451  if (!SWIG_IsOK(ecode1)) {
12452  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12453  }
12454  arg1 = (PLBOOL)(val1);
12455  plspause(arg1);
12456  resultobj = SWIG_Py_Void();
12457  return resultobj;
12458 fail:
12459  return NULL;
12460 }
12461 
12462 
12463 SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12464  PyObject *resultobj = 0;
12465  PLINT arg1 ;
12466  int val1 ;
12467  int ecode1 = 0 ;
12468  PyObject * obj0 = 0 ;
12469 
12470  if (!PyArg_ParseTuple(args,(char *)"O:plsstrm",&obj0)) SWIG_fail;
12471  ecode1 = SWIG_AsVal_int(obj0, &val1);
12472  if (!SWIG_IsOK(ecode1)) {
12473  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12474  }
12475  arg1 = (PLINT)(val1);
12476  plsstrm(arg1);
12477  resultobj = SWIG_Py_Void();
12478  return resultobj;
12479 fail:
12480  return NULL;
12481 }
12482 
12483 
12484 SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12485  PyObject *resultobj = 0;
12486  PLINT arg1 ;
12487  PLINT arg2 ;
12488  int val1 ;
12489  int ecode1 = 0 ;
12490  int val2 ;
12491  int ecode2 = 0 ;
12492  PyObject * obj0 = 0 ;
12493  PyObject * obj1 = 0 ;
12494 
12495  if (!PyArg_ParseTuple(args,(char *)"OO:plssub",&obj0,&obj1)) SWIG_fail;
12496  ecode1 = SWIG_AsVal_int(obj0, &val1);
12497  if (!SWIG_IsOK(ecode1)) {
12498  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12499  }
12500  arg1 = (PLINT)(val1);
12501  ecode2 = SWIG_AsVal_int(obj1, &val2);
12502  if (!SWIG_IsOK(ecode2)) {
12503  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12504  }
12505  arg2 = (PLINT)(val2);
12506  plssub(arg1,arg2);
12507  resultobj = SWIG_Py_Void();
12508  return resultobj;
12509 fail:
12510  return NULL;
12511 }
12512 
12513 
12514 SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12515  PyObject *resultobj = 0;
12516  PLFLT arg1 ;
12517  PLFLT arg2 ;
12518  double val1 ;
12519  int ecode1 = 0 ;
12520  double val2 ;
12521  int ecode2 = 0 ;
12522  PyObject * obj0 = 0 ;
12523  PyObject * obj1 = 0 ;
12524 
12525  if (!PyArg_ParseTuple(args,(char *)"OO:plssym",&obj0,&obj1)) SWIG_fail;
12526  ecode1 = SWIG_AsVal_double(obj0, &val1);
12527  if (!SWIG_IsOK(ecode1)) {
12528  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12529  }
12530  arg1 = (PLFLT)(val1);
12531  ecode2 = SWIG_AsVal_double(obj1, &val2);
12532  if (!SWIG_IsOK(ecode2)) {
12533  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12534  }
12535  arg2 = (PLFLT)(val2);
12536  plssym(arg1,arg2);
12537  resultobj = SWIG_Py_Void();
12538  return resultobj;
12539 fail:
12540  return NULL;
12541 }
12542 
12543 
12544 SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12545  PyObject *resultobj = 0;
12546  PLINT arg1 ;
12547  PLINT arg2 ;
12548  int val1 ;
12549  int ecode1 = 0 ;
12550  int val2 ;
12551  int ecode2 = 0 ;
12552  PyObject * obj0 = 0 ;
12553  PyObject * obj1 = 0 ;
12554 
12555  if (!PyArg_ParseTuple(args,(char *)"OO:plstar",&obj0,&obj1)) SWIG_fail;
12556  ecode1 = SWIG_AsVal_int(obj0, &val1);
12557  if (!SWIG_IsOK(ecode1)) {
12558  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12559  }
12560  arg1 = (PLINT)(val1);
12561  ecode2 = SWIG_AsVal_int(obj1, &val2);
12562  if (!SWIG_IsOK(ecode2)) {
12563  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12564  }
12565  arg2 = (PLINT)(val2);
12566  plstar(arg1,arg2);
12567  resultobj = SWIG_Py_Void();
12568  return resultobj;
12569 fail:
12570  return NULL;
12571 }
12572 
12573 
12574 SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12575  PyObject *resultobj = 0;
12576  char *arg1 = (char *) 0 ;
12577  PLINT arg2 ;
12578  PLINT arg3 ;
12579  int res1 ;
12580  char *buf1 = 0 ;
12581  int alloc1 = 0 ;
12582  int val2 ;
12583  int ecode2 = 0 ;
12584  int val3 ;
12585  int ecode3 = 0 ;
12586  PyObject * obj0 = 0 ;
12587  PyObject * obj1 = 0 ;
12588  PyObject * obj2 = 0 ;
12589 
12590  if (!PyArg_ParseTuple(args,(char *)"OOO:plstart",&obj0,&obj1,&obj2)) SWIG_fail;
12591  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12592  if (!SWIG_IsOK(res1)) {
12593  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12594  }
12595  arg1 = (char *)(buf1);
12596  ecode2 = SWIG_AsVal_int(obj1, &val2);
12597  if (!SWIG_IsOK(ecode2)) {
12598  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12599  }
12600  arg2 = (PLINT)(val2);
12601  ecode3 = SWIG_AsVal_int(obj2, &val3);
12602  if (!SWIG_IsOK(ecode3)) {
12603  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12604  }
12605  arg3 = (PLINT)(val3);
12606  plstart((char const *)arg1,arg2,arg3);
12607  resultobj = SWIG_Py_Void();
12608  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12609  return resultobj;
12610 fail:
12611  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12612  return NULL;
12613 }
12614 
12615 
12616 SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12617  PyObject *resultobj = 0;
12618  ct_func arg1 = (ct_func) 0 ;
12619  PLPointer arg2 = (PLPointer) 0 ;
12620  int res2 ;
12621  PyObject * obj0 = 0 ;
12622  PyObject * obj1 = 0 ;
12623 
12624  {
12625  python_ct = 0;
12626  arg1 = NULL;
12627  }
12628  if (!PyArg_ParseTuple(args,(char *)"|OO:plstransform",&obj0,&obj1)) SWIG_fail;
12629  if (obj0) {
12630  {
12631  if ( python_ct )
12632  cleanup_ct();
12633  // it must be a callable or none
12634  if ( obj0 == Py_None )
12635  {
12636  arg1 = NULL;
12637  }
12638  else
12639  {
12640  if ( !PyCallable_Check( (PyObject *) obj0 ) )
12641  {
12642  PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12643  return NULL;
12644  }
12645  arg1 = marshal_ct( obj0 );
12646  }
12647  }
12648  }
12649  if (obj1) {
12650  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12651  if (!SWIG_IsOK(res2)) {
12652  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12653  }
12654  }
12655  plstransform(arg1,arg2);
12656  resultobj = SWIG_Py_Void();
12657  return resultobj;
12658 fail:
12659  return NULL;
12660 }
12661 
12662 
12663 SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12664  PyObject *resultobj = 0;
12665  PLINT arg1 ;
12666  PLFLT *arg2 = (PLFLT *) 0 ;
12667  PLFLT *arg3 = (PLFLT *) 0 ;
12668  char *arg4 = (char *) 0 ;
12669  PyArrayObject *tmp1 ;
12670  PyArrayObject *tmp3 ;
12671  int res4 ;
12672  char *buf4 = 0 ;
12673  int alloc4 = 0 ;
12674  PyObject * obj0 = 0 ;
12675  PyObject * obj1 = 0 ;
12676  PyObject * obj2 = 0 ;
12677 
12678  if (!PyArg_ParseTuple(args,(char *)"OOO:plstring",&obj0,&obj1,&obj2)) SWIG_fail;
12679  {
12680  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12681  if ( tmp1 == NULL )
12682  return NULL;
12683  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12684  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12685  }
12686  {
12687  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
12688  if ( tmp3 == NULL )
12689  return NULL;
12690  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12691  {
12692  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12693  return NULL;
12694  }
12695  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12696  }
12697  res4 = SWIG_AsCharPtrAndSize(obj2, &buf4, NULL, &alloc4);
12698  if (!SWIG_IsOK(res4)) {
12699  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12700  }
12701  arg4 = (char *)(buf4);
12702  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12703  resultobj = SWIG_Py_Void();
12704  {
12705  Py_DECREF( tmp1 );
12706  }
12707  {
12708  Py_DECREF( tmp3 );
12709  }
12710  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12711  return resultobj;
12712 fail:
12713  {
12714  Py_DECREF( tmp1 );
12715  }
12716  {
12717  Py_DECREF( tmp3 );
12718  }
12719  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12720  return NULL;
12721 }
12722 
12723 
12724 SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12725  PyObject *resultobj = 0;
12726  PLINT arg1 ;
12727  PLFLT *arg2 = (PLFLT *) 0 ;
12728  PLFLT *arg3 = (PLFLT *) 0 ;
12729  PLFLT *arg4 = (PLFLT *) 0 ;
12730  char *arg5 = (char *) 0 ;
12731  PyArrayObject *tmp1 ;
12732  PyArrayObject *tmp3 ;
12733  PyArrayObject *tmp4 ;
12734  int res5 ;
12735  char *buf5 = 0 ;
12736  int alloc5 = 0 ;
12737  PyObject * obj0 = 0 ;
12738  PyObject * obj1 = 0 ;
12739  PyObject * obj2 = 0 ;
12740  PyObject * obj3 = 0 ;
12741 
12742  if (!PyArg_ParseTuple(args,(char *)"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12743  {
12744  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12745  if ( tmp1 == NULL )
12746  return NULL;
12747  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12748  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12749  }
12750  {
12751  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
12752  if ( tmp3 == NULL )
12753  return NULL;
12754  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12755  {
12756  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12757  return NULL;
12758  }
12759  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12760  }
12761  {
12762  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
12763  if ( tmp4 == NULL )
12764  return NULL;
12765  if ( PyArray_DIMS( tmp4 )[0] != Alen )
12766  {
12767  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12768  return NULL;
12769  }
12770  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
12771  }
12772  res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
12773  if (!SWIG_IsOK(res5)) {
12774  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
12775  }
12776  arg5 = (char *)(buf5);
12777  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
12778  resultobj = SWIG_Py_Void();
12779  {
12780  Py_DECREF( tmp1 );
12781  }
12782  {
12783  Py_DECREF( tmp3 );
12784  }
12785  {
12786  Py_DECREF( tmp4 );
12787  }
12788  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12789  return resultobj;
12790 fail:
12791  {
12792  Py_DECREF( tmp1 );
12793  }
12794  {
12795  Py_DECREF( tmp3 );
12796  }
12797  {
12798  Py_DECREF( tmp4 );
12799  }
12800  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12801  return NULL;
12802 }
12803 
12804 
12805 SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12806  PyObject *resultobj = 0;
12807  PLINT arg1 ;
12808  PLINT arg2 ;
12809  PLFLT arg3 ;
12810  PLFLT arg4 ;
12811  int val1 ;
12812  int ecode1 = 0 ;
12813  int val2 ;
12814  int ecode2 = 0 ;
12815  double val3 ;
12816  int ecode3 = 0 ;
12817  double val4 ;
12818  int ecode4 = 0 ;
12819  PyObject * obj0 = 0 ;
12820  PyObject * obj1 = 0 ;
12821  PyObject * obj2 = 0 ;
12822  PyObject * obj3 = 0 ;
12823 
12824  if (!PyArg_ParseTuple(args,(char *)"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12825  ecode1 = SWIG_AsVal_int(obj0, &val1);
12826  if (!SWIG_IsOK(ecode1)) {
12827  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
12828  }
12829  arg1 = (PLINT)(val1);
12830  ecode2 = SWIG_AsVal_int(obj1, &val2);
12831  if (!SWIG_IsOK(ecode2)) {
12832  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
12833  }
12834  arg2 = (PLINT)(val2);
12835  ecode3 = SWIG_AsVal_double(obj2, &val3);
12836  if (!SWIG_IsOK(ecode3)) {
12837  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
12838  }
12839  arg3 = (PLFLT)(val3);
12840  ecode4 = SWIG_AsVal_double(obj3, &val4);
12841  if (!SWIG_IsOK(ecode4)) {
12842  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
12843  }
12844  arg4 = (PLFLT)(val4);
12845  plstripa(arg1,arg2,arg3,arg4);
12846  resultobj = SWIG_Py_Void();
12847  return resultobj;
12848 fail:
12849  return NULL;
12850 }
12851 
12852 
12853 SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12854  PyObject *resultobj = 0;
12855  PLINT *arg1 = (PLINT *) 0 ;
12856  char *arg2 = (char *) 0 ;
12857  char *arg3 = (char *) 0 ;
12858  PLFLT arg4 ;
12859  PLFLT arg5 ;
12860  PLFLT arg6 ;
12861  PLFLT arg7 ;
12862  PLFLT arg8 ;
12863  PLFLT arg9 ;
12864  PLFLT arg10 ;
12865  PLBOOL arg11 ;
12866  PLBOOL arg12 ;
12867  PLINT arg13 ;
12868  PLINT arg14 ;
12869  PLINT *arg15 = (PLINT *) 0 ;
12870  PLINT *arg16 = (PLINT *) 0 ;
12871  char **arg17 ;
12872  char *arg18 = (char *) 0 ;
12873  char *arg19 = (char *) 0 ;
12874  char *arg20 = (char *) 0 ;
12875  PLINT temp1 ;
12876  int res1 = SWIG_TMPOBJ ;
12877  int res2 ;
12878  char *buf2 = 0 ;
12879  int alloc2 = 0 ;
12880  int res3 ;
12881  char *buf3 = 0 ;
12882  int alloc3 = 0 ;
12883  double val4 ;
12884  int ecode4 = 0 ;
12885  double val5 ;
12886  int ecode5 = 0 ;
12887  double val6 ;
12888  int ecode6 = 0 ;
12889  double val7 ;
12890  int ecode7 = 0 ;
12891  double val8 ;
12892  int ecode8 = 0 ;
12893  double val9 ;
12894  int ecode9 = 0 ;
12895  double val10 ;
12896  int ecode10 = 0 ;
12897  int val11 ;
12898  int ecode11 = 0 ;
12899  int val12 ;
12900  int ecode12 = 0 ;
12901  int val13 ;
12902  int ecode13 = 0 ;
12903  int val14 ;
12904  int ecode14 = 0 ;
12905  PyArrayObject *tmp15 ;
12906  PyArrayObject *tmp16 ;
12907  int res18 ;
12908  char *buf18 = 0 ;
12909  int alloc18 = 0 ;
12910  int res19 ;
12911  char *buf19 = 0 ;
12912  int alloc19 = 0 ;
12913  int res20 ;
12914  char *buf20 = 0 ;
12915  int alloc20 = 0 ;
12916  PyObject * obj0 = 0 ;
12917  PyObject * obj1 = 0 ;
12918  PyObject * obj2 = 0 ;
12919  PyObject * obj3 = 0 ;
12920  PyObject * obj4 = 0 ;
12921  PyObject * obj5 = 0 ;
12922  PyObject * obj6 = 0 ;
12923  PyObject * obj7 = 0 ;
12924  PyObject * obj8 = 0 ;
12925  PyObject * obj9 = 0 ;
12926  PyObject * obj10 = 0 ;
12927  PyObject * obj11 = 0 ;
12928  PyObject * obj12 = 0 ;
12929  PyObject * obj13 = 0 ;
12930  PyObject * obj14 = 0 ;
12931  PyObject * obj15 = 0 ;
12932  PyObject * obj16 = 0 ;
12933  PyObject * obj17 = 0 ;
12934  PyObject * obj18 = 0 ;
12935 
12936  arg1 = &temp1;
12937  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;
12938  res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
12939  if (!SWIG_IsOK(res2)) {
12940  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
12941  }
12942  arg2 = (char *)(buf2);
12943  res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
12944  if (!SWIG_IsOK(res3)) {
12945  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
12946  }
12947  arg3 = (char *)(buf3);
12948  ecode4 = SWIG_AsVal_double(obj2, &val4);
12949  if (!SWIG_IsOK(ecode4)) {
12950  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
12951  }
12952  arg4 = (PLFLT)(val4);
12953  ecode5 = SWIG_AsVal_double(obj3, &val5);
12954  if (!SWIG_IsOK(ecode5)) {
12955  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
12956  }
12957  arg5 = (PLFLT)(val5);
12958  ecode6 = SWIG_AsVal_double(obj4, &val6);
12959  if (!SWIG_IsOK(ecode6)) {
12960  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
12961  }
12962  arg6 = (PLFLT)(val6);
12963  ecode7 = SWIG_AsVal_double(obj5, &val7);
12964  if (!SWIG_IsOK(ecode7)) {
12965  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
12966  }
12967  arg7 = (PLFLT)(val7);
12968  ecode8 = SWIG_AsVal_double(obj6, &val8);
12969  if (!SWIG_IsOK(ecode8)) {
12970  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
12971  }
12972  arg8 = (PLFLT)(val8);
12973  ecode9 = SWIG_AsVal_double(obj7, &val9);
12974  if (!SWIG_IsOK(ecode9)) {
12975  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
12976  }
12977  arg9 = (PLFLT)(val9);
12978  ecode10 = SWIG_AsVal_double(obj8, &val10);
12979  if (!SWIG_IsOK(ecode10)) {
12980  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
12981  }
12982  arg10 = (PLFLT)(val10);
12983  ecode11 = SWIG_AsVal_int(obj9, &val11);
12984  if (!SWIG_IsOK(ecode11)) {
12985  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
12986  }
12987  arg11 = (PLBOOL)(val11);
12988  ecode12 = SWIG_AsVal_int(obj10, &val12);
12989  if (!SWIG_IsOK(ecode12)) {
12990  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
12991  }
12992  arg12 = (PLBOOL)(val12);
12993  ecode13 = SWIG_AsVal_int(obj11, &val13);
12994  if (!SWIG_IsOK(ecode13)) {
12995  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
12996  }
12997  arg13 = (PLINT)(val13);
12998  ecode14 = SWIG_AsVal_int(obj12, &val14);
12999  if (!SWIG_IsOK(ecode14)) {
13000  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13001  }
13002  arg14 = (PLINT)(val14);
13003  {
13004  tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
13005  if ( tmp15 == NULL )
13006  return NULL;
13007  Alen = PyArray_DIMS( tmp15 )[0];
13008  arg15 = (PLINT *) PyArray_DATA( tmp15 );
13009  }
13010  {
13011  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj14, NPY_PLINT, 1, 1 );
13012  if ( tmp16 == NULL )
13013  return NULL;
13014  if ( PyArray_DIMS( tmp16 )[0] != Alen )
13015  {
13016  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13017  return NULL;
13018  }
13019  arg16 = (PLINT *) PyArray_DATA( tmp16 );
13020  }
13021  {
13022  int i;
13023  if ( !PySequence_Check( obj15 ) || PySequence_Size( obj15 ) != 4 )
13024  {
13025  PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13026  return NULL;
13027  }
13028  if ( Alen != 4 )
13029  {
13030  PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13031  return NULL;
13032  }
13033  arg17 = malloc( sizeof ( char* ) * 4 );
13034  for ( i = 0; i < 4; i++ )
13035  {
13036  arg17[i] = PyString_AsString( PySequence_Fast_GET_ITEM( obj15, i ) );
13037  if ( arg17[i] == NULL )
13038  {
13039  free( arg17 );
13040  return NULL;
13041  }
13042  }
13043  }
13044  res18 = SWIG_AsCharPtrAndSize(obj16, &buf18, NULL, &alloc18);
13045  if (!SWIG_IsOK(res18)) {
13046  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13047  }
13048  arg18 = (char *)(buf18);
13049  res19 = SWIG_AsCharPtrAndSize(obj17, &buf19, NULL, &alloc19);
13050  if (!SWIG_IsOK(res19)) {
13051  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13052  }
13053  arg19 = (char *)(buf19);
13054  res20 = SWIG_AsCharPtrAndSize(obj18, &buf20, NULL, &alloc20);
13055  if (!SWIG_IsOK(res20)) {
13056  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13057  }
13058  arg20 = (char *)(buf20);
13059  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);
13060  resultobj = SWIG_Py_Void();
13061  if (SWIG_IsTmpObj(res1)) {
13062  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
13063  } else {
13064  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13065  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13066  }
13067  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13068  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13069  {
13070  Py_DECREF( tmp15 );
13071  }
13072  {
13073  Py_DECREF( tmp16 );
13074  }
13075  {
13076  free( arg17 );
13077  }
13078  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13079  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13080  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13081  return resultobj;
13082 fail:
13083  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13084  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13085  {
13086  Py_DECREF( tmp15 );
13087  }
13088  {
13089  Py_DECREF( tmp16 );
13090  }
13091  {
13092  free( arg17 );
13093  }
13094  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13095  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13096  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13097  return NULL;
13098 }
13099 
13100 
13101 SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13102  PyObject *resultobj = 0;
13103  PLINT arg1 ;
13104  int val1 ;
13105  int ecode1 = 0 ;
13106  PyObject * obj0 = 0 ;
13107 
13108  if (!PyArg_ParseTuple(args,(char *)"O:plstripd",&obj0)) SWIG_fail;
13109  ecode1 = SWIG_AsVal_int(obj0, &val1);
13110  if (!SWIG_IsOK(ecode1)) {
13111  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13112  }
13113  arg1 = (PLINT)(val1);
13114  plstripd(arg1);
13115  resultobj = SWIG_Py_Void();
13116  return resultobj;
13117 fail:
13118  return NULL;
13119 }
13120 
13121 
13122 SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13123  PyObject *resultobj = 0;
13124  PLINT arg1 ;
13125  PLINT *arg2 = (PLINT *) 0 ;
13126  PLINT *arg3 = (PLINT *) 0 ;
13127  PyArrayObject *tmp1 ;
13128  PyArrayObject *tmp3 ;
13129  PyObject * obj0 = 0 ;
13130  PyObject * obj1 = 0 ;
13131 
13132  if (!PyArg_ParseTuple(args,(char *)"OO:plstyl",&obj0,&obj1)) SWIG_fail;
13133  {
13134  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
13135  if ( tmp1 == NULL )
13136  return NULL;
13137  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13138  arg2 = (PLINT *) PyArray_DATA( tmp1 );
13139  }
13140  {
13141  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
13142  if ( tmp3 == NULL )
13143  return NULL;
13144  if ( PyArray_DIMS( tmp3 )[0] != Alen )
13145  {
13146  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13147  return NULL;
13148  }
13149  arg3 = (PLINT *) PyArray_DATA( tmp3 );
13150  }
13151  plstyl(arg1,(int const *)arg2,(int const *)arg3);
13152  resultobj = SWIG_Py_Void();
13153  {
13154  Py_DECREF( tmp1 );
13155  }
13156  {
13157  Py_DECREF( tmp3 );
13158  }
13159  return resultobj;
13160 fail:
13161  {
13162  Py_DECREF( tmp1 );
13163  }
13164  {
13165  Py_DECREF( tmp3 );
13166  }
13167  return NULL;
13168 }
13169 
13170 
13171 SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13172  PyObject *resultobj = 0;
13173  PLFLT *arg1 = (PLFLT *) 0 ;
13174  PLFLT *arg2 = (PLFLT *) 0 ;
13175  PLINT arg3 ;
13176  PLBOOL arg4 ;
13177  PyArrayObject *tmp1 ;
13178  PyArrayObject *tmp2 ;
13179  int val4 ;
13180  int ecode4 = 0 ;
13181  PyObject * obj0 = 0 ;
13182  PyObject * obj1 = 0 ;
13183  PyObject * obj2 = 0 ;
13184 
13185  if (!PyArg_ParseTuple(args,(char *)"OOO:plsvect",&obj0,&obj1,&obj2)) SWIG_fail;
13186  {
13187  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13188  if ( tmp1 == NULL )
13189  return NULL;
13190  Alen = PyArray_DIMS( tmp1 )[0];
13191  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13192  }
13193  {
13194  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13195  if ( tmp2 == NULL )
13196  return NULL;
13197  if ( PyArray_DIMS( tmp2 )[0] != Alen )
13198  {
13199  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13200  return NULL;
13201  }
13202  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13203  arg3 = PyArray_DIMS( tmp2 )[0];
13204  }
13205  ecode4 = SWIG_AsVal_int(obj2, &val4);
13206  if (!SWIG_IsOK(ecode4)) {
13207  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13208  }
13209  arg4 = (PLBOOL)(val4);
13210  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13211  resultobj = SWIG_Py_Void();
13212  {
13213  Py_DECREF( tmp1 );
13214  }
13215  {
13216  Py_DECREF( tmp2 );
13217  }
13218  return resultobj;
13219 fail:
13220  {
13221  Py_DECREF( tmp1 );
13222  }
13223  {
13224  Py_DECREF( tmp2 );
13225  }
13226  return NULL;
13227 }
13228 
13229 
13230 SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13231  PyObject *resultobj = 0;
13232  PLFLT arg1 ;
13233  PLFLT arg2 ;
13234  PLFLT arg3 ;
13235  PLFLT arg4 ;
13236  double val1 ;
13237  int ecode1 = 0 ;
13238  double val2 ;
13239  int ecode2 = 0 ;
13240  double val3 ;
13241  int ecode3 = 0 ;
13242  double val4 ;
13243  int ecode4 = 0 ;
13244  PyObject * obj0 = 0 ;
13245  PyObject * obj1 = 0 ;
13246  PyObject * obj2 = 0 ;
13247  PyObject * obj3 = 0 ;
13248 
13249  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13250  ecode1 = SWIG_AsVal_double(obj0, &val1);
13251  if (!SWIG_IsOK(ecode1)) {
13252  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13253  }
13254  arg1 = (PLFLT)(val1);
13255  ecode2 = SWIG_AsVal_double(obj1, &val2);
13256  if (!SWIG_IsOK(ecode2)) {
13257  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13258  }
13259  arg2 = (PLFLT)(val2);
13260  ecode3 = SWIG_AsVal_double(obj2, &val3);
13261  if (!SWIG_IsOK(ecode3)) {
13262  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13263  }
13264  arg3 = (PLFLT)(val3);
13265  ecode4 = SWIG_AsVal_double(obj3, &val4);
13266  if (!SWIG_IsOK(ecode4)) {
13267  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13268  }
13269  arg4 = (PLFLT)(val4);
13270  plsvpa(arg1,arg2,arg3,arg4);
13271  resultobj = SWIG_Py_Void();
13272  return resultobj;
13273 fail:
13274  return NULL;
13275 }
13276 
13277 
13278 SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13279  PyObject *resultobj = 0;
13280  PLINT arg1 ;
13281  PLINT arg2 ;
13282  int val1 ;
13283  int ecode1 = 0 ;
13284  int val2 ;
13285  int ecode2 = 0 ;
13286  PyObject * obj0 = 0 ;
13287  PyObject * obj1 = 0 ;
13288 
13289  if (!PyArg_ParseTuple(args,(char *)"OO:plsxax",&obj0,&obj1)) SWIG_fail;
13290  ecode1 = SWIG_AsVal_int(obj0, &val1);
13291  if (!SWIG_IsOK(ecode1)) {
13292  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13293  }
13294  arg1 = (PLINT)(val1);
13295  ecode2 = SWIG_AsVal_int(obj1, &val2);
13296  if (!SWIG_IsOK(ecode2)) {
13297  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13298  }
13299  arg2 = (PLINT)(val2);
13300  plsxax(arg1,arg2);
13301  resultobj = SWIG_Py_Void();
13302  return resultobj;
13303 fail:
13304  return NULL;
13305 }
13306 
13307 
13308 SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13309  PyObject *resultobj = 0;
13310  PLINT arg1 ;
13311  PLINT arg2 ;
13312  int val1 ;
13313  int ecode1 = 0 ;
13314  int val2 ;
13315  int ecode2 = 0 ;
13316  PyObject * obj0 = 0 ;
13317  PyObject * obj1 = 0 ;
13318 
13319  if (!PyArg_ParseTuple(args,(char *)"OO:plsyax",&obj0,&obj1)) SWIG_fail;
13320  ecode1 = SWIG_AsVal_int(obj0, &val1);
13321  if (!SWIG_IsOK(ecode1)) {
13322  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13323  }
13324  arg1 = (PLINT)(val1);
13325  ecode2 = SWIG_AsVal_int(obj1, &val2);
13326  if (!SWIG_IsOK(ecode2)) {
13327  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13328  }
13329  arg2 = (PLINT)(val2);
13330  plsyax(arg1,arg2);
13331  resultobj = SWIG_Py_Void();
13332  return resultobj;
13333 fail:
13334  return NULL;
13335 }
13336 
13337 
13338 SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13339  PyObject *resultobj = 0;
13340  PLINT arg1 ;
13341  PLFLT *arg2 = (PLFLT *) 0 ;
13342  PLFLT *arg3 = (PLFLT *) 0 ;
13343  PLINT arg4 ;
13344  PyArrayObject *tmp1 ;
13345  PyArrayObject *tmp3 ;
13346  int val4 ;
13347  int ecode4 = 0 ;
13348  PyObject * obj0 = 0 ;
13349  PyObject * obj1 = 0 ;
13350  PyObject * obj2 = 0 ;
13351 
13352  if (!PyArg_ParseTuple(args,(char *)"OOO:plsym",&obj0,&obj1,&obj2)) SWIG_fail;
13353  {
13354  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13355  if ( tmp1 == NULL )
13356  return NULL;
13357  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13358  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13359  }
13360  {
13361  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13362  if ( tmp3 == NULL )
13363  return NULL;
13364  if ( PyArray_DIMS( tmp3 )[0] != Alen )
13365  {
13366  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13367  return NULL;
13368  }
13369  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13370  }
13371  ecode4 = SWIG_AsVal_int(obj2, &val4);
13372  if (!SWIG_IsOK(ecode4)) {
13373  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13374  }
13375  arg4 = (PLINT)(val4);
13376  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13377  resultobj = SWIG_Py_Void();
13378  {
13379  Py_DECREF( tmp1 );
13380  }
13381  {
13382  Py_DECREF( tmp3 );
13383  }
13384  return resultobj;
13385 fail:
13386  {
13387  Py_DECREF( tmp1 );
13388  }
13389  {
13390  Py_DECREF( tmp3 );
13391  }
13392  return NULL;
13393 }
13394 
13395 
13396 SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13397  PyObject *resultobj = 0;
13398  PLINT arg1 ;
13399  PLINT arg2 ;
13400  int val1 ;
13401  int ecode1 = 0 ;
13402  int val2 ;
13403  int ecode2 = 0 ;
13404  PyObject * obj0 = 0 ;
13405  PyObject * obj1 = 0 ;
13406 
13407  if (!PyArg_ParseTuple(args,(char *)"OO:plszax",&obj0,&obj1)) SWIG_fail;
13408  ecode1 = SWIG_AsVal_int(obj0, &val1);
13409  if (!SWIG_IsOK(ecode1)) {
13410  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13411  }
13412  arg1 = (PLINT)(val1);
13413  ecode2 = SWIG_AsVal_int(obj1, &val2);
13414  if (!SWIG_IsOK(ecode2)) {
13415  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13416  }
13417  arg2 = (PLINT)(val2);
13418  plszax(arg1,arg2);
13419  resultobj = SWIG_Py_Void();
13420  return resultobj;
13421 fail:
13422  return NULL;
13423 }
13424 
13425 
13426 SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13427  PyObject *resultobj = 0;
13428 
13429  if (!PyArg_ParseTuple(args,(char *)":pltext")) SWIG_fail;
13430  pltext();
13431  resultobj = SWIG_Py_Void();
13432  return resultobj;
13433 fail:
13434  return NULL;
13435 }
13436 
13437 
13438 SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13439  PyObject *resultobj = 0;
13440  char *arg1 = (char *) 0 ;
13441  int res1 ;
13442  char *buf1 = 0 ;
13443  int alloc1 = 0 ;
13444  PyObject * obj0 = 0 ;
13445 
13446  if (!PyArg_ParseTuple(args,(char *)"O:pltimefmt",&obj0)) SWIG_fail;
13447  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
13448  if (!SWIG_IsOK(res1)) {
13449  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13450  }
13451  arg1 = (char *)(buf1);
13452  pltimefmt((char const *)arg1);
13453  resultobj = SWIG_Py_Void();
13454  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13455  return resultobj;
13456 fail:
13457  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13458  return NULL;
13459 }
13460 
13461 
13462 SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13463  PyObject *resultobj = 0;
13464  PLFLT arg1 ;
13465  double val1 ;
13466  int ecode1 = 0 ;
13467  PyObject * obj0 = 0 ;
13468 
13469  if (!PyArg_ParseTuple(args,(char *)"O:plvasp",&obj0)) SWIG_fail;
13470  ecode1 = SWIG_AsVal_double(obj0, &val1);
13471  if (!SWIG_IsOK(ecode1)) {
13472  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13473  }
13474  arg1 = (PLFLT)(val1);
13475  plvasp(arg1);
13476  resultobj = SWIG_Py_Void();
13477  return resultobj;
13478 fail:
13479  return NULL;
13480 }
13481 
13482 
13483 SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13484  PyObject *resultobj = 0;
13485  PLFLT **arg1 = (PLFLT **) 0 ;
13486  PLFLT **arg2 = (PLFLT **) 0 ;
13487  PLINT arg3 ;
13488  PLINT arg4 ;
13489  PLFLT arg5 ;
13490  pltr_func arg6 = (pltr_func) 0 ;
13491  PLPointer arg7 = (PLPointer) 0 ;
13492  PyArrayObject *tmp1 ;
13493  PyArrayObject *tmp2 ;
13494  double val5 ;
13495  int ecode5 = 0 ;
13496  PyObject * obj0 = 0 ;
13497  PyObject * obj1 = 0 ;
13498  PyObject * obj2 = 0 ;
13499  PyObject * obj3 = 0 ;
13500  PyObject * obj4 = 0 ;
13501 
13502  {
13503  python_pltr = 0;
13504  arg6 = NULL;
13505  }
13506  {
13507  arg7 = NULL;
13508  }
13509  if (!PyArg_ParseTuple(args,(char *)"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13510  {
13511  int i, size;
13512  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
13513  if ( tmp1 == NULL )
13514  return NULL;
13515  Xlen = PyArray_DIMS( tmp1 )[0];
13516  Ylen = PyArray_DIMS( tmp1 )[1];
13517  size = sizeof ( PLFLT ) * Ylen;
13518  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * Xlen );
13519  for ( i = 0; i < Xlen; i++ )
13520  arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
13521  }
13522  {
13523  int i, size;
13524  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 2, 2 );
13525  if ( tmp2 == NULL )
13526  return NULL;
13527  if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13528  {
13529  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13530  return NULL;
13531  }
13532  arg3 = PyArray_DIMS( tmp2 )[0];
13533  arg4 = PyArray_DIMS( tmp2 )[1];
13534  size = sizeof ( PLFLT ) * arg4;
13535  arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg3 );
13536  for ( i = 0; i < arg3; i++ )
13537  arg2[i] = (PLFLT *) ( PyArray_DATA( tmp2 ) + i * size );
13538  }
13539  ecode5 = SWIG_AsVal_double(obj2, &val5);
13540  if (!SWIG_IsOK(ecode5)) {
13541  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13542  }
13543  arg5 = (PLFLT)(val5);
13544  if (obj3) {
13545  {
13546  // it must be a callable or None
13547  if ( obj3 == Py_None )
13548  {
13549  arg6 = NULL;
13550  }
13551  else
13552  {
13553  if ( !PyCallable_Check( (PyObject *) obj3 ) )
13554  {
13555  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13556  return NULL;
13557  }
13558  arg6 = marshal_pltr( obj3 );
13559  }
13560  }
13561  }
13562  if (obj4) {
13563  {
13564  if ( obj4 == Py_None )
13565  arg7 = NULL;
13566  else
13567  {
13568  arg7 = marshal_PLPointer( obj4, 0 );
13569  }
13570  }
13571  }
13572  plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13573  resultobj = SWIG_Py_Void();
13574  {
13575  Py_DECREF( tmp1 );
13576  free( arg1 );
13577  }
13578  {
13579  Py_DECREF( tmp2 );
13580  free( arg2 );
13581  }
13582  {
13583  cleanup_pltr();
13584  }
13585  {
13587  }
13588  return resultobj;
13589 fail:
13590  {
13591  Py_DECREF( tmp1 );
13592  free( arg1 );
13593  }
13594  {
13595  Py_DECREF( tmp2 );
13596  free( arg2 );
13597  }
13598  {
13599  cleanup_pltr();
13600  }
13601  {
13603  }
13604  return NULL;
13605 }
13606 
13607 
13608 SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13609  PyObject *resultobj = 0;
13610  PLFLT arg1 ;
13611  PLFLT arg2 ;
13612  PLFLT arg3 ;
13613  PLFLT arg4 ;
13614  PLFLT arg5 ;
13615  double val1 ;
13616  int ecode1 = 0 ;
13617  double val2 ;
13618  int ecode2 = 0 ;
13619  double val3 ;
13620  int ecode3 = 0 ;
13621  double val4 ;
13622  int ecode4 = 0 ;
13623  double val5 ;
13624  int ecode5 = 0 ;
13625  PyObject * obj0 = 0 ;
13626  PyObject * obj1 = 0 ;
13627  PyObject * obj2 = 0 ;
13628  PyObject * obj3 = 0 ;
13629  PyObject * obj4 = 0 ;
13630 
13631  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13632  ecode1 = SWIG_AsVal_double(obj0, &val1);
13633  if (!SWIG_IsOK(ecode1)) {
13634  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13635  }
13636  arg1 = (PLFLT)(val1);
13637  ecode2 = SWIG_AsVal_double(obj1, &val2);
13638  if (!SWIG_IsOK(ecode2)) {
13639  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13640  }
13641  arg2 = (PLFLT)(val2);
13642  ecode3 = SWIG_AsVal_double(obj2, &val3);
13643  if (!SWIG_IsOK(ecode3)) {
13644  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13645  }
13646  arg3 = (PLFLT)(val3);
13647  ecode4 = SWIG_AsVal_double(obj3, &val4);
13648  if (!SWIG_IsOK(ecode4)) {
13649  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13650  }
13651  arg4 = (PLFLT)(val4);
13652  ecode5 = SWIG_AsVal_double(obj4, &val5);
13653  if (!SWIG_IsOK(ecode5)) {
13654  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13655  }
13656  arg5 = (PLFLT)(val5);
13657  plvpas(arg1,arg2,arg3,arg4,arg5);
13658  resultobj = SWIG_Py_Void();
13659  return resultobj;
13660 fail:
13661  return NULL;
13662 }
13663 
13664 
13665 SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13666  PyObject *resultobj = 0;
13667  PLFLT arg1 ;
13668  PLFLT arg2 ;
13669  PLFLT arg3 ;
13670  PLFLT arg4 ;
13671  double val1 ;
13672  int ecode1 = 0 ;
13673  double val2 ;
13674  int ecode2 = 0 ;
13675  double val3 ;
13676  int ecode3 = 0 ;
13677  double val4 ;
13678  int ecode4 = 0 ;
13679  PyObject * obj0 = 0 ;
13680  PyObject * obj1 = 0 ;
13681  PyObject * obj2 = 0 ;
13682  PyObject * obj3 = 0 ;
13683 
13684  if (!PyArg_ParseTuple(args,(char *)"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13685  ecode1 = SWIG_AsVal_double(obj0, &val1);
13686  if (!SWIG_IsOK(ecode1)) {
13687  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13688  }
13689  arg1 = (PLFLT)(val1);
13690  ecode2 = SWIG_AsVal_double(obj1, &val2);
13691  if (!SWIG_IsOK(ecode2)) {
13692  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13693  }
13694  arg2 = (PLFLT)(val2);
13695  ecode3 = SWIG_AsVal_double(obj2, &val3);
13696  if (!SWIG_IsOK(ecode3)) {
13697  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
13698  }
13699  arg3 = (PLFLT)(val3);
13700  ecode4 = SWIG_AsVal_double(obj3, &val4);
13701  if (!SWIG_IsOK(ecode4)) {
13702  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
13703  }
13704  arg4 = (PLFLT)(val4);
13705  plvpor(arg1,arg2,arg3,arg4);
13706  resultobj = SWIG_Py_Void();
13707  return resultobj;
13708 fail:
13709  return NULL;
13710 }
13711 
13712 
13713 SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13714  PyObject *resultobj = 0;
13715 
13716  if (!PyArg_ParseTuple(args,(char *)":plvsta")) SWIG_fail;
13717  plvsta();
13718  resultobj = SWIG_Py_Void();
13719  return resultobj;
13720 fail:
13721  return NULL;
13722 }
13723 
13724 
13725 SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13726  PyObject *resultobj = 0;
13727  PLFLT arg1 ;
13728  PLFLT arg2 ;
13729  PLFLT arg3 ;
13730  PLFLT arg4 ;
13731  PLFLT arg5 ;
13732  PLFLT arg6 ;
13733  PLFLT arg7 ;
13734  PLFLT arg8 ;
13735  PLFLT arg9 ;
13736  PLFLT arg10 ;
13737  PLFLT arg11 ;
13738  double val1 ;
13739  int ecode1 = 0 ;
13740  double val2 ;
13741  int ecode2 = 0 ;
13742  double val3 ;
13743  int ecode3 = 0 ;
13744  double val4 ;
13745  int ecode4 = 0 ;
13746  double val5 ;
13747  int ecode5 = 0 ;
13748  double val6 ;
13749  int ecode6 = 0 ;
13750  double val7 ;
13751  int ecode7 = 0 ;
13752  double val8 ;
13753  int ecode8 = 0 ;
13754  double val9 ;
13755  int ecode9 = 0 ;
13756  double val10 ;
13757  int ecode10 = 0 ;
13758  double val11 ;
13759  int ecode11 = 0 ;
13760  PyObject * obj0 = 0 ;
13761  PyObject * obj1 = 0 ;
13762  PyObject * obj2 = 0 ;
13763  PyObject * obj3 = 0 ;
13764  PyObject * obj4 = 0 ;
13765  PyObject * obj5 = 0 ;
13766  PyObject * obj6 = 0 ;
13767  PyObject * obj7 = 0 ;
13768  PyObject * obj8 = 0 ;
13769  PyObject * obj9 = 0 ;
13770  PyObject * obj10 = 0 ;
13771 
13772  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
13773  ecode1 = SWIG_AsVal_double(obj0, &val1);
13774  if (!SWIG_IsOK(ecode1)) {
13775  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
13776  }
13777  arg1 = (PLFLT)(val1);
13778  ecode2 = SWIG_AsVal_double(obj1, &val2);
13779  if (!SWIG_IsOK(ecode2)) {
13780  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
13781  }
13782  arg2 = (PLFLT)(val2);
13783  ecode3 = SWIG_AsVal_double(obj2, &val3);
13784  if (!SWIG_IsOK(ecode3)) {
13785  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
13786  }
13787  arg3 = (PLFLT)(val3);
13788  ecode4 = SWIG_AsVal_double(obj3, &val4);
13789  if (!SWIG_IsOK(ecode4)) {
13790  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
13791  }
13792  arg4 = (PLFLT)(val4);
13793  ecode5 = SWIG_AsVal_double(obj4, &val5);
13794  if (!SWIG_IsOK(ecode5)) {
13795  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
13796  }
13797  arg5 = (PLFLT)(val5);
13798  ecode6 = SWIG_AsVal_double(obj5, &val6);
13799  if (!SWIG_IsOK(ecode6)) {
13800  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
13801  }
13802  arg6 = (PLFLT)(val6);
13803  ecode7 = SWIG_AsVal_double(obj6, &val7);
13804  if (!SWIG_IsOK(ecode7)) {
13805  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
13806  }
13807  arg7 = (PLFLT)(val7);
13808  ecode8 = SWIG_AsVal_double(obj7, &val8);
13809  if (!SWIG_IsOK(ecode8)) {
13810  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
13811  }
13812  arg8 = (PLFLT)(val8);
13813  ecode9 = SWIG_AsVal_double(obj8, &val9);
13814  if (!SWIG_IsOK(ecode9)) {
13815  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
13816  }
13817  arg9 = (PLFLT)(val9);
13818  ecode10 = SWIG_AsVal_double(obj9, &val10);
13819  if (!SWIG_IsOK(ecode10)) {
13820  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
13821  }
13822  arg10 = (PLFLT)(val10);
13823  ecode11 = SWIG_AsVal_double(obj10, &val11);
13824  if (!SWIG_IsOK(ecode11)) {
13825  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
13826  }
13827  arg11 = (PLFLT)(val11);
13828  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13829  resultobj = SWIG_Py_Void();
13830  return resultobj;
13831 fail:
13832  return NULL;
13833 }
13834 
13835 
13836 SWIGINTERN PyObject *_wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13837  PyObject *resultobj = 0;
13838  PLINT arg1 ;
13839  int val1 ;
13840  int ecode1 = 0 ;
13841  PyObject * obj0 = 0 ;
13842 
13843  if (!PyArg_ParseTuple(args,(char *)"O:plwidth",&obj0)) SWIG_fail;
13844  ecode1 = SWIG_AsVal_int(obj0, &val1);
13845  if (!SWIG_IsOK(ecode1)) {
13846  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLINT""'");
13847  }
13848  arg1 = (PLINT)(val1);
13849  plwidth(arg1);
13850  resultobj = SWIG_Py_Void();
13851  return resultobj;
13852 fail:
13853  return NULL;
13854 }
13855 
13856 
13857 SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13858  PyObject *resultobj = 0;
13859  PLFLT arg1 ;
13860  PLFLT arg2 ;
13861  PLFLT arg3 ;
13862  PLFLT arg4 ;
13863  double val1 ;
13864  int ecode1 = 0 ;
13865  double val2 ;
13866  int ecode2 = 0 ;
13867  double val3 ;
13868  int ecode3 = 0 ;
13869  double val4 ;
13870  int ecode4 = 0 ;
13871  PyObject * obj0 = 0 ;
13872  PyObject * obj1 = 0 ;
13873  PyObject * obj2 = 0 ;
13874  PyObject * obj3 = 0 ;
13875 
13876  if (!PyArg_ParseTuple(args,(char *)"OOOO:plwind",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13877  ecode1 = SWIG_AsVal_double(obj0, &val1);
13878  if (!SWIG_IsOK(ecode1)) {
13879  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
13880  }
13881  arg1 = (PLFLT)(val1);
13882  ecode2 = SWIG_AsVal_double(obj1, &val2);
13883  if (!SWIG_IsOK(ecode2)) {
13884  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
13885  }
13886  arg2 = (PLFLT)(val2);
13887  ecode3 = SWIG_AsVal_double(obj2, &val3);
13888  if (!SWIG_IsOK(ecode3)) {
13889  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
13890  }
13891  arg3 = (PLFLT)(val3);
13892  ecode4 = SWIG_AsVal_double(obj3, &val4);
13893  if (!SWIG_IsOK(ecode4)) {
13894  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
13895  }
13896  arg4 = (PLFLT)(val4);
13897  plwind(arg1,arg2,arg3,arg4);
13898  resultobj = SWIG_Py_Void();
13899  return resultobj;
13900 fail:
13901  return NULL;
13902 }
13903 
13904 
13905 SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13906  PyObject *resultobj = 0;
13907  PLBOOL arg1 ;
13908  PLBOOL *arg2 = (PLBOOL *) 0 ;
13909  int val1 ;
13910  int ecode1 = 0 ;
13911  PLBOOL temp2 ;
13912  int res2 = SWIG_TMPOBJ ;
13913  PyObject * obj0 = 0 ;
13914 
13915  arg2 = &temp2;
13916  if (!PyArg_ParseTuple(args,(char *)"O:plxormod",&obj0)) SWIG_fail;
13917  ecode1 = SWIG_AsVal_int(obj0, &val1);
13918  if (!SWIG_IsOK(ecode1)) {
13919  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
13920  }
13921  arg1 = (PLBOOL)(val1);
13922  plxormod(arg1,arg2);
13923  resultobj = SWIG_Py_Void();
13924  if (SWIG_IsTmpObj(res2)) {
13925  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13926  } else {
13927  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13928  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13929  }
13930  return resultobj;
13931 fail:
13932  return NULL;
13933 }
13934 
13935 
13936 SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13937  PyObject *resultobj = 0;
13938  mapform_func arg1 = (mapform_func) 0 ;
13939  char *arg2 = (char *) 0 ;
13940  PLFLT arg3 ;
13941  PLFLT arg4 ;
13942  PLFLT arg5 ;
13943  PLFLT arg6 ;
13944  int res2 ;
13945  char *buf2 = 0 ;
13946  int alloc2 = 0 ;
13947  double val3 ;
13948  int ecode3 = 0 ;
13949  double val4 ;
13950  int ecode4 = 0 ;
13951  double val5 ;
13952  int ecode5 = 0 ;
13953  double val6 ;
13954  int ecode6 = 0 ;
13955  PyObject * obj0 = 0 ;
13956  PyObject * obj1 = 0 ;
13957  PyObject * obj2 = 0 ;
13958  PyObject * obj3 = 0 ;
13959  PyObject * obj4 = 0 ;
13960  PyObject * obj5 = 0 ;
13961 
13962  {
13963  python_mapform = 0;
13964  arg1 = NULL;
13965  }
13966  if (!PyArg_ParseTuple(args,(char *)"|OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13967  if (obj0) {
13968  {
13969  // it must be a callable or none
13970  if ( obj0 == Py_None )
13971  {
13972  arg1 = NULL;
13973  }
13974  else
13975  {
13976  if ( !PyCallable_Check( (PyObject *) obj0 ) )
13977  {
13978  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13979  return NULL;
13980  }
13981  arg1 = marshal_mapform( obj0 );
13982  }
13983  }
13984  }
13985  if (obj1) {
13986  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
13987  if (!SWIG_IsOK(res2)) {
13988  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
13989  }
13990  arg2 = (char *)(buf2);
13991  }
13992  if (obj2) {
13993  ecode3 = SWIG_AsVal_double(obj2, &val3);
13994  if (!SWIG_IsOK(ecode3)) {
13995  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
13996  }
13997  arg3 = (PLFLT)(val3);
13998  }
13999  if (obj3) {
14000  ecode4 = SWIG_AsVal_double(obj3, &val4);
14001  if (!SWIG_IsOK(ecode4)) {
14002  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14003  }
14004  arg4 = (PLFLT)(val4);
14005  }
14006  if (obj4) {
14007  ecode5 = SWIG_AsVal_double(obj4, &val5);
14008  if (!SWIG_IsOK(ecode5)) {
14009  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14010  }
14011  arg5 = (PLFLT)(val5);
14012  }
14013  if (obj5) {
14014  ecode6 = SWIG_AsVal_double(obj5, &val6);
14015  if (!SWIG_IsOK(ecode6)) {
14016  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14017  }
14018  arg6 = (PLFLT)(val6);
14019  }
14020  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14021  resultobj = SWIG_Py_Void();
14022  {
14023  cleanup_mapform();
14024  }
14025  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14026  return resultobj;
14027 fail:
14028  {
14029  cleanup_mapform();
14030  }
14031  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14032  return NULL;
14033 }
14034 
14035 
14036 SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14037  PyObject *resultobj = 0;
14038  mapform_func arg1 = (mapform_func) 0 ;
14039  PLFLT arg2 ;
14040  PLFLT arg3 ;
14041  PLFLT arg4 ;
14042  PLFLT arg5 ;
14043  PLFLT arg6 ;
14044  PLFLT arg7 ;
14045  double val2 ;
14046  int ecode2 = 0 ;
14047  double val3 ;
14048  int ecode3 = 0 ;
14049  double val4 ;
14050  int ecode4 = 0 ;
14051  double val5 ;
14052  int ecode5 = 0 ;
14053  double val6 ;
14054  int ecode6 = 0 ;
14055  double val7 ;
14056  int ecode7 = 0 ;
14057  PyObject * obj0 = 0 ;
14058  PyObject * obj1 = 0 ;
14059  PyObject * obj2 = 0 ;
14060  PyObject * obj3 = 0 ;
14061  PyObject * obj4 = 0 ;
14062  PyObject * obj5 = 0 ;
14063  PyObject * obj6 = 0 ;
14064 
14065  {
14066  python_mapform = 0;
14067  arg1 = NULL;
14068  }
14069  if (!PyArg_ParseTuple(args,(char *)"|OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14070  if (obj0) {
14071  {
14072  // it must be a callable or none
14073  if ( obj0 == Py_None )
14074  {
14075  arg1 = NULL;
14076  }
14077  else
14078  {
14079  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14080  {
14081  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14082  return NULL;
14083  }
14084  arg1 = marshal_mapform( obj0 );
14085  }
14086  }
14087  }
14088  if (obj1) {
14089  ecode2 = SWIG_AsVal_double(obj1, &val2);
14090  if (!SWIG_IsOK(ecode2)) {
14091  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14092  }
14093  arg2 = (PLFLT)(val2);
14094  }
14095  if (obj2) {
14096  ecode3 = SWIG_AsVal_double(obj2, &val3);
14097  if (!SWIG_IsOK(ecode3)) {
14098  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14099  }
14100  arg3 = (PLFLT)(val3);
14101  }
14102  if (obj3) {
14103  ecode4 = SWIG_AsVal_double(obj3, &val4);
14104  if (!SWIG_IsOK(ecode4)) {
14105  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14106  }
14107  arg4 = (PLFLT)(val4);
14108  }
14109  if (obj4) {
14110  ecode5 = SWIG_AsVal_double(obj4, &val5);
14111  if (!SWIG_IsOK(ecode5)) {
14112  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14113  }
14114  arg5 = (PLFLT)(val5);
14115  }
14116  if (obj5) {
14117  ecode6 = SWIG_AsVal_double(obj5, &val6);
14118  if (!SWIG_IsOK(ecode6)) {
14119  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14120  }
14121  arg6 = (PLFLT)(val6);
14122  }
14123  if (obj6) {
14124  ecode7 = SWIG_AsVal_double(obj6, &val7);
14125  if (!SWIG_IsOK(ecode7)) {
14126  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14127  }
14128  arg7 = (PLFLT)(val7);
14129  }
14130  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14131  resultobj = SWIG_Py_Void();
14132  {
14133  cleanup_mapform();
14134  }
14135  return resultobj;
14136 fail:
14137  {
14138  cleanup_mapform();
14139  }
14140  return NULL;
14141 }
14142 
14143 
14144 SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14145  PyObject *resultobj = 0;
14146  PLFLT **arg1 = (PLFLT **) 0 ;
14147  PLINT arg2 ;
14148  PLINT arg3 ;
14149  PLFLT arg4 ;
14150  PLFLT arg5 ;
14151  PLFLT arg6 ;
14152  PLFLT arg7 ;
14153  PLFLT arg8 ;
14154  PLFLT arg9 ;
14155  PLFLT arg10 ;
14156  PLFLT arg11 ;
14157  PLFLT arg12 ;
14158  PLFLT arg13 ;
14159  PyArrayObject *tmp1 ;
14160  double val4 ;
14161  int ecode4 = 0 ;
14162  double val5 ;
14163  int ecode5 = 0 ;
14164  double val6 ;
14165  int ecode6 = 0 ;
14166  double val7 ;
14167  int ecode7 = 0 ;
14168  double val8 ;
14169  int ecode8 = 0 ;
14170  double val9 ;
14171  int ecode9 = 0 ;
14172  double val10 ;
14173  int ecode10 = 0 ;
14174  double val11 ;
14175  int ecode11 = 0 ;
14176  double val12 ;
14177  int ecode12 = 0 ;
14178  double val13 ;
14179  int ecode13 = 0 ;
14180  PyObject * obj0 = 0 ;
14181  PyObject * obj1 = 0 ;
14182  PyObject * obj2 = 0 ;
14183  PyObject * obj3 = 0 ;
14184  PyObject * obj4 = 0 ;
14185  PyObject * obj5 = 0 ;
14186  PyObject * obj6 = 0 ;
14187  PyObject * obj7 = 0 ;
14188  PyObject * obj8 = 0 ;
14189  PyObject * obj9 = 0 ;
14190  PyObject * obj10 = 0 ;
14191 
14192  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14193  {
14194  int i, size;
14195  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14196  if ( tmp1 == NULL )
14197  return NULL;
14198  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14199  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14200  size = sizeof ( PLFLT ) * arg3;
14201  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
14202  for ( i = 0; i < arg2; i++ )
14203  arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
14204  }
14205  ecode4 = SWIG_AsVal_double(obj1, &val4);
14206  if (!SWIG_IsOK(ecode4)) {
14207  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14208  }
14209  arg4 = (PLFLT)(val4);
14210  ecode5 = SWIG_AsVal_double(obj2, &val5);
14211  if (!SWIG_IsOK(ecode5)) {
14212  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14213  }
14214  arg5 = (PLFLT)(val5);
14215  ecode6 = SWIG_AsVal_double(obj3, &val6);
14216  if (!SWIG_IsOK(ecode6)) {
14217  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14218  }
14219  arg6 = (PLFLT)(val6);
14220  ecode7 = SWIG_AsVal_double(obj4, &val7);
14221  if (!SWIG_IsOK(ecode7)) {
14222  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14223  }
14224  arg7 = (PLFLT)(val7);
14225  ecode8 = SWIG_AsVal_double(obj5, &val8);
14226  if (!SWIG_IsOK(ecode8)) {
14227  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14228  }
14229  arg8 = (PLFLT)(val8);
14230  ecode9 = SWIG_AsVal_double(obj6, &val9);
14231  if (!SWIG_IsOK(ecode9)) {
14232  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14233  }
14234  arg9 = (PLFLT)(val9);
14235  ecode10 = SWIG_AsVal_double(obj7, &val10);
14236  if (!SWIG_IsOK(ecode10)) {
14237  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14238  }
14239  arg10 = (PLFLT)(val10);
14240  ecode11 = SWIG_AsVal_double(obj8, &val11);
14241  if (!SWIG_IsOK(ecode11)) {
14242  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14243  }
14244  arg11 = (PLFLT)(val11);
14245  ecode12 = SWIG_AsVal_double(obj9, &val12);
14246  if (!SWIG_IsOK(ecode12)) {
14247  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14248  }
14249  arg12 = (PLFLT)(val12);
14250  ecode13 = SWIG_AsVal_double(obj10, &val13);
14251  if (!SWIG_IsOK(ecode13)) {
14252  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14253  }
14254  arg13 = (PLFLT)(val13);
14255  plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14256  resultobj = SWIG_Py_Void();
14257  {
14258  Py_DECREF( tmp1 );
14259  free( arg1 );
14260  }
14261  return resultobj;
14262 fail:
14263  {
14264  Py_DECREF( tmp1 );
14265  free( arg1 );
14266  }
14267  return NULL;
14268 }
14269 
14270 
14271 SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14272  PyObject *resultobj = 0;
14273  PLFLT **arg1 = (PLFLT **) 0 ;
14274  PLINT arg2 ;
14275  PLINT arg3 ;
14276  PLFLT arg4 ;
14277  PLFLT arg5 ;
14278  PLFLT arg6 ;
14279  PLFLT arg7 ;
14280  PLFLT arg8 ;
14281  PLFLT arg9 ;
14282  PLFLT arg10 ;
14283  PLFLT arg11 ;
14284  pltr_func arg12 = (pltr_func) 0 ;
14285  PLPointer arg13 = (PLPointer) 0 ;
14286  PyArrayObject *tmp1 ;
14287  double val4 ;
14288  int ecode4 = 0 ;
14289  double val5 ;
14290  int ecode5 = 0 ;
14291  double val6 ;
14292  int ecode6 = 0 ;
14293  double val7 ;
14294  int ecode7 = 0 ;
14295  double val8 ;
14296  int ecode8 = 0 ;
14297  double val9 ;
14298  int ecode9 = 0 ;
14299  double val10 ;
14300  int ecode10 = 0 ;
14301  double val11 ;
14302  int ecode11 = 0 ;
14303  PyObject * obj0 = 0 ;
14304  PyObject * obj1 = 0 ;
14305  PyObject * obj2 = 0 ;
14306  PyObject * obj3 = 0 ;
14307  PyObject * obj4 = 0 ;
14308  PyObject * obj5 = 0 ;
14309  PyObject * obj6 = 0 ;
14310  PyObject * obj7 = 0 ;
14311  PyObject * obj8 = 0 ;
14312  PyObject * obj9 = 0 ;
14313  PyObject * obj10 = 0 ;
14314 
14315  {
14316  python_pltr = 0;
14317  arg12 = NULL;
14318  }
14319  {
14320  arg13 = NULL;
14321  }
14322  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14323  {
14324  int i, size;
14325  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14326  if ( tmp1 == NULL )
14327  return NULL;
14328  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14329  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14330  size = sizeof ( PLFLT ) * arg3;
14331  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
14332  for ( i = 0; i < arg2; i++ )
14333  arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
14334  }
14335  ecode4 = SWIG_AsVal_double(obj1, &val4);
14336  if (!SWIG_IsOK(ecode4)) {
14337  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14338  }
14339  arg4 = (PLFLT)(val4);
14340  ecode5 = SWIG_AsVal_double(obj2, &val5);
14341  if (!SWIG_IsOK(ecode5)) {
14342  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14343  }
14344  arg5 = (PLFLT)(val5);
14345  ecode6 = SWIG_AsVal_double(obj3, &val6);
14346  if (!SWIG_IsOK(ecode6)) {
14347  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14348  }
14349  arg6 = (PLFLT)(val6);
14350  ecode7 = SWIG_AsVal_double(obj4, &val7);
14351  if (!SWIG_IsOK(ecode7)) {
14352  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14353  }
14354  arg7 = (PLFLT)(val7);
14355  ecode8 = SWIG_AsVal_double(obj5, &val8);
14356  if (!SWIG_IsOK(ecode8)) {
14357  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14358  }
14359  arg8 = (PLFLT)(val8);
14360  ecode9 = SWIG_AsVal_double(obj6, &val9);
14361  if (!SWIG_IsOK(ecode9)) {
14362  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
14363  }
14364  arg9 = (PLFLT)(val9);
14365  ecode10 = SWIG_AsVal_double(obj7, &val10);
14366  if (!SWIG_IsOK(ecode10)) {
14367  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
14368  }
14369  arg10 = (PLFLT)(val10);
14370  ecode11 = SWIG_AsVal_double(obj8, &val11);
14371  if (!SWIG_IsOK(ecode11)) {
14372  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
14373  }
14374  arg11 = (PLFLT)(val11);
14375  if (obj9) {
14376  {
14377  // it must be a callable or None
14378  if ( obj9 == Py_None )
14379  {
14380  arg12 = NULL;
14381  }
14382  else
14383  {
14384  if ( !PyCallable_Check( (PyObject *) obj9 ) )
14385  {
14386  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
14387  return NULL;
14388  }
14389  arg12 = marshal_pltr( obj9 );
14390  }
14391  }
14392  }
14393  if (obj10) {
14394  {
14395  if ( obj10 == Py_None )
14396  arg13 = NULL;
14397  else
14398  {
14399  arg13 = marshal_PLPointer( obj10, 1 );
14400  }
14401  }
14402  }
14403  plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14404  resultobj = SWIG_Py_Void();
14405  {
14406  Py_DECREF( tmp1 );
14407  free( arg1 );
14408  }
14409  {
14410  cleanup_pltr();
14411  }
14412  {
14414  }
14415  return resultobj;
14416 fail:
14417  {
14418  Py_DECREF( tmp1 );
14419  free( arg1 );
14420  }
14421  {
14422  cleanup_pltr();
14423  }
14424  {
14426  }
14427  return NULL;
14428 }
14429 
14430 
14431 SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14432  PyObject *resultobj = 0;
14433 
14434  if (!PyArg_ParseTuple(args,(char *)":plClearOpts")) SWIG_fail;
14435  plClearOpts();
14436  resultobj = SWIG_Py_Void();
14437  return resultobj;
14438 fail:
14439  return NULL;
14440 }
14441 
14442 
14443 SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14444  PyObject *resultobj = 0;
14445 
14446  if (!PyArg_ParseTuple(args,(char *)":plResetOpts")) SWIG_fail;
14447  plResetOpts();
14448  resultobj = SWIG_Py_Void();
14449  return resultobj;
14450 fail:
14451  return NULL;
14452 }
14453 
14454 
14455 SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14456  PyObject *resultobj = 0;
14457  char *arg1 = (char *) 0 ;
14458  char *arg2 = (char *) 0 ;
14459  int res1 ;
14460  char *buf1 = 0 ;
14461  int alloc1 = 0 ;
14462  int res2 ;
14463  char *buf2 = 0 ;
14464  int alloc2 = 0 ;
14465  PyObject * obj0 = 0 ;
14466  PyObject * obj1 = 0 ;
14467 
14468  if (!PyArg_ParseTuple(args,(char *)"OO:plSetUsage",&obj0,&obj1)) SWIG_fail;
14469  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
14470  if (!SWIG_IsOK(res1)) {
14471  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
14472  }
14473  arg1 = (char *)(buf1);
14474  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14475  if (!SWIG_IsOK(res2)) {
14476  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
14477  }
14478  arg2 = (char *)(buf2);
14479  plSetUsage((char const *)arg1,(char const *)arg2);
14480  resultobj = SWIG_Py_Void();
14481  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14482  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14483  return resultobj;
14484 fail:
14485  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14486  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14487  return NULL;
14488 }
14489 
14490 
14491 SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14492  PyObject *resultobj = 0;
14493 
14494  if (!PyArg_ParseTuple(args,(char *)":plOptUsage")) SWIG_fail;
14495  plOptUsage();
14496  resultobj = SWIG_Py_Void();
14497  return resultobj;
14498 fail:
14499  return NULL;
14500 }
14501 
14502 
14503 SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14504  PyObject *resultobj = 0;
14505  PLFLT **arg1 = (PLFLT **) 0 ;
14506  PLINT arg2 ;
14507  PLINT arg3 ;
14508  PLFLT *arg4 = (PLFLT *) 0 ;
14509  PLFLT *arg5 = (PLFLT *) 0 ;
14510  PyArrayObject *tmp1 ;
14511  PLFLT temp4 ;
14512  int res4 = SWIG_TMPOBJ ;
14513  PLFLT temp5 ;
14514  int res5 = SWIG_TMPOBJ ;
14515  PyObject * obj0 = 0 ;
14516 
14517  arg4 = &temp4;
14518  arg5 = &temp5;
14519  if (!PyArg_ParseTuple(args,(char *)"O:plMinMax2dGrid",&obj0)) SWIG_fail;
14520  {
14521  int i, size;
14522  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14523  if ( tmp1 == NULL )
14524  return NULL;
14525  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14526  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14527  size = sizeof ( PLFLT ) * arg3;
14528  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
14529  for ( i = 0; i < arg2; i++ )
14530  arg1[i] = (PLFLT *) ( PyArray_DATA( tmp1 ) + i * size );
14531  }
14532  plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
14533  resultobj = SWIG_Py_Void();
14534  if (SWIG_IsTmpObj(res4)) {
14535  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
14536  } else {
14537  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14538  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14539  }
14540  if (SWIG_IsTmpObj(res5)) {
14541  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
14542  } else {
14543  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14544  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
14545  }
14546  {
14547  Py_DECREF( tmp1 );
14548  free( arg1 );
14549  }
14550  return resultobj;
14551 fail:
14552  {
14553  Py_DECREF( tmp1 );
14554  free( arg1 );
14555  }
14556  return NULL;
14557 }
14558 
14559 
14560 SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14561  PyObject *resultobj = 0;
14562  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14563  void *argp1 = 0 ;
14564  int res1 = 0 ;
14565  PyObject * obj0 = 0 ;
14566  PLINT result;
14567 
14568  if (!PyArg_ParseTuple(args,(char *)"O:plGetCursor",&obj0)) SWIG_fail;
14569  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14570  if (!SWIG_IsOK(res1)) {
14571  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14572  }
14573  arg1 = (PLGraphicsIn *)(argp1);
14574  result = (PLINT)plGetCursor(arg1);
14575  resultobj = SWIG_From_int((int)(result));
14576  return resultobj;
14577 fail:
14578  return NULL;
14579 }
14580 
14581 
14582 static PyMethodDef SwigMethods[] = {
14583  { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
14584  { (char *)"pltr0", _wrap_pltr0, METH_VARARGS, NULL},
14585  { (char *)"pltr1", _wrap_pltr1, METH_VARARGS, NULL},
14586  { (char *)"pltr2", _wrap_pltr2, METH_VARARGS, NULL},
14587  { (char *)"PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
14588  { (char *)"PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_VARARGS, NULL},
14589  { (char *)"PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
14590  { (char *)"PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_VARARGS, NULL},
14591  { (char *)"PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
14592  { (char *)"PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_VARARGS, NULL},
14593  { (char *)"PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
14594  { (char *)"PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_VARARGS, NULL},
14595  { (char *)"PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
14596  { (char *)"PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_VARARGS, NULL},
14597  { (char *)"PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
14598  { (char *)"PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_VARARGS, NULL},
14599  { (char *)"PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
14600  { (char *)"PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_VARARGS, NULL},
14601  { (char *)"PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
14602  { (char *)"PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_VARARGS, NULL},
14603  { (char *)"PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
14604  { (char *)"PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_VARARGS, NULL},
14605  { (char *)"PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
14606  { (char *)"PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_VARARGS, NULL},
14607  { (char *)"PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
14608  { (char *)"PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_VARARGS, NULL},
14609  { (char *)"PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
14610  { (char *)"PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_VARARGS, NULL},
14611  { (char *)"new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_VARARGS, NULL},
14612  { (char *)"delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_VARARGS, NULL},
14613  { (char *)"PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_VARARGS, NULL},
14614  { (char *)"plsxwin", _wrap_plsxwin, METH_VARARGS, NULL},
14615  { (char *)"pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, (char *)"\n"
14616  "Set format of numerical label for contours\n"
14617  "\n"
14618  "DESCRIPTION:\n"
14619  "\n"
14620  " Set format of numerical label for contours. \n"
14621  "\n"
14622  " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
14623  "\n"
14624  " This function is used example 9. \n"
14625  "\n"
14626  "\n"
14627  "\n"
14628  "SYNOPSIS:\n"
14629  "\n"
14630  "pl_setcontlabelformat(lexp, sigdig)\n"
14631  "\n"
14632  "ARGUMENTS:\n"
14633  "\n"
14634  " lexp (PLINT, input) : If the contour numerical label is greater\n"
14635  " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
14636  " format is used. Default value of lexp is 4. \n"
14637  "\n"
14638  " sigdig (PLINT, input) : Number of significant digits. Default\n"
14639  " value is 2. \n"
14640  "\n"
14641  ""},
14642  { (char *)"pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, (char *)"\n"
14643  "Set parameters of contour labelling other than format of numerical label\n"
14644  "\n"
14645  "DESCRIPTION:\n"
14646  "\n"
14647  " Set parameters of contour labelling other than those handled by\n"
14648  " pl_setcontlabelformat. \n"
14649  "\n"
14650  " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
14651  "\n"
14652  " This function is used in example 9. \n"
14653  "\n"
14654  "\n"
14655  "\n"
14656  "SYNOPSIS:\n"
14657  "\n"
14658  "pl_setcontlabelparam(offset, size, spacing, active)\n"
14659  "\n"
14660  "ARGUMENTS:\n"
14661  "\n"
14662  " offset (PLFLT, input) : Offset of label from contour line (if set\n"
14663  " to 0.0, labels are printed on the lines). Default value is 0.006. \n"
14664  "\n"
14665  " size (PLFLT, input) : Font height for contour labels (normalized). \n"
14666  " Default value is 0.3. \n"
14667  "\n"
14668  " spacing (PLFLT, input) : Spacing parameter for contour labels. \n"
14669  " Default value is 0.1. \n"
14670  "\n"
14671  " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
14672  " contour labels on. Default is off (0). \n"
14673  "\n"
14674  ""},
14675  { (char *)"pladv", _wrap_pladv, METH_VARARGS, (char *)"\n"
14676  "Advance the (sub-)page\n"
14677  "\n"
14678  "DESCRIPTION:\n"
14679  "\n"
14680  " Advances to the next subpage if sub=0, performing a page advance if\n"
14681  " there are no remaining subpages on the current page. If subpages\n"
14682  " aren't being used, pladv(0) will always advance the page. If sub>0,\n"
14683  " PLplot switches to the specified subpage. Note that this allows you\n"
14684  " to overwrite a plot on the specified subpage; if this is not what you\n"
14685  " intended, use pleop followed by plbop to first advance the page. This\n"
14686  " routine is called automatically (with sub=0) by plenv, but if plenv is\n"
14687  " not used, pladv must be called after initializing PLplot but before\n"
14688  " defining the viewport. \n"
14689  "\n"
14690  " Redacted form: pladv(sub)\n"
14691  "\n"
14692  " This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n"
14693  "\n"
14694  "\n"
14695  "\n"
14696  "SYNOPSIS:\n"
14697  "\n"
14698  "pladv(sub)\n"
14699  "\n"
14700  "ARGUMENTS:\n"
14701  "\n"
14702  " sub (PLINT, input) : Specifies the subpage number (starting from 1\n"
14703  " in the top left corner and increasing along the rows) to which to\n"
14704  " advance. Set to zero to advance to the next subpage. \n"
14705  "\n"
14706  ""},
14707  { (char *)"plarc", _wrap_plarc, METH_VARARGS, (char *)"\n"
14708  "Draw a circular or elliptical arc \n"
14709  "\n"
14710  "DESCRIPTION:\n"
14711  "\n"
14712  " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
14713  " semiminor axis b, starting at angle1 and ending at angle2. \n"
14714  "\n"
14715  " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
14716  " fill)\n"
14717  "\n"
14718  "\n"
14719  " This function is used in examples 3 and 27. \n"
14720  "\n"
14721  "\n"
14722  "\n"
14723  "SYNOPSIS:\n"
14724  "\n"
14725  "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
14726  "\n"
14727  "ARGUMENTS:\n"
14728  "\n"
14729  " x (PLFLT, input) : X coordinate of arc center. \n"
14730  "\n"
14731  " y (PLFLT, input) : Y coordinate of arc center. \n"
14732  "\n"
14733  " a (PLFLT, input) : Length of the semimajor axis of the arc. \n"
14734  "\n"
14735  " b (PLFLT, input) : Length of the semiminor axis of the arc. \n"
14736  "\n"
14737  " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
14738  " semimajor axis. \n"
14739  "\n"
14740  " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
14741  " semimajor axis. \n"
14742  "\n"
14743  " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
14744  " X-axis. \n"
14745  "\n"
14746  " fill (PLBOOL, input) : Draw a filled arc. \n"
14747  "\n"
14748  ""},
14749  { (char *)"plaxes", _wrap_plaxes, METH_VARARGS, (char *)"\n"
14750  "Draw a box with axes, etc. with arbitrary origin \n"
14751  "\n"
14752  "DESCRIPTION:\n"
14753  "\n"
14754  " Draws a box around the currently defined viewport with arbitrary\n"
14755  " world-coordinate origin specified by x0 and y0 and labels it with\n"
14756  " world coordinate values appropriate to the window. Thus plaxes should\n"
14757  " only be called after defining both viewport and window. The character\n"
14758  " strings xopt and yopt specify how the box should be drawn as described\n"
14759  " below. If ticks and/or subticks are to be drawn for a particular\n"
14760  " axis, the tick intervals and number of subintervals may be specified\n"
14761  " explicitly, or they may be defaulted by setting the appropriate\n"
14762  " arguments to zero. \n"
14763  "\n"
14764  " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
14765  " ytick, nysub)\n"
14766  " Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n"
14767  " yopt)\n"
14768  "\n"
14769  "\n"
14770  " This function is not used in any examples. \n"
14771  "\n"
14772  "\n"
14773  "\n"
14774  "SYNOPSIS:\n"
14775  "\n"
14776  "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14777  "\n"
14778  "ARGUMENTS:\n"
14779  "\n"
14780  " x0 (PLFLT, input) : World X coordinate of origin. \n"
14781  "\n"
14782  " y0 (PLFLT, input) : World Y coordinate of origin. \n"
14783  "\n"
14784  " xopt (const char *, input) : Pointer to character string specifying\n"
14785  " options for horizontal axis. The string can include any\n"
14786  " combination of the following letters (upper or lower case) in any\n"
14787  " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
14788  " is vertical line (x=0). \n"
14789  " b: Draws bottom (X) or left (Y) edge of frame. \n"
14790  " c: Draws top (X) or right (Y) edge of frame. \n"
14791  " d: Plot labels as date / time. Values are assumed to be\n"
14792  " seconds since the epoch (as used by gmtime). \n"
14793  " f: Always use fixed point numeric labels. \n"
14794  " g: Draws a grid at the major tick interval. \n"
14795  " h: Draws a grid at the minor tick interval. \n"
14796  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14797  " inwards. \n"
14798  " l: Labels axis logarithmically. This only affects the labels,\n"
14799  " not the data, and so it is necessary to compute the logarithms\n"
14800  " of data points before passing them to any of the drawing\n"
14801  " routines. \n"
14802  " m: Writes numeric labels at major tick intervals in the\n"
14803  " unconventional location (above box for X, right of box for Y). \n"
14804  " n: Writes numeric labels at major tick intervals in the\n"
14805  " conventional location (below box for X, left of box for Y). \n"
14806  " o: Use custom labeling function to generate axis label text. \n"
14807  " The custom labeling function can be defined with the\n"
14808  " plslabelfuncplslabelfunc; command. \n"
14809  " s: Enables subticks between major ticks, only valid if t is\n"
14810  " also specified. \n"
14811  " t: Draws major ticks. \n"
14812  "\n"
14813  "\n"
14814  " xtick (PLFLT, input) : World coordinate interval between major\n"
14815  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14816  " generates a suitable tick interval. \n"
14817  "\n"
14818  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14819  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14820  " generates a suitable minor tick interval. \n"
14821  "\n"
14822  " yopt (const char *, input) : Pointer to character string specifying\n"
14823  " options for vertical axis. The string can include any combination\n"
14824  " of the letters defined above for xopt, and in addition may\n"
14825  " contain: v: Write numeric labels for vertical axis parallel to the\n"
14826  " base of the graph, rather than parallel to the axis. \n"
14827  "\n"
14828  "\n"
14829  " ytick (PLFLT, input) : World coordinate interval between major\n"
14830  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
14831  " generates a suitable tick interval. \n"
14832  "\n"
14833  " nysub (PLINT, input) : Number of subintervals between major y 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  ""},
14838  { (char *)"plbin", _wrap_plbin, METH_VARARGS, (char *)"\n"
14839  "Plot a histogram from binned data \n"
14840  "\n"
14841  "DESCRIPTION:\n"
14842  "\n"
14843  " Plots a histogram consisting of nbin bins. The value associated with\n"
14844  " the i'th bin is placed in x[i], and the number of points in the bin is\n"
14845  " placed in y[i]. For proper operation, the values in x[i] must form a\n"
14846  " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
14847  " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
14848  " placed midway between the values in the x array. Also see plhist for\n"
14849  " drawing histograms from unbinned data. \n"
14850  "\n"
14851  " Redacted form: General: plbin(x, y, opt)\n"
14852  " Perl/PDL: plbin(nbin, x, y, opt)\n"
14853  " Python: plbin(nbin, x, y, opt)\n"
14854  "\n"
14855  "\n"
14856  " This function is not used in any examples. \n"
14857  "\n"
14858  "\n"
14859  "\n"
14860  "SYNOPSIS:\n"
14861  "\n"
14862  "plbin(nbin, x, y, opt)\n"
14863  "\n"
14864  "ARGUMENTS:\n"
14865  "\n"
14866  " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
14867  " and y arrays.) \n"
14868  "\n"
14869  " x (PLFLT *, input) : Pointer to array containing values associated\n"
14870  " with bins. These must form a strictly increasing sequence. \n"
14871  "\n"
14872  " y (PLFLT *, input) : Pointer to array containing number of points\n"
14873  " in bin. This is a PLFLT (instead of PLINT) array so as to allow\n"
14874  " histograms of probabilities, etc. \n"
14875  "\n"
14876  " opt (PLINT, input) : Is a combination of several flags:\n"
14877  " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
14878  " outer bins are expanded to fill up the entire x-axis and bins of\n"
14879  " zero height are simply drawn. \n"
14880  " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
14881  " between the x values. If the values in x are equally spaced,\n"
14882  " the values are the center values of the bins. \n"
14883  " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
14884  " size as the ones inside. \n"
14885  " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
14886  " (there is a gap for such bins). \n"
14887  "\n"
14888  ""},
14889  { (char *)"plbtime", _wrap_plbtime, METH_VARARGS, NULL},
14890  { (char *)"plbop", _wrap_plbop, METH_VARARGS, (char *)"\n"
14891  "Begin a new page\n"
14892  "\n"
14893  "DESCRIPTION:\n"
14894  "\n"
14895  " Begins a new page. For a file driver, the output file is opened if\n"
14896  " necessary. Advancing the page via pleop and plbop is useful when a\n"
14897  " page break is desired at a particular point when plotting to subpages.\n"
14898  " Another use for pleop and plbop is when plotting pages to different\n"
14899  " files, since you can manually set the file name by calling plsfnam\n"
14900  " after the call to pleop. (In fact some drivers may only support a\n"
14901  " single page per file, making this a necessity.) One way to handle\n"
14902  " this case automatically is to page advance via pladv, but enable\n"
14903  " familying (see plsfam) with a small limit on the file size so that a\n"
14904  " new family member file will be created on each page break. \n"
14905  "\n"
14906  " Redacted form: plbop()\n"
14907  "\n"
14908  " This function is used in examples 2,20. \n"
14909  "\n"
14910  "\n"
14911  "\n"
14912  "SYNOPSIS:\n"
14913  "\n"
14914  "plbop()\n"
14915  "\n"
14916  ""},
14917  { (char *)"plbox", _wrap_plbox, METH_VARARGS, (char *)"\n"
14918  "Draw a box with axes, etc\n"
14919  "\n"
14920  "DESCRIPTION:\n"
14921  "\n"
14922  " Draws a box around the currently defined viewport, and labels it with\n"
14923  " world coordinate values appropriate to the window. Thus plbox should\n"
14924  " only be called after defining both viewport and window. The character\n"
14925  " strings xopt and yopt specify how the box should be drawn as described\n"
14926  " below. If ticks and/or subticks are to be drawn for a particular\n"
14927  " axis, the tick intervals and number of subintervals may be specified\n"
14928  " explicitly, or they may be defaulted by setting the appropriate\n"
14929  " arguments to zero. \n"
14930  "\n"
14931  " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14932  " Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n"
14933  "\n"
14934  "\n"
14935  " This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n"
14936  "\n"
14937  "\n"
14938  "\n"
14939  "SYNOPSIS:\n"
14940  "\n"
14941  "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14942  "\n"
14943  "ARGUMENTS:\n"
14944  "\n"
14945  " xopt (const char *, input) : Pointer to character string specifying\n"
14946  " options for horizontal axis. The string can include any\n"
14947  " combination of the following letters (upper or lower case) in any\n"
14948  " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
14949  " is vertical line (x=0). \n"
14950  " b: Draws bottom (X) or left (Y) edge of frame. \n"
14951  " c: Draws top (X) or right (Y) edge of frame. \n"
14952  " d: Plot labels as date / time. Values are assumed to be\n"
14953  " seconds since the epoch (as used by gmtime). \n"
14954  " f: Always use fixed point numeric labels. \n"
14955  " g: Draws a grid at the major tick interval. \n"
14956  " h: Draws a grid at the minor tick interval. \n"
14957  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14958  " inwards. \n"
14959  " l: Labels axis logarithmically. This only affects the labels,\n"
14960  " not the data, and so it is necessary to compute the logarithms\n"
14961  " of data points before passing them to any of the drawing\n"
14962  " routines. \n"
14963  " m: Writes numeric labels at major tick intervals in the\n"
14964  " unconventional location (above box for X, right of box for Y). \n"
14965  " n: Writes numeric labels at major tick intervals in the\n"
14966  " conventional location (below box for X, left of box for Y). \n"
14967  " o: Use custom labeling function to generate axis label text. \n"
14968  " The custom labeling function can be defined with the\n"
14969  " plslabelfuncplslabelfunc; command. \n"
14970  " s: Enables subticks between major ticks, only valid if t is\n"
14971  " also specified. \n"
14972  " t: Draws major ticks. \n"
14973  " u: Exactly like \"b\" except don't draw edge line. \n"
14974  " w: Exactly like \"c\" except don't draw edge line. \n"
14975  "\n"
14976  "\n"
14977  " xtick (PLFLT, input) : World coordinate interval between major\n"
14978  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14979  " generates a suitable tick interval. \n"
14980  "\n"
14981  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14982  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14983  " generates a suitable minor tick interval. \n"
14984  "\n"
14985  " yopt (const char *, input) : Pointer to character string specifying\n"
14986  " options for vertical axis. The string can include any combination\n"
14987  " of the letters defined above for xopt, and in addition may\n"
14988  " contain: v: Write numeric labels for vertical axis parallel to the\n"
14989  " base of the graph, rather than parallel to the axis. \n"
14990  "\n"
14991  "\n"
14992  " ytick (PLFLT, input) : World coordinate interval between major\n"
14993  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
14994  " generates a suitable tick interval. \n"
14995  "\n"
14996  " nysub (PLINT, input) : Number of subintervals between major y 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  ""},
15001  { (char *)"plbox3", _wrap_plbox3, METH_VARARGS, (char *)"\n"
15002  "Draw a box with axes, etc, in 3-d \n"
15003  "\n"
15004  "DESCRIPTION:\n"
15005  "\n"
15006  " Draws axes, numeric and text labels for a three-dimensional surface\n"
15007  " plot. For a more complete description of three-dimensional plotting\n"
15008  " see the PLplot documentation. \n"
15009  "\n"
15010  " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15011  " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15012  " Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n"
15013  " xopt, xlabel, yopt, ylabel, zopt, zlabel)\n"
15014  "\n"
15015  "\n"
15016  " This function is used in examples 8,11,18,21. \n"
15017  "\n"
15018  "\n"
15019  "\n"
15020  "SYNOPSIS:\n"
15021  "\n"
15022  "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15023  "\n"
15024  "ARGUMENTS:\n"
15025  "\n"
15026  " xopt (const char *, input) : Pointer to character string specifying\n"
15027  " options for the x axis. The string can include any combination of\n"
15028  " the following letters (upper or lower case) in any order: b: Draws\n"
15029  " axis at base, at height z=\n"
15030  " zmin where zmin is defined by call to plw3d. This character must be\n"
15031  " specified in order to use any of the other options. \n"
15032  " f: Always use fixed point numeric labels. \n"
15033  " i: Inverts tick marks, so they are drawn downwards, rather\n"
15034  " than upwards. \n"
15035  " l: Labels axis logarithmically. This only affects the labels,\n"
15036  " not the data, and so it is necessary to compute the logarithms\n"
15037  " of data points before passing them to any of the drawing\n"
15038  " routines. \n"
15039  " n: Writes numeric labels at major tick intervals. \n"
15040  " o: Use custom labeling function to generate axis label text. \n"
15041  " The custom labeling function can be defined with the\n"
15042  " plslabelfuncplslabelfunc; command. \n"
15043  " s: Enables subticks between major ticks, only valid if t is\n"
15044  " also specified. \n"
15045  " t: Draws major ticks. \n"
15046  " u: If this is specified, the text label for the axis is\n"
15047  " written under the axis. \n"
15048  "\n"
15049  "\n"
15050  " xlabel (const char *, input) : Pointer to character string\n"
15051  " specifying text label for the x axis. It is only drawn if u is in\n"
15052  " the xopt string. \n"
15053  "\n"
15054  " xtick (PLFLT, input) : World coordinate interval between major\n"
15055  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15056  " generates a suitable tick interval. \n"
15057  "\n"
15058  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15059  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15060  " generates a suitable minor tick interval. \n"
15061  "\n"
15062  " yopt (const char *, input) : Pointer to character string specifying\n"
15063  " options for the y axis. The string is interpreted in the same way\n"
15064  " as xopt. \n"
15065  "\n"
15066  " ylabel (const char *, input) : Pointer to character string\n"
15067  " specifying text label for the y axis. It is only drawn if u is in\n"
15068  " the yopt string. \n"
15069  "\n"
15070  " ytick (PLFLT, input) : World coordinate interval between major\n"
15071  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15072  " generates a suitable tick interval. \n"
15073  "\n"
15074  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15075  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15076  " generates a suitable minor tick interval. \n"
15077  "\n"
15078  " zopt (const char *, input) : Pointer to character string specifying\n"
15079  " options for the z axis. The string can include any combination of\n"
15080  " the following letters (upper or lower case) in any order: b: Draws\n"
15081  " z axis to the left of the surface plot. \n"
15082  " c: Draws z axis to the right of the surface plot. \n"
15083  " d: Draws grid lines parallel to the x-y plane behind the\n"
15084  " figure. These lines are not drawn until after plot3d or\n"
15085  " plmesh are called because of the need for hidden line removal. \n"
15086  " f: Always use fixed point numeric labels. \n"
15087  " i: Inverts tick marks, so they are drawn away from the center. \n"
15088  " l: Labels axis logarithmically. This only affects the labels,\n"
15089  " not the data, and so it is necessary to compute the logarithms\n"
15090  " of data points before passing them to any of the drawing\n"
15091  " routines. \n"
15092  " m: Writes numeric labels at major tick intervals on the\n"
15093  " right-hand vertical axis. \n"
15094  " n: Writes numeric labels at major tick intervals on the\n"
15095  " left-hand vertical axis. \n"
15096  " o: Use custom labeling function to generate axis label text. \n"
15097  " The custom labeling function can be defined with the\n"
15098  " plslabelfuncplslabelfunc; command. \n"
15099  " s: Enables subticks between major ticks, only valid if t is\n"
15100  " also specified. \n"
15101  " t: Draws major ticks. \n"
15102  " u: If this is specified, the text label is written beside the\n"
15103  " left-hand axis. \n"
15104  " v: If this is specified, the text label is written beside the\n"
15105  " right-hand axis. \n"
15106  "\n"
15107  "\n"
15108  " zlabel (const char *, input) : Pointer to character string\n"
15109  " specifying text label for the z axis. It is only drawn if u or v\n"
15110  " are in the zopt string. \n"
15111  "\n"
15112  " ztick (PLFLT, input) : World coordinate interval between major\n"
15113  " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15114  " generates a suitable tick interval. \n"
15115  "\n"
15116  " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15117  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15118  " generates a suitable minor tick interval. \n"
15119  "\n"
15120  ""},
15121  { (char *)"plcalc_world", _wrap_plcalc_world, METH_VARARGS, (char *)"\n"
15122  "Calculate world coordinates and corresponding window index from relative device coordinates \n"
15123  "\n"
15124  "DESCRIPTION:\n"
15125  "\n"
15126  " Calculate world coordinates, wx and wy, and corresponding window index\n"
15127  " from relative device coordinates, rx and ry. \n"
15128  "\n"
15129  " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15130  " Perl/PDL: Not available? \n"
15131  "\n"
15132  "\n"
15133  " This function is used in example 31. \n"
15134  "\n"
15135  "\n"
15136  "\n"
15137  "SYNOPSIS:\n"
15138  "\n"
15139  "plcalc_world(rx, ry, wx, wy, window)\n"
15140  "\n"
15141  "ARGUMENTS:\n"
15142  "\n"
15143  " rx (PLFLT, input) : Input relative device coordinate (ranging from\n"
15144  " 0. to 1.) for the x coordinate. \n"
15145  "\n"
15146  " ry (PLFLT, input) : Input relative device coordinate (ranging from\n"
15147  " 0. to 1.) for the y coordinate. \n"
15148  "\n"
15149  " wx (PLFLT *, output) : Pointer to the returned world coordinate for\n"
15150  " x corresponding to the relative device coordinates rx and ry. \n"
15151  "\n"
15152  " wy (PLFLT *, output) : Pointer to the returned world coordinate for\n"
15153  " y corresponding to the relative device coordinates rx and ry. \n"
15154  "\n"
15155  " window (PLINT *, output) : Pointer to the returned last defined\n"
15156  " window index that corresponds to the input relative device\n"
15157  " coordinates (and the returned world coordinates). To give some\n"
15158  " background on the window index, for each page the initial window\n"
15159  " index is set to zero, and each time plwind is called within the\n"
15160  " page, world and device coordinates are stored for the window and\n"
15161  " the window index is incremented. Thus, for a simple page layout\n"
15162  " with non-overlapping viewports and one window per viewport, window\n"
15163  " corresponds to the viewport index (in the order which the\n"
15164  " viewport/windows were created) of the only viewport/window\n"
15165  " corresponding to rx and ry. However, for more complicated layouts\n"
15166  " with potentially overlapping viewports and possibly more than one\n"
15167  " window (set of world coordinates) per viewport, window and the\n"
15168  " corresponding output world coordinates corresponds to the last\n"
15169  " window created that fulfils the criterion that the relative device\n"
15170  " coordinates are inside it. Finally, in all cases where the input\n"
15171  " relative device coordinates are not inside any viewport/window,\n"
15172  " then window is set to -1. \n"
15173  "\n"
15174  ""},
15175  { (char *)"plclear", _wrap_plclear, METH_VARARGS, (char *)"\n"
15176  "Clear current (sub)page \n"
15177  "\n"
15178  "DESCRIPTION:\n"
15179  "\n"
15180  " Clears the current page, effectively erasing everything that have been\n"
15181  " drawn. This command only works with interactive drivers; if the\n"
15182  " driver does not support this, the page is filled with the background\n"
15183  " color in use. If the current page is divided into subpages, only the\n"
15184  " current subpage is erased. The nth subpage can be selected with\n"
15185  " pladv(n). \n"
15186  "\n"
15187  " Redacted form: General: plclear()\n"
15188  " Perl/PDL: Not available? \n"
15189  "\n"
15190  "\n"
15191  " This function is not used in any examples. \n"
15192  "\n"
15193  "\n"
15194  "\n"
15195  "SYNOPSIS:\n"
15196  "\n"
15197  "plclear()\n"
15198  "\n"
15199  ""},
15200  { (char *)"plcol0", _wrap_plcol0, METH_VARARGS, (char *)"\n"
15201  "Set color, map0 \n"
15202  "\n"
15203  "DESCRIPTION:\n"
15204  "\n"
15205  " Sets the color for color map0 (see the PLplot documentation). \n"
15206  "\n"
15207  " Redacted form: plcol0(color)\n"
15208  "\n"
15209  " This function is used in examples 1-9,11-16,18-27,29. \n"
15210  "\n"
15211  "\n"
15212  "\n"
15213  "SYNOPSIS:\n"
15214  "\n"
15215  "plcol0(color)\n"
15216  "\n"
15217  "ARGUMENTS:\n"
15218  "\n"
15219  " color (PLINT, input) : Integer representing the color. The\n"
15220  " defaults at present are (these may change): \n"
15221  " 0 black (default background) \n"
15222  " 1 red (default foreground) \n"
15223  " 2 yellow \n"
15224  " 3 green \n"
15225  " 4 aquamarine \n"
15226  " 5 pink \n"
15227  " 6 wheat \n"
15228  " 7 grey \n"
15229  " 8 brown \n"
15230  " 9 blue \n"
15231  " 10 BlueViolet \n"
15232  " 11 cyan \n"
15233  " 12 turquoise \n"
15234  " 13 magenta \n"
15235  " 14 salmon \n"
15236  " 15 white \n"
15237  "\n"
15238  " Use plscmap0 to change the entire map0 color palette and plscol0 to\n"
15239  " change an individual color in the map0 color palette. \n"
15240  "\n"
15241  ""},
15242  { (char *)"plcol1", _wrap_plcol1, METH_VARARGS, (char *)"\n"
15243  "Set color, map1 \n"
15244  "\n"
15245  "DESCRIPTION:\n"
15246  "\n"
15247  " Sets the color for color map1 (see the PLplot documentation). \n"
15248  "\n"
15249  " Redacted form: plcol1(col1)\n"
15250  "\n"
15251  " This function is used in examples 12 and 21. \n"
15252  "\n"
15253  "\n"
15254  "\n"
15255  "SYNOPSIS:\n"
15256  "\n"
15257  "plcol1(col1)\n"
15258  "\n"
15259  "ARGUMENTS:\n"
15260  "\n"
15261  " col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n"
15262  " and is mapped to color using the continuous map1 color palette\n"
15263  " which by default ranges from blue to the background color to red. \n"
15264  " The map1 palette can also be straightforwardly changed by the user\n"
15265  " with plscmap1 or plscmap1l. \n"
15266  "\n"
15267  ""},
15268  { (char *)"plconfigtime", _wrap_plconfigtime, METH_VARARGS, NULL},
15269  { (char *)"plcont", _wrap_plcont, METH_VARARGS, (char *)"\n"
15270  "Contour plot \n"
15271  "\n"
15272  "DESCRIPTION:\n"
15273  "\n"
15274  " Draws a contour plot of the data in z[\n"
15275  " nx][\n"
15276  " ny], using the nlevel contour levels specified by clevel. Only the\n"
15277  " region of the array from kx to lx and from ky to ly is plotted out. A\n"
15278  " transformation routine pointed to by pltr with a pointer pltr_data for\n"
15279  " additional data required by the transformation routine is used to map\n"
15280  " indices within the array to the world coordinates. See the following\n"
15281  " discussion of the arguments and the PLplot documentation for more\n"
15282  " information. \n"
15283  "\n"
15284  " Redacted form: [PLEASE UPDATE! ONLY PERL INFO IS LIKELY CORRECT!] F95:\n"
15285  " plcont(z, kx, lx, ky, ly, clevel, tr?) or plcont(z, kx, lx, ky, ly,\n"
15286  " clevel, xgrid, ygrid)\n"
15287  " Java: pls.cont(z, kx, lx, ky, ly, clevel, xgrid, ygrid)\n"
15288  " Perl/PDL: plcont(z, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
15289  " Python: plcont2(z, kx, lx, ky, ly, clevel)\n"
15290  "\n"
15291  "\n"
15292  " This function is used in examples 9,14,16,22. \n"
15293  "\n"
15294  "\n"
15295  "\n"
15296  "SYNOPSIS:\n"
15297  "\n"
15298  "plcont(z, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
15299  "\n"
15300  "ARGUMENTS:\n"
15301  "\n"
15302  " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
15303  " containing data to be contoured. \n"
15304  "\n"
15305  " nx, ny (PLINT, input) : Physical dimensions of array z. \n"
15306  "\n"
15307  " kx, lx (PLINT, input) : Range of x indices to consider. \n"
15308  "\n"
15309  " ky, ly (PLINT, input) : Range of y indices to consider. \n"
15310  "\n"
15311  " clevel (PLFLT *, input) : Pointer to array specifying levels at\n"
15312  " which to draw contours. \n"
15313  "\n"
15314  " nlevel (PLINT, input) : Number of contour levels to draw. \n"
15315  "\n"
15316  " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
15317  " Pointer to function that defines transformation between indices\n"
15318  " in array z and the world coordinates (C only). Transformation\n"
15319  " functions are provided in the PLplot library: pltr0 for identity\n"
15320  " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
15321  " defined by one- and two-dimensional arrays. In addition,\n"
15322  " user-supplied routines for the transformation can be used as well.\n"
15323  " Examples of all of these approaches are given in the PLplot\n"
15324  " documentation. The transformation function should have the form\n"
15325  " given by any of pltr0, pltr1, or pltr2. Note that unlike plshades\n"
15326  " and similar PLplot functions which have a pltr argument, plcont\n"
15327  " requires that a transformation function be provided in the C\n"
15328  " interface. Leaving pltr NULL will result in an error. \n"
15329  "\n"
15330  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
15331  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
15332  " externally supplied. \n"
15333  "\n"
15334  ""},
15335  { (char *)"plctime", _wrap_plctime, METH_VARARGS, NULL},
15336  { (char *)"plcpstrm", _wrap_plcpstrm, METH_VARARGS, (char *)"\n"
15337  "Copy state parameters from the reference stream to the current stream \n"
15338  "\n"
15339  "DESCRIPTION:\n"
15340  "\n"
15341  " Copies state parameters from the reference stream to the current\n"
15342  " stream. Tell driver interface to map device coordinates unless flags\n"
15343  " == 1. \n"
15344  "\n"
15345  " This function is used for making save files of selected plots (e.g.\n"
15346  " from the TK driver). After initializing, you can get a copy of the\n"
15347  " current plot to the specified device by switching to this stream and\n"
15348  " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
15349  " appropriate. The plot buffer must have previously been enabled (done\n"
15350  " automatically by some display drivers, such as X). \n"
15351  "\n"
15352  " Redacted form: plcpstrm(iplsr, flags)\n"
15353  "\n"
15354  " This function is used in example 1,20. \n"
15355  "\n"
15356  "\n"
15357  "\n"
15358  "SYNOPSIS:\n"
15359  "\n"
15360  "plcpstrm(iplsr, flags)\n"
15361  "\n"
15362  "ARGUMENTS:\n"
15363  "\n"
15364  " iplsr (PLINT, input) : Number of reference stream. \n"
15365  "\n"
15366  " flags (PLBOOL, input) : If flags is set to true the device\n"
15367  " coordinates are not copied from the reference to current stream. \n"
15368  "\n"
15369  ""},
15370  { (char *)"plend", _wrap_plend, METH_VARARGS, (char *)"\n"
15371  "End plotting session \n"
15372  "\n"
15373  "DESCRIPTION:\n"
15374  "\n"
15375  " Ends a plotting session, tidies up all the output files, switches\n"
15376  " interactive devices back into text mode and frees up any memory that\n"
15377  " was allocated. Must be called before end of program. \n"
15378  "\n"
15379  " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
15380  " wait state after a call to plend or other functions which trigger the\n"
15381  " end of a plot page. To avoid this, use the plspause function. \n"
15382  "\n"
15383  " Redacted form: plend()\n"
15384  "\n"
15385  " This function is used in all of the examples. \n"
15386  "\n"
15387  "\n"
15388  "\n"
15389  "SYNOPSIS:\n"
15390  "\n"
15391  "plend()\n"
15392  "\n"
15393  ""},
15394  { (char *)"plend1", _wrap_plend1, METH_VARARGS, (char *)"\n"
15395  "End plotting session for current stream \n"
15396  "\n"
15397  "DESCRIPTION:\n"
15398  "\n"
15399  " Ends a plotting session for the current output stream only. See\n"
15400  " plsstrm for more info. \n"
15401  "\n"
15402  " Redacted form: plend1()\n"
15403  "\n"
15404  " This function is used in examples 1,20. \n"
15405  "\n"
15406  "\n"
15407  "\n"
15408  "SYNOPSIS:\n"
15409  "\n"
15410  "plend1()\n"
15411  "\n"
15412  ""},
15413  { (char *)"plenv", _wrap_plenv, METH_VARARGS, (char *)"\n"
15414  "Set up standard window and draw box \n"
15415  "\n"
15416  "DESCRIPTION:\n"
15417  "\n"
15418  " Sets up plotter environment for simple graphs by calling pladv and\n"
15419  " setting up viewport and window to sensible default values. plenv\n"
15420  " leaves enough room around most graphs for axis labels and a title.\n"
15421  " When these defaults are not suitable, use the individual routines\n"
15422  " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
15423  " defining the window, and plbox for drawing the box. \n"
15424  "\n"
15425  " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15426  "\n"
15427  " This function is used in example 1,3,9,13,14,19-22,29. \n"
15428  "\n"
15429  "\n"
15430  "\n"
15431  "SYNOPSIS:\n"
15432  "\n"
15433  "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15434  "\n"
15435  "ARGUMENTS:\n"
15436  "\n"
15437  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15438  " world coordinates). \n"
15439  "\n"
15440  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15441  " world coordinates). \n"
15442  "\n"
15443  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15444  " coordinates). \n"
15445  "\n"
15446  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15447  " coordinates). \n"
15448  "\n"
15449  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15450  " scales will not be set, the user must set up the scale before\n"
15451  " calling plenv using plsvpa, plvasp or other. \n"
15452  " 0: the x and y axes are scaled independently to use as much of\n"
15453  " the screen as possible. \n"
15454  " 1: the scales of the x and y axes are made equal. \n"
15455  " 2: the axis of the x and y axes are made equal, and the plot\n"
15456  " box will be square. \n"
15457  "\n"
15458  "\n"
15459  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15460  " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
15461  " -1: draw box only. \n"
15462  " 0: draw box, ticks, and numeric tick labels. \n"
15463  " 1: also draw coordinate axes at x=0 and y=0. \n"
15464  " 2: also draw a grid at major tick positions in both\n"
15465  " coordinates. \n"
15466  " 3: also draw a grid at minor tick positions in both\n"
15467  " coordinates. \n"
15468  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15469  " have to be converted to logarithms separately.) \n"
15470  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15471  " have to be converted to logarithms separately.) \n"
15472  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15473  " have to be converted to logarithms separately.) \n"
15474  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15475  " have to be converted to logarithms separately.) \n"
15476  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15477  " have to be converted to logarithms separately.) \n"
15478  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15479  " have to be converted to logarithms separately.) \n"
15480  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15481  " have to be converted to logarithms separately.) \n"
15482  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15483  " have to be converted to logarithms separately.) \n"
15484  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15485  " and y data have to be converted to logarithms separately.) \n"
15486  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15487  " and y data have to be converted to logarithms separately.) \n"
15488  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15489  " and y data have to be converted to logarithms separately.) \n"
15490  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15491  " and y data have to be converted to logarithms separately.) \n"
15492  " 40: same as 0 except date / time x labels. \n"
15493  " 41: same as 1 except date / time x labels. \n"
15494  " 42: same as 2 except date / time x labels. \n"
15495  " 43: same as 3 except date / time x labels. \n"
15496  " 50: same as 0 except date / time y labels. \n"
15497  " 51: same as 1 except date / time y labels. \n"
15498  " 52: same as 2 except date / time y labels. \n"
15499  " 53: same as 3 except date / time y labels. \n"
15500  " 60: same as 0 except date / time x and y labels. \n"
15501  " 61: same as 1 except date / time x and y labels. \n"
15502  " 62: same as 2 except date / time x and y labels. \n"
15503  " 63: same as 3 except date / time x and y labels. \n"
15504  " 70: same as 0 except custom x and y labels. \n"
15505  " 71: same as 1 except custom x and y labels. \n"
15506  " 72: same as 2 except custom x and y labels. \n"
15507  " 73: same as 3 except custom x and y labels. \n"
15508  "\n"
15509  ""},
15510  { (char *)"plenv0", _wrap_plenv0, METH_VARARGS, (char *)"\n"
15511  "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it. \n"
15512  "\n"
15513  "DESCRIPTION:\n"
15514  "\n"
15515  " Sets up plotter environment for simple graphs by calling pladv and\n"
15516  " setting up viewport and window to sensible default values. plenv0\n"
15517  " leaves enough room around most graphs for axis labels and a title.\n"
15518  " When these defaults are not suitable, use the individual routines\n"
15519  " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
15520  " defining the window, and plbox for drawing the box. \n"
15521  "\n"
15522  " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15523  "\n"
15524  " This function is used in example 21. \n"
15525  "\n"
15526  "\n"
15527  "\n"
15528  "SYNOPSIS:\n"
15529  "\n"
15530  "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15531  "\n"
15532  "ARGUMENTS:\n"
15533  "\n"
15534  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15535  " world coordinates). \n"
15536  "\n"
15537  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15538  " world coordinates). \n"
15539  "\n"
15540  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15541  " coordinates). \n"
15542  "\n"
15543  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15544  " coordinates). \n"
15545  "\n"
15546  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15547  " scales will not be set, the user must set up the scale before\n"
15548  " calling plenv0 using plsvpa, plvasp or other. \n"
15549  " 0: the x and y axes are scaled independently to use as much of\n"
15550  " the screen as possible. \n"
15551  " 1: the scales of the x and y axes are made equal. \n"
15552  " 2: the axis of the x and y axes are made equal, and the plot\n"
15553  " box will be square. \n"
15554  "\n"
15555  "\n"
15556  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15557  " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
15558  " -1: draw box only. \n"
15559  " 0: draw box, ticks, and numeric tick labels. \n"
15560  " 1: also draw coordinate axes at x=0 and y=0. \n"
15561  " 2: also draw a grid at major tick positions in both\n"
15562  " coordinates. \n"
15563  " 3: also draw a grid at minor tick positions in both\n"
15564  " coordinates. \n"
15565  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15566  " have to be converted to logarithms separately.) \n"
15567  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15568  " have to be converted to logarithms separately.) \n"
15569  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15570  " have to be converted to logarithms separately.) \n"
15571  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15572  " have to be converted to logarithms separately.) \n"
15573  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15574  " have to be converted to logarithms separately.) \n"
15575  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15576  " have to be converted to logarithms separately.) \n"
15577  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15578  " have to be converted to logarithms separately.) \n"
15579  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15580  " have to be converted to logarithms separately.) \n"
15581  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15582  " and y data have to be converted to logarithms separately.) \n"
15583  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15584  " and y data have to be converted to logarithms separately.) \n"
15585  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15586  " and y data have to be converted to logarithms separately.) \n"
15587  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15588  " and y data have to be converted to logarithms separately.) \n"
15589  " 40: same as 0 except date / time x labels. \n"
15590  " 41: same as 1 except date / time x labels. \n"
15591  " 42: same as 2 except date / time x labels. \n"
15592  " 43: same as 3 except date / time x labels. \n"
15593  " 50: same as 0 except date / time y labels. \n"
15594  " 51: same as 1 except date / time y labels. \n"
15595  " 52: same as 2 except date / time y labels. \n"
15596  " 53: same as 3 except date / time y labels. \n"
15597  " 60: same as 0 except date / time x and y labels. \n"
15598  " 61: same as 1 except date / time x and y labels. \n"
15599  " 62: same as 2 except date / time x and y labels. \n"
15600  " 63: same as 3 except date / time x and y labels. \n"
15601  " 70: same as 0 except custom x and y labels. \n"
15602  " 71: same as 1 except custom x and y labels. \n"
15603  " 72: same as 2 except custom x and y labels. \n"
15604  " 73: same as 3 except custom x and y labels. \n"
15605  "\n"
15606  ""},
15607  { (char *)"pleop", _wrap_pleop, METH_VARARGS, (char *)"\n"
15608  "Eject current page \n"
15609  "\n"
15610  "DESCRIPTION:\n"
15611  "\n"
15612  " Clears the graphics screen of an interactive device, or ejects a page\n"
15613  " on a plotter. See plbop for more information. \n"
15614  "\n"
15615  " Redacted form: pleop()\n"
15616  "\n"
15617  " This function is used in example 2,14. \n"
15618  "\n"
15619  "\n"
15620  "\n"
15621  "SYNOPSIS:\n"
15622  "\n"
15623  "pleop()\n"
15624  "\n"
15625  ""},
15626  { (char *)"plerrx", _wrap_plerrx, METH_VARARGS, (char *)"\n"
15627  "Draw x error bar \n"
15628  "\n"
15629  "DESCRIPTION:\n"
15630  "\n"
15631  " Draws a set of n horizontal error bars, the i'th error bar extending\n"
15632  " from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n"
15633  " error bar are of length equal to the minor tick length (settable using\n"
15634  " plsmin). \n"
15635  "\n"
15636  " Redacted form: General: plerrx(xmin, ymax, y)\n"
15637  " Perl/PDL: plerrx(n, xmin, xmax, y)\n"
15638  "\n"
15639  "\n"
15640  " This function is used in example 29. \n"
15641  "\n"
15642  "\n"
15643  "\n"
15644  "SYNOPSIS:\n"
15645  "\n"
15646  "plerrx(n, xmin, xmax, y)\n"
15647  "\n"
15648  "ARGUMENTS:\n"
15649  "\n"
15650  " n (PLINT, input) : Number of error bars to draw. \n"
15651  "\n"
15652  " xmin (PLFLT *, input) : Pointer to array with x coordinates of\n"
15653  " left-hand endpoint of error bars. \n"
15654  "\n"
15655  " xmax (PLFLT *, input) : Pointer to array with x coordinates of\n"
15656  " right-hand endpoint of error bars. \n"
15657  "\n"
15658  " y (PLFLT *, input) : Pointer to array with y coordinates of error\n"
15659  " bar. \n"
15660  "\n"
15661  ""},
15662  { (char *)"plerry", _wrap_plerry, METH_VARARGS, (char *)"\n"
15663  "Draw y error bar \n"
15664  "\n"
15665  "DESCRIPTION:\n"
15666  "\n"
15667  " Draws a set of n vertical error bars, the i'th error bar extending\n"
15668  " from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n"
15669  " error bar are of length equal to the minor tick length (settable using\n"
15670  " plsmin). \n"
15671  "\n"
15672  " Redacted form: General: plerry(x, ymin, ymax)\n"
15673  " Perl/PDL: plerry(n, x, ymin, ymax)\n"
15674  "\n"
15675  "\n"
15676  " This function is used in example 29. \n"
15677  "\n"
15678  "\n"
15679  "\n"
15680  "SYNOPSIS:\n"
15681  "\n"
15682  "plerry(n, x, ymin, ymax)\n"
15683  "\n"
15684  "ARGUMENTS:\n"
15685  "\n"
15686  " n (PLINT, input) : Number of error bars to draw. \n"
15687  "\n"
15688  " x (PLFLT *, input) : Pointer to array with x coordinates of error\n"
15689  " bars. \n"
15690  "\n"
15691  " ymin (PLFLT *, input) : Pointer to array with y coordinates of\n"
15692  " lower endpoint of error bars. \n"
15693  "\n"
15694  " ymax (PLFLT *, input) : Pointer to array with y coordinate of upper\n"
15695  " endpoint of error bar. \n"
15696  "\n"
15697  ""},
15698  { (char *)"plfamadv", _wrap_plfamadv, METH_VARARGS, (char *)"\n"
15699  "Advance to the next family file on the next new page \n"
15700  "\n"
15701  "DESCRIPTION:\n"
15702  "\n"
15703  " Advance to the next family file on the next new page. \n"
15704  "\n"
15705  " Redacted form: plfamadv()\n"
15706  "\n"
15707  " This function is not used in any examples. \n"
15708  "\n"
15709  "\n"
15710  "\n"
15711  "SYNOPSIS:\n"
15712  "\n"
15713  "plfamadv()\n"
15714  "\n"
15715  ""},
15716  { (char *)"plfill", _wrap_plfill, METH_VARARGS, (char *)"\n"
15717  "Draw filled polygon \n"
15718  "\n"
15719  "DESCRIPTION:\n"
15720  "\n"
15721  " Fills the polygon defined by the n points (\n"
15722  " x[i], \n"
15723  " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
15724  " style is a solid fill. The routine will automatically close the\n"
15725  " polygon between the last and first vertices. If multiple closed\n"
15726  " polygons are passed in x and y then plfill will fill in between them. \n"
15727  "\n"
15728  " Redacted form: plfill(x,y)\n"
15729  "\n"
15730  " This function is used in examples 12,13,15,16,21,24,25. \n"
15731  "\n"
15732  "\n"
15733  "\n"
15734  "SYNOPSIS:\n"
15735  "\n"
15736  "plfill(n, x, y)\n"
15737  "\n"
15738  "ARGUMENTS:\n"
15739  "\n"
15740  " n (PLINT, input) : Number of vertices in polygon. \n"
15741  "\n"
15742  " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15743  " vertices. \n"
15744  "\n"
15745  " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15746  " vertices. \n"
15747  "\n"
15748  ""},
15749  { (char *)"plfill3", _wrap_plfill3, METH_VARARGS, (char *)"\n"
15750  "Draw filled polygon in 3D \n"
15751  "\n"
15752  "DESCRIPTION:\n"
15753  "\n"
15754  " Fills the 3D polygon defined by the n points in the x, y, and z arrays\n"
15755  " using the pattern defined by plpsty or plpat. The routine will\n"
15756  " automatically close the polygon between the last and first vertices. \n"
15757  " If multiple closed polygons are passed in x, y, and z then plfill3\n"
15758  " will fill in between them. \n"
15759  "\n"
15760  " Redacted form: General: plfill3(x, y, z)\n"
15761  " Perl/PDL: plfill3(n, x, y, z)\n"
15762  "\n"
15763  "\n"
15764  " This function is used in example 15. \n"
15765  "\n"
15766  "\n"
15767  "\n"
15768  "SYNOPSIS:\n"
15769  "\n"
15770  "plfill3(n, x, y, z)\n"
15771  "\n"
15772  "ARGUMENTS:\n"
15773  "\n"
15774  " n (PLINT, input) : Number of vertices in polygon. \n"
15775  "\n"
15776  " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15777  " vertices. \n"
15778  "\n"
15779  " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15780  " vertices. \n"
15781  "\n"
15782  " z (PLFLT *, input) : Pointer to array with z coordinates of\n"
15783  " vertices. \n"
15784  "\n"
15785  ""},
15786  { (char *)"plgradient", _wrap_plgradient, METH_VARARGS, (char *)"\n"
15787  "Draw linear gradient inside polygon \n"
15788  "\n"
15789  "DESCRIPTION:\n"
15790  "\n"
15791  " Draw a linear gradient using colour map 1 inside the polygon defined\n"
15792  " by the n points (\n"
15793  " x[i], \n"
15794  " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
15795  " polygon coordinates and the gradient angle are all expressed in world\n"
15796  " coordinates. The angle from the x axis for both the rotated\n"
15797  " coordinate system and the gradient vector is specified by angle. The\n"
15798  " magnitude of the gradient vector is the difference between the maximum\n"
15799  " and minimum values of x for the vertices in the rotated coordinate\n"
15800  " system. The origin of the gradient vector can be interpreted as being\n"
15801  " anywhere on the line corresponding to the minimum x value for the\n"
15802  " vertices in the rotated coordinate system. The distance along the\n"
15803  " gradient vector is linearly transformed to the independent variable of\n"
15804  " colour map 1 which ranges from 0. at the tail of the gradient vector\n"
15805  " to 1. at the head of the gradient vector. What is drawn is the RGBA\n"
15806  " colour corresponding to the independent variable of colour map 1. For\n"
15807  " more information about colour map 1 (see the PLplot documentation). \n"
15808  "\n"
15809  " Redacted form: plgradient(x,y,angle)\n"
15810  "\n"
15811  " This function is used in examples 25,30. \n"
15812  "\n"
15813  "\n"
15814  "\n"
15815  "SYNOPSIS:\n"
15816  "\n"
15817  "plgradient(n, x, y, angle)\n"
15818  "\n"
15819  "ARGUMENTS:\n"
15820  "\n"
15821  " n (PLINT, input) : Number of vertices in polygon. \n"
15822  "\n"
15823  " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15824  " vertices. \n"
15825  "\n"
15826  " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15827  " vertices. \n"
15828  "\n"
15829  " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
15830  " axis. \n"
15831  "\n"
15832  ""},
15833  { (char *)"plflush", _wrap_plflush, METH_VARARGS, (char *)"\n"
15834  "Flushes the output stream \n"
15835  "\n"
15836  "DESCRIPTION:\n"
15837  "\n"
15838  " Flushes the output stream. Use sparingly, if at all. \n"
15839  "\n"
15840  " Redacted form: plflush()\n"
15841  "\n"
15842  " This function is used in examples 1,14. \n"
15843  "\n"
15844  "\n"
15845  "\n"
15846  "SYNOPSIS:\n"
15847  "\n"
15848  "plflush()\n"
15849  "\n"
15850  ""},
15851  { (char *)"plfont", _wrap_plfont, METH_VARARGS, (char *)"\n"
15852  "Set character font \n"
15853  "\n"
15854  "DESCRIPTION:\n"
15855  "\n"
15856  " Sets the default character font for subsequent character drawing. Also\n"
15857  " affects symbols produced by plpoin. This routine has no effect unless\n"
15858  " the extended character set is loaded (see plfontld). \n"
15859  "\n"
15860  " Redacted form: plfont(font)\n"
15861  "\n"
15862  " This function is used in examples 1,2,4,7,13,24,26. \n"
15863  "\n"
15864  "\n"
15865  "\n"
15866  "SYNOPSIS:\n"
15867  "\n"
15868  "plfont(font)\n"
15869  "\n"
15870  "ARGUMENTS:\n"
15871  "\n"
15872  " font (PLINT, input) : Specifies the font: 1: Normal font (simplest\n"
15873  " and fastest) \n"
15874  " 2: Roman font \n"
15875  " 3: Italic font \n"
15876  " 4: Script font \n"
15877  "\n"
15878  ""},
15879  { (char *)"plfontld", _wrap_plfontld, METH_VARARGS, (char *)"\n"
15880  "Load character font \n"
15881  "\n"
15882  "DESCRIPTION:\n"
15883  "\n"
15884  " Sets the character set to use for subsequent character drawing. May\n"
15885  " be called before initializing PLplot. \n"
15886  "\n"
15887  " Redacted form: plfontld(set)\n"
15888  "\n"
15889  " This function is used in examples 1,7. \n"
15890  "\n"
15891  "\n"
15892  "\n"
15893  "SYNOPSIS:\n"
15894  "\n"
15895  "plfontld(set)\n"
15896  "\n"
15897  "ARGUMENTS:\n"
15898  "\n"
15899  " set (PLINT, input) : Specifies the character set to load: 0:\n"
15900  " Standard character set \n"
15901  " 1: Extended character set \n"
15902  "\n"
15903  ""},
15904  { (char *)"plgchr", _wrap_plgchr, METH_VARARGS, (char *)"\n"
15905  "Get character default height and current (scaled) height \n"
15906  "\n"
15907  "DESCRIPTION:\n"
15908  "\n"
15909  " Get character default height and current (scaled) height. \n"
15910  "\n"
15911  " Redacted form: plgchr(p_def, p_ht)\n"
15912  "\n"
15913  " This function is used in example 23. \n"
15914  "\n"
15915  "\n"
15916  "\n"
15917  "SYNOPSIS:\n"
15918  "\n"
15919  "plgchr(p_def, p_ht)\n"
15920  "\n"
15921  "ARGUMENTS:\n"
15922  "\n"
15923  " p_def (PLFLT *, output) : Pointer to default character height (mm). \n"
15924  "\n"
15925  " p_ht (PLFLT *, output) : Pointer to current (scaled) character\n"
15926  " height (mm). \n"
15927  "\n"
15928  ""},
15929  { (char *)"plgcol0", _wrap_plgcol0, METH_VARARGS, (char *)"\n"
15930  "Returns 8-bit RGB values for given color from color map0 \n"
15931  "\n"
15932  "DESCRIPTION:\n"
15933  "\n"
15934  " Returns 8-bit RGB values (0-255) for given color from color map0 (see\n"
15935  " the PLplot documentation). Values are negative if an invalid color id\n"
15936  " is given. \n"
15937  "\n"
15938  " Redacted form: plgcol0(icol0, r, g, b)\n"
15939  "\n"
15940  " This function is used in example 2. \n"
15941  "\n"
15942  "\n"
15943  "\n"
15944  "SYNOPSIS:\n"
15945  "\n"
15946  "plgcol0(icol0, r, g, b)\n"
15947  "\n"
15948  "ARGUMENTS:\n"
15949  "\n"
15950  " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
15951  "\n"
15952  " r (PLINT *, output) : Pointer to 8-bit red value. \n"
15953  "\n"
15954  " g (PLINT *, output) : Pointer to 8-bit green value. \n"
15955  "\n"
15956  " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
15957  "\n"
15958  ""},
15959  { (char *)"plgcol0a", _wrap_plgcol0a, METH_VARARGS, (char *)"\n"
15960  "Returns 8-bit RGB values and double alpha value for given color from color map0. \n"
15961  "\n"
15962  "DESCRIPTION:\n"
15963  "\n"
15964  " Returns 8-bit RGB values (0-255) and double alpha value (0.0 - 1.0)\n"
15965  " for given color from color map0 (see the PLplot documentation). \n"
15966  " Values are negative if an invalid color id is given. \n"
15967  "\n"
15968  " This function is used in example 30. \n"
15969  "\n"
15970  "\n"
15971  "\n"
15972  "SYNOPSIS:\n"
15973  "\n"
15974  "plgcol0a(icol0, r, g, b, a)\n"
15975  "\n"
15976  "ARGUMENTS:\n"
15977  "\n"
15978  " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
15979  "\n"
15980  " r (PLINT *, output) : Pointer to 8-bit red value. \n"
15981  "\n"
15982  " g (PLINT *, output) : Pointer to 8-bit green value. \n"
15983  "\n"
15984  " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
15985  "\n"
15986  " a (PLFLT *, output) : Pointer to PLFLT alpha value. \n"
15987  "\n"
15988  ""},
15989  { (char *)"plgcolbg", _wrap_plgcolbg, METH_VARARGS, (char *)"\n"
15990  "Returns the background color (cmap0[0]) by 8-bit RGB value \n"
15991  "\n"
15992  "ESCRIPTION:\n"
15993  "\n"
15994  " Returns the background color (cmap0[0]) by 8-bit RGB value. \n"
15995  "\n"
15996  " Redacted form: plgcolbg(r, g, b)\n"
15997  "\n"
15998  " This function is used in example 31. \n"
15999  "\n"
16000  "\n"
16001  "\n"
16002  "YNOPSIS:\n"
16003  "\n"
16004  "lgcolbg(r, g, b)\n"
16005  "\n"
16006  "RGUMENTS:\n"
16007  "\n"
16008  " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16009  " representing the degree of red in the color. \n"
16010  "\n"
16011  " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16012  " representing the degree of green in the color. \n"
16013  "\n"
16014  " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16015  " representing the degree of blue in the color. \n"
16016  "\n"
16017  ""},
16018  { (char *)"plgcolbga", _wrap_plgcolbga, METH_VARARGS, (char *)"\n"
16019  "Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha value. \n"
16020  "\n"
16021  "ESCRIPTION:\n"
16022  "\n"
16023  " Returns the background color (cmap0[0]) by 8-bit RGB value and double\n"
16024  " alpha value. \n"
16025  "\n"
16026  " This function is used in example 31. \n"
16027  "\n"
16028  "\n"
16029  "\n"
16030  "YNOPSIS:\n"
16031  "\n"
16032  "lgcolbga(r, g, b, a)\n"
16033  "\n"
16034  "RGUMENTS:\n"
16035  "\n"
16036  " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16037  " representing the degree of red in the color. \n"
16038  "\n"
16039  " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16040  " representing the degree of green in the color. \n"
16041  "\n"
16042  " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16043  " representing the degree of blue in the color. \n"
16044  "\n"
16045  " a (PLFLT *, output) : Pointer to PLFLT alpha value. \n"
16046  "\n"
16047  ""},
16048  { (char *)"plgcompression", _wrap_plgcompression, METH_VARARGS, (char *)"\n"
16049  "Get the current device-compression setting \n"
16050  "\n"
16051  "DESCRIPTION:\n"
16052  "\n"
16053  " Get the current device-compression setting. This parameter is only\n"
16054  " used for drivers that provide compression. \n"
16055  "\n"
16056  " Redacted form: plgcompression(compression)\n"
16057  "\n"
16058  " This function is used in example 31. \n"
16059  "\n"
16060  "\n"
16061  "\n"
16062  "SYNOPSIS:\n"
16063  "\n"
16064  "plgcompression(compression)\n"
16065  "\n"
16066  "ARGUMENTS:\n"
16067  "\n"
16068  " compression (PLINT *, output) : Pointer to a variable to be filled\n"
16069  " with the current device-compression setting. \n"
16070  "\n"
16071  ""},
16072  { (char *)"plgdev", _wrap_plgdev, METH_VARARGS, (char *)"\n"
16073  "Get the current device (keyword) name \n"
16074  "\n"
16075  "DESCRIPTION:\n"
16076  "\n"
16077  " Get the current device (keyword) name. Note: you must have allocated\n"
16078  " space for this (80 characters is safe). \n"
16079  "\n"
16080  " Redacted form: plgdev(p_dev)\n"
16081  "\n"
16082  " This function is used in example 14. \n"
16083  "\n"
16084  "\n"
16085  "\n"
16086  "SYNOPSIS:\n"
16087  "\n"
16088  "plgdev(p_dev)\n"
16089  "\n"
16090  "ARGUMENTS:\n"
16091  "\n"
16092  " p_dev (char *, output) : Pointer to device (keyword) name string. \n"
16093  "\n"
16094  ""},
16095  { (char *)"plgdidev", _wrap_plgdidev, METH_VARARGS, (char *)"\n"
16096  "Get parameters that define current device-space window \n"
16097  "\n"
16098  "DESCRIPTION:\n"
16099  "\n"
16100  " Get relative margin width, aspect ratio, and relative justification\n"
16101  " that define current device-space window. If plsdidev has not been\n"
16102  " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
16103  " p_jy will all be 0. \n"
16104  "\n"
16105  " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16106  "\n"
16107  " This function is used in example 31. \n"
16108  "\n"
16109  "\n"
16110  "\n"
16111  "SYNOPSIS:\n"
16112  "\n"
16113  "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16114  "\n"
16115  "ARGUMENTS:\n"
16116  "\n"
16117  " p_mar (PLFLT *, output) : Pointer to relative margin width. \n"
16118  "\n"
16119  " p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n"
16120  "\n"
16121  " p_jx (PLFLT *, output) : Pointer to relative justification in x. \n"
16122  "\n"
16123  " p_jy (PLFLT *, output) : Pointer to relative justification in y. \n"
16124  "\n"
16125  ""},
16126  { (char *)"plgdiori", _wrap_plgdiori, METH_VARARGS, (char *)"\n"
16127  "Get plot orientation \n"
16128  "\n"
16129  "DESCRIPTION:\n"
16130  "\n"
16131  " Get plot orientation parameter which is multiplied by 90 degrees to\n"
16132  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
16133  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
16134  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
16135  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
16136  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
16137  " not been called the default value pointed to by p_rot will be 0. \n"
16138  "\n"
16139  " Redacted form: plgdiori(p_rot)\n"
16140  "\n"
16141  " This function is not used in any examples. \n"
16142  "\n"
16143  "\n"
16144  "\n"
16145  "SYNOPSIS:\n"
16146  "\n"
16147  "plgdiori(p_rot)\n"
16148  "\n"
16149  "ARGUMENTS:\n"
16150  "\n"
16151  " p_rot (PLFLT *, output) : Pointer to orientation parameter. \n"
16152  "\n"
16153  ""},
16154  { (char *)"plgdiplt", _wrap_plgdiplt, METH_VARARGS, (char *)"\n"
16155  "Get parameters that define current plot-space window \n"
16156  "\n"
16157  "DESCRIPTION:\n"
16158  "\n"
16159  " Get relative minima and maxima that define current plot-space window.\n"
16160  " If plsdiplt has not been called the default values pointed to by\n"
16161  " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n"
16162  "\n"
16163  " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16164  "\n"
16165  " This function is used in example 31. \n"
16166  "\n"
16167  "\n"
16168  "\n"
16169  "SYNOPSIS:\n"
16170  "\n"
16171  "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16172  "\n"
16173  "ARGUMENTS:\n"
16174  "\n"
16175  " p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n"
16176  "\n"
16177  " p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n"
16178  "\n"
16179  " p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n"
16180  "\n"
16181  " p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n"
16182  "\n"
16183  ""},
16184  { (char *)"plgfam", _wrap_plgfam, METH_VARARGS, (char *)"\n"
16185  "Get family file parameters \n"
16186  "\n"
16187  "DESCRIPTION:\n"
16188  "\n"
16189  " Gets information about current family file, if familying is enabled. \n"
16190  " See the PLplot documentation for more information. \n"
16191  "\n"
16192  " Redacted form: plgfam(fam, num, bmax)\n"
16193  "\n"
16194  " This function is used in examples 14,31. \n"
16195  "\n"
16196  "\n"
16197  "\n"
16198  "SYNOPSIS:\n"
16199  "\n"
16200  "plgfam(fam, num, bmax)\n"
16201  "\n"
16202  "ARGUMENTS:\n"
16203  "\n"
16204  " fam (PLINT *, output) : Pointer to variable with the Boolean family\n"
16205  " flag value. If nonzero, familying is enabled. \n"
16206  "\n"
16207  " num (PLINT *, output) : Pointer to variable with the current family\n"
16208  " file number. \n"
16209  "\n"
16210  " bmax (PLINT *, output) : Pointer to variable with the maximum file\n"
16211  " size (in bytes) for a family file. \n"
16212  "\n"
16213  ""},
16214  { (char *)"plgfci", _wrap_plgfci, METH_VARARGS, (char *)"\n"
16215  "Get FCI (font characterization integer) \n"
16216  "\n"
16217  "DESCRIPTION:\n"
16218  "\n"
16219  " Gets information about the current font using the FCI approach. See\n"
16220  " the PLplot documentation for more information. \n"
16221  "\n"
16222  " Redacted form: plgfci(fci)\n"
16223  "\n"
16224  " This function is used in example 23. \n"
16225  "\n"
16226  "\n"
16227  "\n"
16228  "SYNOPSIS:\n"
16229  "\n"
16230  "plgfci(fci)\n"
16231  "\n"
16232  "ARGUMENTS:\n"
16233  "\n"
16234  " fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n"
16235  " integer) variable which is updated with current FCI value. \n"
16236  "\n"
16237  ""},
16238  { (char *)"plgfnam", _wrap_plgfnam, METH_VARARGS, (char *)"\n"
16239  "Get output file name \n"
16240  "\n"
16241  "DESCRIPTION:\n"
16242  "\n"
16243  " Gets the current output file name, if applicable. \n"
16244  "\n"
16245  " Redacted form: plgfnam(fnam)\n"
16246  "\n"
16247  " This function is used in example 31. \n"
16248  "\n"
16249  "\n"
16250  "\n"
16251  "SYNOPSIS:\n"
16252  "\n"
16253  "plgfnam(fnam)\n"
16254  "\n"
16255  "ARGUMENTS:\n"
16256  "\n"
16257  " fnam (char *, output) : Pointer to file name string (a preallocated\n"
16258  " string of 80 characters or more). \n"
16259  "\n"
16260  ""},
16261  { (char *)"plgfont", _wrap_plgfont, METH_VARARGS, (char *)"\n"
16262  "Get family, style and weight of the current font \n"
16263  "\n"
16264  "DESCRIPTION:\n"
16265  "\n"
16266  " Gets information about current font. See the PLplot documentation for\n"
16267  " more information on font selection. \n"
16268  "\n"
16269  " Redacted form: plgfont(p_family, p_style, p_weight)\n"
16270  "\n"
16271  " This function is used in example 23. \n"
16272  "\n"
16273  "\n"
16274  "\n"
16275  "SYNOPSIS:\n"
16276  "\n"
16277  "plgfont(p_family, p_style, p_weight)\n"
16278  "\n"
16279  "ARGUMENTS:\n"
16280  "\n"
16281  " p_family (PLINT *, output) : Pointer to variable with the current\n"
16282  " font family. The available values are given by the PL_FCI_*\n"
16283  " constants in plplot.h. Current options are PL_FCI_SANS,\n"
16284  " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
16285  " p_family is NULL then the font family is not returned. \n"
16286  "\n"
16287  " p_style (PLINT *, output) : Pointer to variable with the current\n"
16288  " font style. The available values are given by the PL_FCI_*\n"
16289  " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
16290  " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n"
16291  " font style is not returned. \n"
16292  "\n"
16293  " p_weight (PLINT *, output) : Pointer to variable with the current\n"
16294  " font weight. The available values are given by the PL_FCI_*\n"
16295  " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
16296  " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
16297  " returned. \n"
16298  "\n"
16299  ""},
16300  { (char *)"plglevel", _wrap_plglevel, METH_VARARGS, (char *)"\n"
16301  "Get the (current) run level \n"
16302  "\n"
16303  "DESCRIPTION:\n"
16304  "\n"
16305  " Get the (current) run level. Valid settings are: 0, uninitialized \n"
16306  " 1, initialized \n"
16307  " 2, viewport defined \n"
16308  " 3, world coordinates defined \n"
16309  "\n"
16310  "\n"
16311  " Redacted form: plglevel(p_level)\n"
16312  "\n"
16313  " This function is used in example 31. \n"
16314  "\n"
16315  "\n"
16316  "\n"
16317  "SYNOPSIS:\n"
16318  "\n"
16319  "plglevel(p_level)\n"
16320  "\n"
16321  "ARGUMENTS:\n"
16322  "\n"
16323  " p_level (PLINT *, output) : Pointer to the run level. \n"
16324  "\n"
16325  ""},
16326  { (char *)"plgpage", _wrap_plgpage, METH_VARARGS, (char *)"\n"
16327  "Get page parameters \n"
16328  "\n"
16329  "DESCRIPTION:\n"
16330  "\n"
16331  " Gets the current page configuration. The length and offset values are\n"
16332  " expressed in units that are specific to the current driver. For\n"
16333  " instance: screen drivers will usually interpret them as number of\n"
16334  " pixels, whereas printer drivers will usually use mm. \n"
16335  "\n"
16336  " Redacted form: plgpage(xp, yp, xleng, yleng, xoff, yoff)\n"
16337  "\n"
16338  " This function is used in examples 14 and 31. \n"
16339  "\n"
16340  "\n"
16341  "\n"
16342  "SYNOPSIS:\n"
16343  "\n"
16344  "plgpage(xp, yp, xleng, yleng, xoff, yoff)\n"
16345  "\n"
16346  "ARGUMENTS:\n"
16347  "\n"
16348  " xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n"
16349  "\n"
16350  " yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in y. \n"
16351  "\n"
16352  " xleng (PLINT *, output) : Pointer to x page length value. \n"
16353  "\n"
16354  " yleng (PLINT *, output) : Pointer to y page length value. \n"
16355  "\n"
16356  " xoff (PLINT *, output) : Pointer to x page offset. \n"
16357  "\n"
16358  " yoff (PLINT *, output) : Pointer to y page offset. \n"
16359  "\n"
16360  ""},
16361  { (char *)"plgra", _wrap_plgra, METH_VARARGS, (char *)"\n"
16362  "Switch to graphics screen \n"
16363  "\n"
16364  "DESCRIPTION:\n"
16365  "\n"
16366  " Sets an interactive device to graphics mode, used in conjunction with\n"
16367  " pltext to allow graphics and text to be interspersed. On a device\n"
16368  " which supports separate text and graphics windows, this command causes\n"
16369  " control to be switched to the graphics window. If already in graphics\n"
16370  " mode, this command is ignored. It is also ignored on devices which\n"
16371  " only support a single window or use a different method for shifting\n"
16372  " focus. See also pltext. \n"
16373  "\n"
16374  " Redacted form: plgra()\n"
16375  "\n"
16376  " This function is used in example 1. \n"
16377  "\n"
16378  "\n"
16379  "\n"
16380  "SYNOPSIS:\n"
16381  "\n"
16382  "plgra()\n"
16383  "\n"
16384  ""},
16385  { (char *)"plgriddata", _wrap_plgriddata, METH_VARARGS, (char *)"\n"
16386  "Grid data from irregularly sampled data \n"
16387  "\n"
16388  "DESCRIPTION:\n"
16389  "\n"
16390  " Real world data is frequently irregularly sampled, but all PLplot 3D\n"
16391  " plots require data placed in a uniform grid. This function takes\n"
16392  " irregularly sampled data from three input arrays x[npts], y[npts], and\n"
16393  " z[npts], reads the desired grid location from input arrays xg[nptsx]\n"
16394  " and yg[nptsy], and returns the gridded data into output array\n"
16395  " zg[nptsx][nptsy]. The algorithm used to grid the data is specified\n"
16396  " with the argument type which can have one parameter specified in\n"
16397  " argument data. \n"
16398  "\n"
16399  " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
16400  " Perl/PDL: Not available? \n"
16401  " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
16402  "\n"
16403  "\n"
16404  " This function is used in example 21. \n"
16405  "\n"
16406  "\n"
16407  "\n"
16408  "SYNOPSIS:\n"
16409  "\n"
16410  "plggriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
16411  "\n"
16412  "ARGUMENTS:\n"
16413  "\n"
16414  " x (PLFLT *, input) : The input x array. \n"
16415  "\n"
16416  " y (PLFLT *, input) : The input y array. \n"
16417  "\n"
16418  " z (PLFLT *, input) : The input z array. Each triple x[i], y[i],\n"
16419  " z[i] represents one data sample coordinate. \n"
16420  "\n"
16421  " npts (PLINT, input) : The number of data samples in the x, y and z\n"
16422  " arrays. \n"
16423  "\n"
16424  " xg (PLFLT *, input) : The input array that specifies the grid\n"
16425  " spacing in the x direction. Usually xg has nptsx equally spaced\n"
16426  " values from the minimum to the maximum values of the x input\n"
16427  " array. \n"
16428  "\n"
16429  " nptsx (PLINT, input) : The number of points in the xg array. \n"
16430  "\n"
16431  " yg (PLFLT *, input) : The input array that specifies the grid\n"
16432  " spacing in the y direction. Similar to the xg parameter. \n"
16433  "\n"
16434  " nptsy (PLINT, input) : The number of points in the yg array. \n"
16435  "\n"
16436  " zg (PLFLT **, output) : The output array, where data lies in the\n"
16437  " regular grid specified by xg and yg. the zg array must exist or be\n"
16438  " allocated by the user prior to the call, and must have dimension\n"
16439  " zg[nptsx][nptsy]. \n"
16440  "\n"
16441  " type (PLINT, input) : The type of gridding algorithm to use, which\n"
16442  " can be: GRID_CSA: Bivariate Cubic Spline approximation \n"
16443  " GRID_DTLI: Delaunay Triangulation Linear Interpolation \n"
16444  " GRID_NNI: Natural Neighbors Interpolation \n"
16445  " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted \n"
16446  " GRID_NNLI: Nearest Neighbors Linear Interpolation \n"
16447  " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
16448  " Weighted \n"
16449  " For details of the algorithms read the source file plgridd.c. \n"
16450  "\n"
16451  " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
16452  " which can be specified through this argument. Currently, for\n"
16453  " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
16454  " use, the lower the value, the noisier (more local) the\n"
16455  " approximation is. \n"
16456  " GRID_NNLI, data specifies what a thin triangle is, in the\n"
16457  " range [1. .. 2.]. High values enable the usage of very thin\n"
16458  " triangles for interpolation, possibly resulting in error in\n"
16459  " the approximation. \n"
16460  " GRID_NNI, only weights greater than data will be accepted. If\n"
16461  " 0, all weights will be accepted. \n"
16462  "\n"
16463  ""},
16464  { (char *)"plgspa", _wrap_plgspa, METH_VARARGS, (char *)"\n"
16465  "Get current subpage parameters \n"
16466  "\n"
16467  "DESCRIPTION:\n"
16468  "\n"
16469  " Gets the size of the current subpage in millimeters measured from the\n"
16470  " bottom left hand corner of the output device page or screen. Can be\n"
16471  " used in conjunction with plsvpa for setting the size of a viewport in\n"
16472  " absolute coordinates (millimeters). \n"
16473  "\n"
16474  " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
16475  "\n"
16476  " This function is used in example 23. \n"
16477  "\n"
16478  "\n"
16479  "\n"
16480  "SYNOPSIS:\n"
16481  "\n"
16482  "plgspa(xmin, xmax, ymin, ymax)\n"
16483  "\n"
16484  "ARGUMENTS:\n"
16485  "\n"
16486  " xmin (PLFLT *, output) : Pointer to variable with position of left\n"
16487  " hand edge of subpage in millimeters. \n"
16488  "\n"
16489  " xmax (PLFLT *, output) : Pointer to variable with position of right\n"
16490  " hand edge of subpage in millimeters. \n"
16491  "\n"
16492  " ymin (PLFLT *, output) : Pointer to variable with position of\n"
16493  " bottom edge of subpage in millimeters. \n"
16494  "\n"
16495  " ymax (PLFLT *, output) : Pointer to variable with position of top\n"
16496  " edge of subpage in millimeters. \n"
16497  "\n"
16498  ""},
16499  { (char *)"plgstrm", _wrap_plgstrm, METH_VARARGS, (char *)"\n"
16500  "Get current stream number \n"
16501  "\n"
16502  "DESCRIPTION:\n"
16503  "\n"
16504  " Gets the number of the current output stream. See also plsstrm. \n"
16505  "\n"
16506  " Redacted form: plgstrm(strm)\n"
16507  "\n"
16508  " This function is used in example 1,20. \n"
16509  "\n"
16510  "\n"
16511  "\n"
16512  "SYNOPSIS:\n"
16513  "\n"
16514  "plgstrm(strm)\n"
16515  "\n"
16516  "ARGUMENTS:\n"
16517  "\n"
16518  " strm (PLINT *, output) : Pointer to current stream value. \n"
16519  "\n"
16520  ""},
16521  { (char *)"plgver", _wrap_plgver, METH_VARARGS, (char *)"\n"
16522  "Get the current library version number \n"
16523  "\n"
16524  "DESCRIPTION:\n"
16525  "\n"
16526  " Get the current library version number. Note: you must have allocated\n"
16527  " space for this (80 characters is safe). \n"
16528  "\n"
16529  " Redacted form: plgver(p_ver)\n"
16530  "\n"
16531  " This function is used in example 1. \n"
16532  "\n"
16533  "\n"
16534  "\n"
16535  "SYNOPSIS:\n"
16536  "\n"
16537  "plgver(p_ver)\n"
16538  "\n"
16539  "ARGUMENTS:\n"
16540  "\n"
16541  " p_ver (char *, output) : Pointer to the current library version\n"
16542  " number. \n"
16543  "\n"
16544  ""},
16545  { (char *)"plgvpd", _wrap_plgvpd, METH_VARARGS, (char *)"\n"
16546  "Get viewport limits in normalized device coordinates \n"
16547  "\n"
16548  "DESCRIPTION:\n"
16549  "\n"
16550  " Get viewport limits in normalized device coordinates. \n"
16551  "\n"
16552  " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16553  " Perl/PDL: Not available? \n"
16554  "\n"
16555  "\n"
16556  " This function is used in example 31. \n"
16557  "\n"
16558  "\n"
16559  "\n"
16560  "SYNOPSIS:\n"
16561  "\n"
16562  "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16563  "\n"
16564  "ARGUMENTS:\n"
16565  "\n"
16566  " p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n"
16567  " device coordinate in x. \n"
16568  "\n"
16569  " p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n"
16570  " device coordinate in x. \n"
16571  "\n"
16572  " p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n"
16573  " device coordinate in y. \n"
16574  "\n"
16575  " p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n"
16576  " device coordinate in y. \n"
16577  "\n"
16578  ""},
16579  { (char *)"plgvpw", _wrap_plgvpw, METH_VARARGS, (char *)"\n"
16580  "Get viewport limits in world coordinates \n"
16581  "\n"
16582  "DESCRIPTION:\n"
16583  "\n"
16584  " Get viewport limits in world coordinates. \n"
16585  "\n"
16586  " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16587  " Perl/PDL: Not available? \n"
16588  "\n"
16589  "\n"
16590  " This function is used in example 31. \n"
16591  "\n"
16592  "\n"
16593  "\n"
16594  "SYNOPSIS:\n"
16595  "\n"
16596  "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16597  "\n"
16598  "ARGUMENTS:\n"
16599  "\n"
16600  " p_xmin (PLFLT *, output) : Lower viewport limit of the world\n"
16601  " coordinate in x. \n"
16602  "\n"
16603  " p_xmax (PLFLT *, output) : Upper viewport limit of the world\n"
16604  " coordinate in x. \n"
16605  "\n"
16606  " p_ymin (PLFLT *, output) : Lower viewport limit of the world\n"
16607  " coordinate in y. \n"
16608  "\n"
16609  " p_ymax (PLFLT *, output) : Upper viewport limit of the world\n"
16610  " coordinate in y. \n"
16611  "\n"
16612  ""},
16613  { (char *)"plgxax", _wrap_plgxax, METH_VARARGS, (char *)"\n"
16614  "Get x axis parameters \n"
16615  "\n"
16616  "DESCRIPTION:\n"
16617  "\n"
16618  " Returns current values of the digmax and digits flags for the x axis. \n"
16619  " digits is updated after the plot is drawn, so this routine should only\n"
16620  " be called after the call to plbox (or plbox3) is complete. See the\n"
16621  " PLplot documentation for more information. \n"
16622  "\n"
16623  " Redacted form: plgxax(digmax, digits)\n"
16624  "\n"
16625  " This function is used in example 31. \n"
16626  "\n"
16627  "\n"
16628  "\n"
16629  "SYNOPSIS:\n"
16630  "\n"
16631  "plgxax(digmax, digits)\n"
16632  "\n"
16633  "ARGUMENTS:\n"
16634  "\n"
16635  " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16636  " number of digits for the x axis. If nonzero, the printed label\n"
16637  " has been switched to a floating point representation when the\n"
16638  " number of digits exceeds digmax. \n"
16639  "\n"
16640  " digits (PLINT *, output) : Pointer to variable with the actual\n"
16641  " number of digits for the numeric labels (x axis) from the last\n"
16642  " plot. \n"
16643  "\n"
16644  ""},
16645  { (char *)"plgyax", _wrap_plgyax, METH_VARARGS, (char *)"\n"
16646  "Get y axis parameters \n"
16647  "\n"
16648  "DESCRIPTION:\n"
16649  "\n"
16650  " Identical to plgxax, except that arguments are flags for y axis. See\n"
16651  " the description of plgxax for more detail. \n"
16652  "\n"
16653  " Redacted form: plgyax(digmax, digits)\n"
16654  "\n"
16655  " This function is used in example 31. \n"
16656  "\n"
16657  "\n"
16658  "\n"
16659  "SYNOPSIS:\n"
16660  "\n"
16661  "plgyax(digmax, digits)\n"
16662  "\n"
16663  "ARGUMENTS:\n"
16664  "\n"
16665  " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16666  " number of digits for the y axis. If nonzero, the printed label\n"
16667  " has been switched to a floating point representation when the\n"
16668  " number of digits exceeds digmax. \n"
16669  "\n"
16670  " digits (PLINT *, output) : Pointer to variable with the actual\n"
16671  " number of digits for the numeric labels (y axis) from the last\n"
16672  " plot. \n"
16673  "\n"
16674  ""},
16675  { (char *)"plgzax", _wrap_plgzax, METH_VARARGS, (char *)"\n"
16676  "Get z axis parameters \n"
16677  "\n"
16678  "DESCRIPTION:\n"
16679  "\n"
16680  " Identical to plgxax, except that arguments are flags for z axis. See\n"
16681  " the description of plgxax for more detail. \n"
16682  "\n"
16683  " Redacted form: plgzax(digmax, digits)\n"
16684  "\n"
16685  " This function is used in example 31. \n"
16686  "\n"
16687  "\n"
16688  "\n"
16689  "SYNOPSIS:\n"
16690  "\n"
16691  "plgzax(digmax, digits)\n"
16692  "\n"
16693  "ARGUMENTS:\n"
16694  "\n"
16695  " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16696  " number of digits for the z axis. If nonzero, the printed label\n"
16697  " has been switched to a floating point representation when the\n"
16698  " number of digits exceeds digmax. \n"
16699  "\n"
16700  " digits (PLINT *, output) : Pointer to variable with the actual\n"
16701  " number of digits for the numeric labels (z axis) from the last\n"
16702  " plot. \n"
16703  "\n"
16704  ""},
16705  { (char *)"plhist", _wrap_plhist, METH_VARARGS, (char *)"\n"
16706  "Plot a histogram from unbinned data \n"
16707  "\n"
16708  "DESCRIPTION:\n"
16709  "\n"
16710  " Plots a histogram from n data points stored in the array data. This\n"
16711  " routine bins the data into nbin bins equally spaced between datmin and\n"
16712  " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
16713  " opt allows, among other things, the histogram either to be plotted in\n"
16714  " an existing window or causes plhist to call plenv with suitable limits\n"
16715  " before plotting the histogram. \n"
16716  "\n"
16717  " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
16718  "\n"
16719  " This function is used in example 5. \n"
16720  "\n"
16721  "\n"
16722  "\n"
16723  "SYNOPSIS:\n"
16724  "\n"
16725  "plhist(n, data, datmin, datmax, nbin, opt)\n"
16726  "\n"
16727  "ARGUMENTS:\n"
16728  "\n"
16729  " n (PLINT, input) : Number of data points. \n"
16730  "\n"
16731  " data (PLFLT *, input) : Pointer to array with values of the n data\n"
16732  " points. \n"
16733  "\n"
16734  " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n"
16735  "\n"
16736  " datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n"
16737  "\n"
16738  " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
16739  " divide the interval xmin to xmax. \n"
16740  "\n"
16741  " opt (PLINT, input) : Is a combination of several flags:\n"
16742  " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
16743  " the histogram data, the outer bins are expanded to fill up the\n"
16744  " entire x-axis, data outside the given extremes are assigned to the\n"
16745  " outer bins and bins of zero height are simply drawn. \n"
16746  " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
16747  " to fit the histogram data, without this flag, plenv is called\n"
16748  " to set the world coordinates. \n"
16749  " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
16750  " extremes are not taken into account. This option should\n"
16751  " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
16752  " properly present the data. \n"
16753  " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
16754  " size as the ones inside. \n"
16755  " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
16756  " (there is a gap for such bins). \n"
16757  "\n"
16758  ""},
16759  { (char *)"plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, (char *)"\n"
16760  "Convert HLS color to RGB \n"
16761  "\n"
16762  "DESCRIPTION:\n"
16763  "\n"
16764  " Convert HLS color coordinates to RGB. \n"
16765  "\n"
16766  " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16767  " Perl/PDL: Not available? Implemented as plhls? \n"
16768  "\n"
16769  "\n"
16770  " This function is used in example 2. \n"
16771  "\n"
16772  "\n"
16773  "\n"
16774  "SYNOPSIS:\n"
16775  "\n"
16776  "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16777  "\n"
16778  "ARGUMENTS:\n"
16779  "\n"
16780  " h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n"
16781  "\n"
16782  " l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n"
16783  " of the colour cone (0.0-1.0) \n"
16784  "\n"
16785  " s (PLFLT, input) : Saturation, expressed as a fraction of the\n"
16786  " radius of the colour cone (0.0-1.0) \n"
16787  "\n"
16788  " p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n"
16789  " colour \n"
16790  "\n"
16791  " p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n"
16792  " colour \n"
16793  "\n"
16794  " p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n"
16795  " colour \n"
16796  "\n"
16797  ""},
16798  { (char *)"plinit", _wrap_plinit, METH_VARARGS, (char *)"\n"
16799  "Initialize PLplot \n"
16800  "\n"
16801  "DESCRIPTION:\n"
16802  "\n"
16803  " Initializing the plotting package. The program prompts for the device\n"
16804  " keyword or number of the desired output device. Hitting a RETURN in\n"
16805  " response to the prompt is the same as selecting the first device. \n"
16806  " plinit will issue no prompt if either the device was specified\n"
16807  " previously (via command line flag, the plsetopt function, or the\n"
16808  " plsdev function), or if only one device is enabled when PLplot is\n"
16809  " installed. If subpages have been specified, the output device is\n"
16810  " divided into nx by ny subpages, each of which may be used\n"
16811  " independently. If plinit is called again during a program, the\n"
16812  " previously opened file will be closed. The subroutine pladv is used\n"
16813  " to advance from one subpage to the next. \n"
16814  "\n"
16815  " Redacted form: plinit()\n"
16816  "\n"
16817  " This function is used in all of the examples. \n"
16818  "\n"
16819  "\n"
16820  "\n"
16821  "SYNOPSIS:\n"
16822  "\n"
16823  "plinit()\n"
16824  "\n"
16825  ""},
16826  { (char *)"pljoin", _wrap_pljoin, METH_VARARGS, (char *)"\n"
16827  "Draw a line between two points \n"
16828  "\n"
16829  "DESCRIPTION:\n"
16830  "\n"
16831  " Joins the point (\n"
16832  " x1, \n"
16833  " y1) to (\n"
16834  " x2, \n"
16835  " y2). \n"
16836  "\n"
16837  " Redacted form: pljoin(x1,y1,x2,y2)\n"
16838  "\n"
16839  " This function is used in examples 3,14. \n"
16840  "\n"
16841  "\n"
16842  "\n"
16843  "SYNOPSIS:\n"
16844  "\n"
16845  "pljoin(x1, y1, x2, y2)\n"
16846  "\n"
16847  "ARGUMENTS:\n"
16848  "\n"
16849  " x1 (PLFLT, input) : x coordinate of first point. \n"
16850  "\n"
16851  " y1 (PLFLT, input) : y coordinate of first point. \n"
16852  "\n"
16853  " x2 (PLFLT, input) : x coordinate of second point. \n"
16854  "\n"
16855  " y2 (PLFLT, input) : y coordinate of second point. \n"
16856  "\n"
16857  ""},
16858  { (char *)"pllab", _wrap_pllab, METH_VARARGS, (char *)"\n"
16859  "Simple routine to write labels \n"
16860  "\n"
16861  "DESCRIPTION:\n"
16862  "\n"
16863  " Routine for writing simple labels. Use plmtex for more complex labels. \n"
16864  "\n"
16865  " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
16866  "\n"
16867  " This function is used in examples 1,5,9,12,14-16,20-22,29. \n"
16868  "\n"
16869  "\n"
16870  "\n"
16871  "SYNOPSIS:\n"
16872  "\n"
16873  "pllab(xlabel, ylabel, tlabel)\n"
16874  "\n"
16875  "ARGUMENTS:\n"
16876  "\n"
16877  " xlabel (const char *, input) : Label for horizontal axis. \n"
16878  "\n"
16879  " ylabel (const char *, input) : Label for vertical axis. \n"
16880  "\n"
16881  " tlabel (const char *, input) : Title of graph. \n"
16882  "\n"
16883  ""},
16884  { (char *)"pllegend", _wrap_pllegend, METH_VARARGS, (char *)"\n"
16885  "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n"
16886  "\n"
16887  "DESCRIPTION:\n"
16888  "\n"
16889  " Routine for creating a discrete plot legend with a plotted filled box,\n"
16890  " line, and/or line of symbols for each annotated legend entry. The\n"
16891  " arguments of pllegend provide control over the location and size of\n"
16892  " the legend as well as the location and characteristics of the elements\n"
16893  " (most of which are optional) within that legend. The resulting legend\n"
16894  " is clipped at the boundaries of the current subpage. (N.B. the adopted\n"
16895  " coordinate system used for some of the parameters is defined in the\n"
16896  " documentation of the position parameter.) \n"
16897  "\n"
16898  " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
16899  " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
16900  " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
16901  " test_justification, text_colors, text, box_colors, box_patterns,\n"
16902  " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
16903  " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
16904  "\n"
16905  " This function is used in examples 4 and 26. \n"
16906  "\n"
16907  "\n"
16908  "\n"
16909  "SYNOPSIS:\n"
16910  "\n"
16911  "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"
16912  "\n"
16913  "ARGUMENTS:\n"
16914  "\n"
16915  " p_legend_width (PLFLT *, output) : Pointer to a location which\n"
16916  " contains (after the call) the legend width in adopted coordinates.\n"
16917  " This quantity is calculated from plot_width, text_offset, ncolumn\n"
16918  " (possibly modified inside the routine depending on nlegend and\n"
16919  " nrow), and the length (calculated internally) of the longest text\n"
16920  " string. \n"
16921  "\n"
16922  " p_legend_height (PLFLT *, output) : Pointer to a location which\n"
16923  " contains (after the call) the legend height in adopted\n"
16924  " coordinates. This quantity is calculated from text_scale,\n"
16925  " text_spacing, and nrow (possibly modified inside the routine\n"
16926  " depending on nlegend and nrow). \n"
16927  "\n"
16928  " opt (PLINT, input) : opt contains bits controlling the overall\n"
16929  " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
16930  " on the left of the legend and the plotted area on the right.\n"
16931  " Otherwise, put the text area on the right of the legend and the\n"
16932  " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
16933  " plot a (semi-transparent) background for the legend. If the\n"
16934  " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
16935  " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
16936  " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
16937  " plot the resulting array of legend entries in row-major order.\n"
16938  " Otherwise, plot the legend entries in column-major order. \n"
16939  "\n"
16940  " position (PLINT, input) : position contains bits controlling the\n"
16941  " overall position of the legend and the definition of the adopted\n"
16942  " coordinates used for positions. The combination of the\n"
16943  " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP,\n"
16944  " PL_POSITION_BOTTOM, PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE\n"
16945  " bits specifies one of the 16 possible standard positions (the 4\n"
16946  " corners and 4 side centers for both the inside and outside cases)\n"
16947  " of the legend relative to the adopted coordinate system. The\n"
16948  " adopted coordinates are normalized viewport coordinates if the\n"
16949  " PL_POSITION_VIEWPORT bit is set or normalized subpage coordinates\n"
16950  " if the PL_POSITION_SUBPAGE bit is set. Default position bits: If\n"
16951  " none of PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, or\n"
16952  " PL_POSITION_BOTTOM are set, then use the combination of\n"
16953  " PL_POSITION_RIGHT and PL_POSITION_TOP. If neither of\n"
16954  " PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set, use\n"
16955  " PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
16956  " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n"
16957  "\n"
16958  " x (PLFLT, input) : X offset of the legend position in adopted\n"
16959  " coordinates from the specified standard position of the legend.\n"
16960  " For positive x, the direction of motion away from the standard\n"
16961  " position is inward/outward from the standard corner positions or\n"
16962  " standard left or right positions if the\n"
16963  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
16964  " For the standard top or bottom positions, the direction of motion\n"
16965  " is toward positive X. \n"
16966  "\n"
16967  " y (PLFLT, input) : Y offset of the legend position in adopted\n"
16968  " coordinates from the specified standard position of the legend.\n"
16969  " For positive y, the direction of motion away from the standard\n"
16970  " position is inward/outward from the standard corner positions or\n"
16971  " standard top or bottom positions if the\n"
16972  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
16973  " For the standard left or right positions, the direction of motion\n"
16974  " is toward positive Y. \n"
16975  "\n"
16976  " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
16977  " of the plot area (where the colored boxes, lines, and/or lines of\n"
16978  " symbols are drawn) of the legend. \n"
16979  "\n"
16980  " bg_color (PLINT, input) : The cmap0 index of the background color\n"
16981  " for the legend (PL_LEGEND_BACKGROUND). \n"
16982  "\n"
16983  " bb_color (PLINT, input) : The cmap0 index of the color of the\n"
16984  " bounding-box line for the legend (PL_LEGEND_BOUNDING_BOX). \n"
16985  "\n"
16986  " bb_style (PLINT, input) : The cmap0 index of the background color\n"
16987  " for the legend (PL_LEGEND_BACKGROUND). \n"
16988  "\n"
16989  " nrow (PLINT, input) : The cmap0 index of the background color for\n"
16990  " the legend (PL_LEGEND_BACKGROUND). \n"
16991  "\n"
16992  " ncolumn (PLINT, input) : The cmap0 index of the background color\n"
16993  " for the legend (PL_LEGEND_BACKGROUND). \n"
16994  "\n"
16995  " nlegend (PLINT, input) : Number of legend entries. N.B. The total\n"
16996  " vertical height of the legend in adopted coordinates is calculated\n"
16997  " internally from nlegend, text_scale (see below), and text_spacing\n"
16998  " (see below). \n"
16999  "\n"
17000  " opt_array (const PLINT *, input) : Array of nlegend values of\n"
17001  " options to control each individual plotted area corresponding to a\n"
17002  " legend entry. If the \n"
17003  " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
17004  " area. If the \n"
17005  " PL_LEGEND_COLOR_BOX, \n"
17006  " PL_LEGEND_LINE, and/or \n"
17007  " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
17008  " entry is plotted with a colored box; a line; and/or a line of\n"
17009  " symbols. \n"
17010  "\n"
17011  " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
17012  " area in units of character width. N.B. The total horizontal\n"
17013  " width of the legend in adopted coordinates is calculated\n"
17014  " internally from \n"
17015  " plot_width (see above), \n"
17016  " text_offset, and length (calculated internally) of the longest text\n"
17017  " string. \n"
17018  "\n"
17019  " text_scale (PLFLT, input) : Character height scale for text\n"
17020  " annotations. N.B. The total vertical height of the legend in\n"
17021  " adopted coordinates is calculated internally from \n"
17022  " nlegend (see above), \n"
17023  " text_scale, and \n"
17024  " text_spacing (see below). \n"
17025  "\n"
17026  " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
17027  " character height from one legend entry to the next. N.B. The\n"
17028  " total vertical height of the legend in adopted coordinates is\n"
17029  " calculated internally from \n"
17030  " nlegend (see above), \n"
17031  " text_scale (see above), and \n"
17032  " text_spacing. \n"
17033  "\n"
17034  " text_justification (PLFLT, input) : Justification parameter used\n"
17035  " for text justification. The most common values of\n"
17036  " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
17037  " is left justified, centred, or right justified within the text\n"
17038  " area, but other values are allowed as well. \n"
17039  "\n"
17040  " text_colors (const PLINT *, input) : Array of nlegend text colors\n"
17041  " (cmap0 indices). \n"
17042  "\n"
17043  " text (const char **, input) : Array of nlegend text string\n"
17044  " annotations. \n"
17045  "\n"
17046  " box_colors (const PLINT *, input) : Array of nlegend colors (cmap0\n"
17047  " indices) for the discrete colored boxes (\n"
17048  " PL_LEGEND_COLOR_BOX). \n"
17049  "\n"
17050  " box_patterns (const PLINT *, input) : Array of nlegend patterns\n"
17051  " (plpsty indices) for the discrete colored boxes (\n"
17052  " PL_LEGEND_COLOR_BOX). \n"
17053  "\n"
17054  " box_scales (const PLFLT *, input) : Array of nlegend scales (units\n"
17055  " of fraction of character height) for the height of the discrete\n"
17056  " colored boxes (\n"
17057  " PL_LEGEND_COLOR_BOX). \n"
17058  "\n"
17059  " box_line_widths (const PLFLT *, input) : Array of nlegend line\n"
17060  " widths for the patterns specified by box_patterns (\n"
17061  " PL_LEGEND_COLOR_BOX). \n"
17062  "\n"
17063  " line_colors (const PLINT *, input) : Array of nlegend line colors\n"
17064  " (cmap0 indices) (\n"
17065  " PL_LEGEND_LINE). \n"
17066  "\n"
17067  " line_styles (const PLINT *, input) : Array of nlegend line styles\n"
17068  " (plsty indices) (\n"
17069  " PL_LEGEND_LINE). \n"
17070  "\n"
17071  " line_widths (const PLFLT *, input) : Array of nlegend line widths (\n"
17072  " PL_LEGEND_LINE). \n"
17073  "\n"
17074  " symbol_colors (const PLINT *, input) : Array of nlegend symbol\n"
17075  " colors (cmap0 indices) (\n"
17076  " PL_LEGEND_SYMBOL). \n"
17077  "\n"
17078  " symbol_scales (const PLFLT *, input) : Array of nlegend scale\n"
17079  " values for the symbol height (\n"
17080  " PL_LEGEND_SYMBOL). \n"
17081  "\n"
17082  " symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n"
17083  " symbols to be drawn across the width of the plotted area (\n"
17084  " PL_LEGEND_SYMBOL). \n"
17085  "\n"
17086  " symbols (const char **, input) : Array of nlegend symbols (plpoin\n"
17087  " indices) (\n"
17088  " PL_LEGEND_SYMBOL). \n"
17089  "\n"
17090  ""},
17091  { (char *)"plcolorbar", _wrap_plcolorbar, METH_VARARGS, NULL},
17092  { (char *)"pllightsource", _wrap_pllightsource, METH_VARARGS, (char *)"\n"
17093  "Sets the 3D position of the light source \n"
17094  "\n"
17095  "DESCRIPTION:\n"
17096  "\n"
17097  " Sets the 3D position of the light source for use with plsurf3d. \n"
17098  "\n"
17099  " Redacted form: pllightsource(x, y, z)\n"
17100  "\n"
17101  " This function is used in example 8. \n"
17102  "\n"
17103  "\n"
17104  "\n"
17105  "SYNOPSIS:\n"
17106  "\n"
17107  "pllightsource(x, y, z)\n"
17108  "\n"
17109  "ARGUMENTS:\n"
17110  "\n"
17111  " x (PLFLT, input) : X-coordinate of the light source. \n"
17112  "\n"
17113  " y (PLFLT, input) : Y-coordinate of the light source. \n"
17114  "\n"
17115  " z (PLFLT, input) : Z-coordinate of the light source. \n"
17116  "\n"
17117  ""},
17118  { (char *)"plline", _wrap_plline, METH_VARARGS, (char *)"\n"
17119  "Draw a line \n"
17120  "\n"
17121  "DESCRIPTION:\n"
17122  "\n"
17123  " Draws line defined by n points in x and y. \n"
17124  "\n"
17125  " Redacted form: plline(x, y)\n"
17126  "\n"
17127  " This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n"
17128  "\n"
17129  "\n"
17130  "\n"
17131  "SYNOPSIS:\n"
17132  "\n"
17133  "plline(n, x, y)\n"
17134  "\n"
17135  "ARGUMENTS:\n"
17136  "\n"
17137  " n (PLINT, input) : Number of points defining line. \n"
17138  "\n"
17139  " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
17140  "\n"
17141  " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
17142  "\n"
17143  ""},
17144  { (char *)"plline3", _wrap_plline3, METH_VARARGS, (char *)"\n"
17145  "Draw a line in 3 space \n"
17146  "\n"
17147  "DESCRIPTION:\n"
17148  "\n"
17149  " Draws line in 3 space defined by n points in x, y, and z. You must\n"
17150  " first set up the viewport, the 2d viewing window (in world\n"
17151  " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
17152  " more info. \n"
17153  "\n"
17154  " Redacted form: plline3(x, y, z)\n"
17155  "\n"
17156  " This function is used in example 18. \n"
17157  "\n"
17158  "\n"
17159  "\n"
17160  "SYNOPSIS:\n"
17161  "\n"
17162  "plline3(n, x, y, z)\n"
17163  "\n"
17164  "ARGUMENTS:\n"
17165  "\n"
17166  " n (PLINT, input) : Number of points defining line. \n"
17167  "\n"
17168  " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
17169  "\n"
17170  " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
17171  "\n"
17172  " z (PLFLT *, input) : Pointer to array with z coordinates of points. \n"
17173  "\n"
17174  ""},
17175  { (char *)"pllsty", _wrap_pllsty, METH_VARARGS, (char *)"\n"
17176  "Select line style \n"
17177  "\n"
17178  "DESCRIPTION:\n"
17179  "\n"
17180  " This sets the line style according to one of eight predefined patterns\n"
17181  " (also see plstyl). \n"
17182  "\n"
17183  " Redacted form: pllsty(n)\n"
17184  "\n"
17185  " This function is used in examples 9,12,22,25. \n"
17186  "\n"
17187  "\n"
17188  "\n"
17189  "SYNOPSIS:\n"
17190  "\n"
17191  "pllsty(n)\n"
17192  "\n"
17193  "ARGUMENTS:\n"
17194  "\n"
17195  " n (PLINT, input) : Integer value between 1 and 8. Line style 1 is a\n"
17196  " continuous line, line style 2 is a line with short dashes and\n"
17197  " gaps, line style 3 is a line with long dashes and gaps, line style\n"
17198  " 4 has long dashes and short gaps and so on. \n"
17199  "\n"
17200  ""},
17201  { (char *)"plmesh", _wrap_plmesh, METH_VARARGS, (char *)"\n"
17202  "Plot surface mesh \n"
17203  "\n"
17204  "DESCRIPTION:\n"
17205  "\n"
17206  " Plots a surface mesh within the environment set up by plw3d. The\n"
17207  " surface is defined by the two-dimensional array z[\n"
17208  " nx][\n"
17209  " ny], the point z[i][j] being the value of the function at (\n"
17210  " x[i], \n"
17211  " y[j]). Note that the points in arrays x and y do not need to be\n"
17212  " equally spaced, but must be stored in ascending order. The parameter\n"
17213  " opt controls the way in which the surface is displayed. For further\n"
17214  " details see the PLplot documentation. \n"
17215  "\n"
17216  " Redacted form: plmesh(x, y, z, opt)\n"
17217  "\n"
17218  " This function is used in example 11. \n"
17219  "\n"
17220  "\n"
17221  "\n"
17222  "SYNOPSIS:\n"
17223  "\n"
17224  "plmesh(x, y, z, nx, ny, opt)\n"
17225  "\n"
17226  "ARGUMENTS:\n"
17227  "\n"
17228  " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17229  " the function is evaluated. \n"
17230  "\n"
17231  " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17232  " the function is evaluated. \n"
17233  "\n"
17234  " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17235  " with set of function values. \n"
17236  "\n"
17237  " nx (PLINT, input) : Number of x values at which function is\n"
17238  " evaluated. \n"
17239  "\n"
17240  " ny (PLINT, input) : Number of y values at which function is\n"
17241  " evaluated. \n"
17242  "\n"
17243  " opt (PLINT, input) : Determines the way in which the surface is\n"
17244  " represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
17245  " function of x for each value of y[j]. \n"
17246  " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17247  " for each value of x[i]. \n"
17248  " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17249  " at which function is defined. \n"
17250  "\n"
17251  ""},
17252  { (char *)"plmeshc", _wrap_plmeshc, METH_VARARGS, (char *)"\n"
17253  "Magnitude colored plot surface mesh with contour. \n"
17254  "\n"
17255  "DESCRIPTION:\n"
17256  "\n"
17257  " Identical to plmesh but with extra functionalities: the surface mesh\n"
17258  " can be colored accordingly to the current z value being plotted, a\n"
17259  " contour plot can be drawn at the base XY plane, and a curtain can be\n"
17260  " drawn between the plotted function border and the base XY plane. \n"
17261  "\n"
17262  " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
17263  "\n"
17264  " This function is used in example 11. \n"
17265  "\n"
17266  "\n"
17267  "\n"
17268  "SYNOPSIS:\n"
17269  "\n"
17270  "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17271  "\n"
17272  "ARGUMENTS:\n"
17273  "\n"
17274  " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17275  " the function is evaluated. \n"
17276  "\n"
17277  " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17278  " the function is evaluated. \n"
17279  "\n"
17280  " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17281  " with set of function values. \n"
17282  "\n"
17283  " nx (PLINT, input) : Number of x values at which function is\n"
17284  " evaluated. \n"
17285  "\n"
17286  " ny (PLINT, input) : Number of y values at which function is\n"
17287  " evaluated. \n"
17288  "\n"
17289  " opt (PLINT, input) : Determines the way in which the surface is\n"
17290  " represented. To specify more than one option just add the options,\n"
17291  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX: Lines are drawn\n"
17292  " showing z as a function of x for each value of y[j]. \n"
17293  " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17294  " for each value of x[i]. \n"
17295  " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17296  " at which function is defined. \n"
17297  " opt=MAG_COLOR: Each line in the mesh is colored according to\n"
17298  " the z value being plotted. The color is used from the current\n"
17299  " colormap 1. \n"
17300  " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
17301  " using parameters \n"
17302  " nlevel and \n"
17303  " clevel. \n"
17304  " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
17305  " the borders of the plotted function. \n"
17306  "\n"
17307  "\n"
17308  " clevel (PLFLT *, input) : Pointer to the array that defines the\n"
17309  " contour level spacing. \n"
17310  "\n"
17311  " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
17312  "\n"
17313  ""},
17314  { (char *)"plmkstrm", _wrap_plmkstrm, METH_VARARGS, (char *)"\n"
17315  "Creates a new stream and makes it the default \n"
17316  "\n"
17317  "DESCRIPTION:\n"
17318  "\n"
17319  " Creates a new stream and makes it the default. Differs from using\n"
17320  " plsstrm, in that a free stream number is found, and returned.\n"
17321  " Unfortunately, I have to start at stream 1 and work upward, since\n"
17322  " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
17323  " that no initial, library-opening call is required. So stream 0 must\n"
17324  " be preallocated, and there is no simple way of determining whether it\n"
17325  " is already in use or not. \n"
17326  "\n"
17327  " Redacted form: plmkstrm(p_strm)\n"
17328  "\n"
17329  " This function is used in examples 1,20. \n"
17330  "\n"
17331  "\n"
17332  "\n"
17333  "SYNOPSIS:\n"
17334  "\n"
17335  "plmkstrm(p_strm)\n"
17336  "\n"
17337  "ARGUMENTS:\n"
17338  "\n"
17339  " p_strm (PLINT *, output) : Pointer to stream number of the created\n"
17340  " stream. \n"
17341  "\n"
17342  ""},
17343  { (char *)"plmtex", _wrap_plmtex, METH_VARARGS, (char *)"\n"
17344  "Write text relative to viewport boundaries \n"
17345  "\n"
17346  "DESCRIPTION:\n"
17347  "\n"
17348  " Writes text at a specified position relative to the viewport\n"
17349  " boundaries. Text may be written inside or outside the viewport, but\n"
17350  " is clipped at the subpage boundaries. The reference point of a string\n"
17351  " lies along a line passing through the string at half the height of a\n"
17352  " capital letter. The position of the reference point along this line\n"
17353  " is determined by just, and the position of the reference point\n"
17354  " relative to the viewport is set by disp and pos. \n"
17355  "\n"
17356  " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
17357  " Perl/PDL: plmtex(disp, pos, just, side, text)\n"
17358  "\n"
17359  "\n"
17360  " This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n"
17361  "\n"
17362  "\n"
17363  "\n"
17364  "SYNOPSIS:\n"
17365  "\n"
17366  "plmtex(side, disp, pos, just, text)\n"
17367  "\n"
17368  "ARGUMENTS:\n"
17369  "\n"
17370  " side (const char *, input) : Specifies the side of the viewport\n"
17371  " along which the text is to be written. The string must be one of:\n"
17372  " b: Bottom of viewport, text written parallel to edge. \n"
17373  " bv: Bottom of viewport, text written at right angles to edge. \n"
17374  " l: Left of viewport, text written parallel to edge. \n"
17375  " lv: Left of viewport, text written at right angles to edge. \n"
17376  " r: Right of viewport, text written parallel to edge. \n"
17377  " rv: Right of viewport, text written at right angles to edge. \n"
17378  " t: Top of viewport, text written parallel to edge. \n"
17379  " tv: Top of viewport, text written at right angles to edge. \n"
17380  "\n"
17381  "\n"
17382  " disp (PLFLT, input) : Position of the reference point of string,\n"
17383  " measured outwards from the specified viewport edge in units of the\n"
17384  " current character height. Use negative disp to write within the\n"
17385  " viewport. \n"
17386  "\n"
17387  " pos (PLFLT, input) : Position of the reference point of string\n"
17388  " along the specified edge, expressed as a fraction of the length of\n"
17389  " the edge. \n"
17390  "\n"
17391  " just (PLFLT, input) : Specifies the position of the string relative\n"
17392  " to its reference point. If just=0., the reference point is at the\n"
17393  " left and if just=1., it is at the right of the string. Other\n"
17394  " values of just give intermediate justifications. \n"
17395  "\n"
17396  " text (const char *, input) : The string to be written out. \n"
17397  "\n"
17398  ""},
17399  { (char *)"plmtex3", _wrap_plmtex3, METH_VARARGS, (char *)"\n"
17400  "Write text relative to viewport boundaries in 3D plots. \n"
17401  "\n"
17402  "DESCRIPTION:\n"
17403  "\n"
17404  " Writes text at a specified position relative to the viewport\n"
17405  " boundaries. Text may be written inside or outside the viewport, but\n"
17406  " is clipped at the subpage boundaries. The reference point of a string\n"
17407  " lies along a line passing through the string at half the height of a\n"
17408  " capital letter. The position of the reference point along this line\n"
17409  " is determined by just, and the position of the reference point\n"
17410  " relative to the viewport is set by disp and pos. \n"
17411  "\n"
17412  " Redacted form: plmtex3(side, disp, pos, just, text)\n"
17413  "\n"
17414  " This function is used in example 28. \n"
17415  "\n"
17416  "\n"
17417  "\n"
17418  "SYNOPSIS:\n"
17419  "\n"
17420  "plmtex3(side, disp, pos, just, text)\n"
17421  "\n"
17422  "ARGUMENTS:\n"
17423  "\n"
17424  " side (const char *, input) : Specifies the side of the viewport\n"
17425  " along which the text is to be written. The string should contain\n"
17426  " one or more of the following characters: [xyz][ps][v]. Only one\n"
17427  " label is drawn at a time, i.e. xyp will only label the X axis, not\n"
17428  " both the X and Y axes. x: Label the X axis. \n"
17429  " y: Label the Y axis. \n"
17430  " z: Label the Z axis. \n"
17431  " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
17432  " For X it is the axis that starts at y-min. For Y it is the\n"
17433  " axis that starts at x-min. \n"
17434  " s: Label the secondary axis. \n"
17435  " v: Draw the text perpendicular to the axis. \n"
17436  "\n"
17437  "\n"
17438  " disp (PLFLT, input) : Position of the reference point of string,\n"
17439  " measured outwards from the specified viewport edge in units of the\n"
17440  " current character height. Use negative disp to write within the\n"
17441  " viewport. \n"
17442  "\n"
17443  " pos (PLFLT, input) : Position of the reference point of string\n"
17444  " along the specified edge, expressed as a fraction of the length of\n"
17445  " the edge. \n"
17446  "\n"
17447  " just (PLFLT, input) : Specifies the position of the string relative\n"
17448  " to its reference point. If just=0., the reference point is at the\n"
17449  " left and if just=1., it is at the right of the string. Other\n"
17450  " values of just give intermediate justifications. \n"
17451  "\n"
17452  " text (const char *, input) : The string to be written out. \n"
17453  "\n"
17454  ""},
17455  { (char *)"plot3d", _wrap_plot3d, METH_VARARGS, (char *)"\n"
17456  "Plot 3-d surface plot \n"
17457  "\n"
17458  "DESCRIPTION:\n"
17459  "\n"
17460  " Plots a three dimensional surface plot within the environment set up\n"
17461  " by plw3d. The surface is defined by the two-dimensional array z[\n"
17462  " nx][\n"
17463  " ny], the point z[i][j] being the value of the function at (\n"
17464  " x[i], \n"
17465  " y[j]). Note that the points in arrays x and y do not need to be\n"
17466  " equally spaced, but must be stored in ascending order. The parameter\n"
17467  " opt controls the way in which the surface is displayed. For further\n"
17468  " details see the PLplot documentation. The only difference between\n"
17469  " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
17470  " while plot3d only draws the surface as viewed from the top. \n"
17471  "\n"
17472  " Redacted form: plot3d(x, y, z, opt, side)\n"
17473  "\n"
17474  " This function is used in examples 11,21. \n"
17475  "\n"
17476  "\n"
17477  "\n"
17478  "SYNOPSIS:\n"
17479  "\n"
17480  "plot3d(x, y, z, nx, ny, opt, side)\n"
17481  "\n"
17482  "ARGUMENTS:\n"
17483  "\n"
17484  " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17485  " the function is evaluated. \n"
17486  "\n"
17487  " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17488  " the function is evaluated. \n"
17489  "\n"
17490  " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17491  " with set of function values. \n"
17492  "\n"
17493  " nx (PLINT, input) : Number of x values at which function is\n"
17494  " evaluated. \n"
17495  "\n"
17496  " ny (PLINT, input) : Number of y values at which function is\n"
17497  " evaluated. \n"
17498  "\n"
17499  " opt (PLINT, input) : Determines the way in which the surface is\n"
17500  " represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
17501  " function of x for each value of y[j]. \n"
17502  " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17503  " for each value of x[i]. \n"
17504  " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17505  " at which function is defined. \n"
17506  "\n"
17507  "\n"
17508  " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
17509  " should be draw on the figure. If side is true sides are drawn,\n"
17510  " otherwise no sides are drawn. \n"
17511  "\n"
17512  ""},
17513  { (char *)"plot3dc", _wrap_plot3dc, METH_VARARGS, (char *)"\n"
17514  "Magnitude colored plot surface with contour. \n"
17515  "\n"
17516  "DESCRIPTION:\n"
17517  "\n"
17518  " Identical to plot3d but with extra functionalities: the surface mesh\n"
17519  " can be colored accordingly to the current z value being plotted, a\n"
17520  " contour plot can be drawn at the base XY plane, and a curtain can be\n"
17521  " drawn between the plotted function border and the base XY plane. The\n"
17522  " arguments are identical to plmeshc. The only difference between\n"
17523  " plmeshc and plot3dc is that plmeshc draws the bottom side of the\n"
17524  " surface, while plot3dc only draws the surface as viewed from the top. \n"
17525  "\n"
17526  " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
17527  " Perl/PDL: Not available? \n"
17528  "\n"
17529  "\n"
17530  " This function is used in example 21. \n"
17531  "\n"
17532  "\n"
17533  "\n"
17534  "SYNOPSIS:\n"
17535  "\n"
17536  "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17537  "\n"
17538  ""},
17539  { (char *)"plot3dcl", _wrap_plot3dcl, METH_VARARGS, NULL},
17540  { (char *)"plsurf3d", _wrap_plsurf3d, METH_VARARGS, (char *)"\n"
17541  "Plot shaded 3-d surface plot \n"
17542  "\n"
17543  "DESCRIPTION:\n"
17544  "\n"
17545  " Plots a three dimensional shaded surface plot within the environment\n"
17546  " set up by plw3d. The surface is defined by the two-dimensional array\n"
17547  " z[\n"
17548  " nx][\n"
17549  " ny], the point z[i][j] being the value of the function at (\n"
17550  " x[i], \n"
17551  " y[j]). Note that the points in arrays x and y do not need to be\n"
17552  " equally spaced, but must be stored in ascending order. For further\n"
17553  " details see the PLplot documentation. \n"
17554  "\n"
17555  " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
17556  "\n"
17557  " This function is not used in any examples. \n"
17558  "\n"
17559  "\n"
17560  "\n"
17561  "SYNOPSIS:\n"
17562  "\n"
17563  "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17564  "\n"
17565  "ARGUMENTS:\n"
17566  "\n"
17567  " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17568  " the function is evaluated. \n"
17569  "\n"
17570  " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17571  " the function is evaluated. \n"
17572  "\n"
17573  " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17574  " with set of function values. \n"
17575  "\n"
17576  " nx (PLINT, input) : Number of x values at which function is\n"
17577  " evaluated. \n"
17578  "\n"
17579  " ny (PLINT, input) : Number of y values at which function is\n"
17580  " evaluated. \n"
17581  "\n"
17582  " opt (PLINT, input) : Determines the way in which the surface is\n"
17583  " represented. To specify more than one option just add the options,\n"
17584  " e.g. FACETED + SURF_CONT opt=FACETED: Network of lines is drawn\n"
17585  " connecting points at which function is defined. \n"
17586  " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
17587  " using parameters \n"
17588  " nlevel and \n"
17589  " clevel. \n"
17590  " opt=SURF_CONT: A contour plot is drawn at the surface plane\n"
17591  " using parameters \n"
17592  " nlevel and \n"
17593  " clevel. \n"
17594  " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
17595  " the borders of the plotted function. \n"
17596  " opt=MAG_COLOR: the surface is colored according to the value\n"
17597  " of Z; if MAG_COLOR is not used, then the default the surface\n"
17598  " is colored according to the intensity of the reflected light\n"
17599  " in the surface from a light source whose position is set using\n"
17600  " pllightsource. \n"
17601  "\n"
17602  "\n"
17603  " clevel (PLFLT *, input) : Pointer to the array that defines the\n"
17604  " contour level spacing. \n"
17605  "\n"
17606  " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
17607  "\n"
17608  ""},
17609  { (char *)"plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, NULL},
17610  { (char *)"plparseopts", _wrap_plparseopts, METH_VARARGS, (char *)"\n"
17611  "Parse command-line arguments \n"
17612  "\n"
17613  "DESCRIPTION:\n"
17614  "\n"
17615  " Parse command-line arguments. \n"
17616  "\n"
17617  " plparseopts removes all recognized flags (decreasing argc\n"
17618  " accordingly), so that invalid input may be readily detected. It can\n"
17619  " also be used to process user command line flags. The user can merge\n"
17620  " an option table of type PLOptionTable into the internal option table\n"
17621  " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
17622  " the external table(s) be parsed by calling plClearOpts before\n"
17623  " plMergeOpts. \n"
17624  "\n"
17625  " The default action taken by plparseopts is as follows: \n"
17626  " Returns with an error if an unrecognized option or badly formed\n"
17627  " option-value pair are encountered. \n"
17628  " Returns immediately (return code 0) when the first non-option command\n"
17629  " line argument is found. \n"
17630  " Returns with the return code of the option handler, if one was called.\n"
17631  " \n"
17632  " Deletes command line arguments from argv list as they are found, and\n"
17633  " decrements argc accordingly. \n"
17634  " Does not show \"invisible\" options in usage or help messages. \n"
17635  " Assumes the program name is contained in argv[0]. \n"
17636  "\n"
17637  " These behaviors may be controlled through the \n"
17638  " mode argument. \n"
17639  "\n"
17640  " Redacted form: General: plparseopts(argv, mode)\n"
17641  " Perl/PDL: Not available? \n"
17642  "\n"
17643  "\n"
17644  " This function is used in all of the examples. \n"
17645  "\n"
17646  "\n"
17647  "\n"
17648  "SYNOPSIS:\n"
17649  "\n"
17650  "int plparseopts(p_argc, argv, mode)\n"
17651  "\n"
17652  "ARGUMENTS:\n"
17653  "\n"
17654  " p_argc (int *, input) : pointer to number of arguments. \n"
17655  "\n"
17656  " argv (char **, input) : Pointer to character array containing\n"
17657  " *p_argc command-line arguments. \n"
17658  "\n"
17659  " mode (PLINT, input) : Parsing mode with the following\n"
17660  " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
17661  " and all error messages enabled, including program exit when an\n"
17662  " error occurs. Anything on the command line that isn't recognized\n"
17663  " as a valid option or option argument is flagged as an error. \n"
17664  " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
17665  " of errors. \n"
17666  " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
17667  " arguments. \n"
17668  " PL_PARSE_SHOWALL (8) -- Show invisible options \n"
17669  " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
17670  " pointer to the program name. \n"
17671  " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n"
17672  " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
17673  " unrecognized arguments. \n"
17674  "\n"
17675  ""},
17676  { (char *)"plpat", _wrap_plpat, METH_VARARGS, (char *)"\n"
17677  "Set area fill pattern \n"
17678  "\n"
17679  "DESCRIPTION:\n"
17680  "\n"
17681  " Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n"
17682  " parallel lines with specified inclinations and spacings. The\n"
17683  " arguments to this routine are the number of sets to use (1 or 2)\n"
17684  " followed by two pointers to integer arrays (of 1 or 2 elements)\n"
17685  " specifying the inclinations in tenths of a degree and the spacing in\n"
17686  " micrometers. (also see plpsty) \n"
17687  "\n"
17688  " Redacted form: General: plpat(inc, del)\n"
17689  " Perl/PDL: plpat(nlin, inc, del)\n"
17690  "\n"
17691  "\n"
17692  " This function is used in example 15. \n"
17693  "\n"
17694  "\n"
17695  "\n"
17696  "SYNOPSIS:\n"
17697  "\n"
17698  "plpat(nlin, inc, del)\n"
17699  "\n"
17700  "ARGUMENTS:\n"
17701  "\n"
17702  " nlin (PLINT, input) : Number of sets of lines making up the\n"
17703  " pattern, either 1 or 2. \n"
17704  "\n"
17705  " inc (PLINT *, input) : Pointer to array with nlin elements.\n"
17706  " Specifies the line inclination in tenths of a degree. (Should be\n"
17707  " between -900 and 900). \n"
17708  "\n"
17709  " del (PLINT *, input) : Pointer to array with nlin elements.\n"
17710  " Specifies the spacing in micrometers between the lines making up\n"
17711  " the pattern. \n"
17712  "\n"
17713  ""},
17714  { (char *)"plpoin", _wrap_plpoin, METH_VARARGS, (char *)"\n"
17715  "Plot a glyph at the specified points \n"
17716  "\n"
17717  "DESCRIPTION:\n"
17718  "\n"
17719  " Plot a glyph at the specified points. (This function is largely\n"
17720  " superseded by plstring which gives access to many[!] more glyphs.)\n"
17721  " code=-1 means try to just draw a point. Right now it's just a move\n"
17722  " and a draw at the same place. Not ideal, since a sufficiently\n"
17723  " intelligent output device may optimize it away, or there may be faster\n"
17724  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
17725  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
17726  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
17727  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
17728  " code <= 127 the corresponding printable ASCII character is plotted. \n"
17729  "\n"
17730  " Redacted form: plpoin(x, y, code)\n"
17731  "\n"
17732  " This function is used in examples 1,6,14,29. \n"
17733  "\n"
17734  "\n"
17735  "\n"
17736  "SYNOPSIS:\n"
17737  "\n"
17738  "plpoin(n, x, y, code)\n"
17739  "\n"
17740  "ARGUMENTS:\n"
17741  "\n"
17742  " n (PLINT, input) : Number of points in the x and y arrays. \n"
17743  "\n"
17744  " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
17745  " points. \n"
17746  "\n"
17747  " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
17748  " points. \n"
17749  "\n"
17750  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
17751  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
17752  " each of the n points. \n"
17753  "\n"
17754  ""},
17755  { (char *)"plpoin3", _wrap_plpoin3, METH_VARARGS, (char *)"\n"
17756  "Plot a glyph at the specified 3D points \n"
17757  "\n"
17758  "DESCRIPTION:\n"
17759  "\n"
17760  " Plot a glyph at the specified 3D points. (This function is largely\n"
17761  " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
17762  " Set up the call to this function similar to what is done for plline3.\n"
17763  " code=-1 means try to just draw a point. Right now it's just a move\n"
17764  " and a draw at the same place. Not ideal, since a sufficiently\n"
17765  " intelligent output device may optimize it away, or there may be faster\n"
17766  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
17767  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
17768  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
17769  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
17770  " code <= 127 the corresponding printable ASCII character is plotted. \n"
17771  "\n"
17772  " Redacted form: plpoin3(x, y, z, code)\n"
17773  "\n"
17774  " This function is not used in any example. \n"
17775  "\n"
17776  "\n"
17777  "\n"
17778  "SYNOPSIS:\n"
17779  "\n"
17780  "plpoin3(n, x, y, z, code)\n"
17781  "\n"
17782  "ARGUMENTS:\n"
17783  "\n"
17784  " n (PLINT, input) : Number of points in the x and y arrays. \n"
17785  "\n"
17786  " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
17787  " points. \n"
17788  "\n"
17789  " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
17790  " points. \n"
17791  "\n"
17792  " z (PLFLT *, input) : Pointer to an array with Z coordinates of\n"
17793  " points. \n"
17794  "\n"
17795  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
17796  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
17797  " each of the n points. \n"
17798  "\n"
17799  ""},
17800  { (char *)"plpoly3", _wrap_plpoly3, METH_VARARGS, (char *)"\n"
17801  "Draw a polygon in 3 space \n"
17802  "\n"
17803  "DESCRIPTION:\n"
17804  "\n"
17805  " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
17806  " like plline3, but differs from that function in that plpoly3 attempts\n"
17807  " to determine if the polygon is viewable depending on the order of the\n"
17808  " points within the arrays and the value of ifcc. If the back of\n"
17809  " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
17810  " you want, then use plline3 instead. \n"
17811  "\n"
17812  " The points are assumed to be in a plane, and the directionality of the\n"
17813  " plane is determined from the first three points. Additional points do\n"
17814  " not have to lie on the plane defined by the first three, but if they\n"
17815  " do not, then the determination of visibility obviously can't be 100%\n"
17816  " accurate... So if you're 3 space polygons are too far from planar,\n"
17817  " consider breaking them into smaller polygons. 3 points define a plane\n"
17818  " :-). \n"
17819  "\n"
17820  " Bugs: If one of the first two segments is of zero length, or if they\n"
17821  " are co-linear, the calculation of visibility has a 50/50 chance of\n"
17822  " being correct. Avoid such situations :-). See x18c.c for an example\n"
17823  " of this problem. (Search for 20.1). \n"
17824  "\n"
17825  " Redacted form: plpoly3(x, y, z, code)\n"
17826  "\n"
17827  " This function is used in example 18. \n"
17828  "\n"
17829  "\n"
17830  "\n"
17831  "SYNOPSIS:\n"
17832  "\n"
17833  "plpoly3(n, x, y, z, draw, ifcc)\n"
17834  "\n"
17835  "ARGUMENTS:\n"
17836  "\n"
17837  " n (PLINT, input) : Number of points defining line. \n"
17838  "\n"
17839  " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
17840  "\n"
17841  " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
17842  "\n"
17843  " z (PLFLT *, input) : Pointer to array with z coordinates of points. \n"
17844  "\n"
17845  " draw (PLBOOL *, input) : Pointer to array which controls drawing\n"
17846  " the segments of the polygon. If draw[i] is true, then the polygon\n"
17847  " segment from index [i] to [i+1] is drawn, otherwise, not. \n"
17848  "\n"
17849  " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
17850  " polygon is determined by assuming the points are laid out in a\n"
17851  " counter-clockwise order. Otherwise, the directionality of the\n"
17852  " polygon is determined by assuming the points are laid out in a\n"
17853  " clockwise order. \n"
17854  "\n"
17855  ""},
17856  { (char *)"plprec", _wrap_plprec, METH_VARARGS, (char *)"\n"
17857  "Set precision in numeric labels \n"
17858  "\n"
17859  "DESCRIPTION:\n"
17860  "\n"
17861  " Sets the number of places after the decimal point in numeric labels. \n"
17862  "\n"
17863  " Redacted form: plprec(set, prec)\n"
17864  "\n"
17865  " This function is used in example 29. \n"
17866  "\n"
17867  "\n"
17868  "\n"
17869  "SYNOPSIS:\n"
17870  "\n"
17871  "plprec(set, prec)\n"
17872  "\n"
17873  "ARGUMENTS:\n"
17874  "\n"
17875  " set (PLINT, input) : If set is equal to 0 then PLplot automatically\n"
17876  " determines the number of places to use after the decimal point in\n"
17877  " numeric labels (like those used to label axes). If set is 1 then\n"
17878  " prec sets the number of places. \n"
17879  "\n"
17880  " prec (PLINT, input) : The number of characters to draw after the\n"
17881  " decimal point in numeric labels. \n"
17882  "\n"
17883  ""},
17884  { (char *)"plpsty", _wrap_plpsty, METH_VARARGS, (char *)"\n"
17885  "Select area fill pattern \n"
17886  "\n"
17887  "DESCRIPTION:\n"
17888  "\n"
17889  " Select one of eight predefined area fill patterns to use (also see\n"
17890  " plpat). Setting the fill style to 0 gives a solid fill. \n"
17891  "\n"
17892  " Redacted form: plpsty(n)\n"
17893  "\n"
17894  " This function is used in examples 12,13,15,16,25. \n"
17895  "\n"
17896  "\n"
17897  "\n"
17898  "SYNOPSIS:\n"
17899  "\n"
17900  "plpsty(n)\n"
17901  "\n"
17902  "ARGUMENTS:\n"
17903  "\n"
17904  " n (PLINT, input) : The desired pattern. Pattern 1 consists of\n"
17905  " horizontal lines, pattern 2 consists of vertical lines, pattern 3\n"
17906  " consists of lines at 45 degrees angle (upward), and so on. \n"
17907  "\n"
17908  ""},
17909  { (char *)"plptex", _wrap_plptex, METH_VARARGS, (char *)"\n"
17910  "Write text inside the viewport \n"
17911  "\n"
17912  "DESCRIPTION:\n"
17913  "\n"
17914  " Writes text at a specified position and inclination within the\n"
17915  " viewport. Text is clipped at the viewport boundaries. The reference\n"
17916  " point of a string lies along a line passing through the string at half\n"
17917  " the height of a capital letter. The position of the reference point\n"
17918  " along this line is determined by just, the reference point is placed\n"
17919  " at world coordinates (\n"
17920  " x, \n"
17921  " y) within the viewport. The inclination of the string is specified in\n"
17922  " terms of differences of world coordinates making it easy to write text\n"
17923  " parallel to a line in a graph. \n"
17924  "\n"
17925  " Redacted form: plptex(x, y, dx, dy, just, text)\n"
17926  "\n"
17927  " This function is used in example 2-4,10,12-14,20,23,24,26. \n"
17928  "\n"
17929  "\n"
17930  "\n"
17931  "SYNOPSIS:\n"
17932  "\n"
17933  "plptex(x, y, dx, dy, just, text)\n"
17934  "\n"
17935  "ARGUMENTS:\n"
17936  "\n"
17937  " x (PLFLT, input) : x coordinate of reference point of string. \n"
17938  "\n"
17939  " y (PLFLT, input) : y coordinate of reference point of string. \n"
17940  "\n"
17941  " dx (PLFLT, input) : Together with dy, this specifies the\n"
17942  " inclination of the string. The baseline of the string is parallel\n"
17943  " to a line joining (\n"
17944  " x, \n"
17945  " y) to (\n"
17946  " x+\n"
17947  " dx, \n"
17948  " y+\n"
17949  " dy). \n"
17950  "\n"
17951  " dy (PLFLT, input) : Together with dx, this specifies the\n"
17952  " inclination of the string. \n"
17953  "\n"
17954  " just (PLFLT, input) : Specifies the position of the string relative\n"
17955  " to its reference point. If just=0., the reference point is at the\n"
17956  " left and if just=1., it is at the right of the string. Other\n"
17957  " values of just give intermediate justifications. \n"
17958  "\n"
17959  " text (const char *, input) : The string to be written out. \n"
17960  "\n"
17961  ""},
17962  { (char *)"plptex3", _wrap_plptex3, METH_VARARGS, (char *)"\n"
17963  "Write text inside the viewport of a 3D plot. \n"
17964  "\n"
17965  "DESCRIPTION:\n"
17966  "\n"
17967  " Writes text at a specified position and inclination and with a\n"
17968  " specified shear within the viewport. Text is clipped at the viewport\n"
17969  " boundaries. The reference point of a string lies along a line passing\n"
17970  " through the string at half the height of a capital letter. The\n"
17971  " position of the reference point along this line is determined by just,\n"
17972  " and the reference point is placed at world coordinates (\n"
17973  " x, \n"
17974  " y, \n"
17975  " z) within the viewport. The inclination and shear of the string is\n"
17976  " specified in terms of differences of world coordinates making it easy\n"
17977  " to write text parallel to a line in a graph. \n"
17978  "\n"
17979  " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
17980  "\n"
17981  " This function is used in example 28. \n"
17982  "\n"
17983  "\n"
17984  "\n"
17985  "SYNOPSIS:\n"
17986  "\n"
17987  "plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
17988  "\n"
17989  "ARGUMENTS:\n"
17990  "\n"
17991  " x (PLFLT, input) : x coordinate of reference point of string. \n"
17992  "\n"
17993  " y (PLFLT, input) : y coordinate of reference point of string. \n"
17994  "\n"
17995  " z (PLFLT, input) : z coordinate of reference point of string. \n"
17996  "\n"
17997  " dx (PLFLT, input) : Together with dy and \n"
17998  " dz, this specifies the inclination of the string. The baseline of\n"
17999  " the string is parallel to a line joining (\n"
18000  " x, \n"
18001  " y, \n"
18002  " z) to (\n"
18003  " x+\n"
18004  " dx, \n"
18005  " y+\n"
18006  " dy, \n"
18007  " z+\n"
18008  " dz). \n"
18009  "\n"
18010  " dy (PLFLT, input) : Together with dx and \n"
18011  " dz, this specifies the inclination of the string. \n"
18012  "\n"
18013  " dz (PLFLT, input) : Together with dx and \n"
18014  " dy, this specifies the inclination of the string. \n"
18015  "\n"
18016  " sx (PLFLT, input) : Together with sy and \n"
18017  " sz, this specifies the shear of the string. The string is sheared so\n"
18018  " that the characters are vertically parallel to a line joining (\n"
18019  " x, \n"
18020  " y, \n"
18021  " z) to (\n"
18022  " x+\n"
18023  " sx, \n"
18024  " y+\n"
18025  " sy, \n"
18026  " z+\n"
18027  " sz). If sx = \n"
18028  " sy = \n"
18029  " sz = 0.) then the text is not sheared. \n"
18030  "\n"
18031  " sy (PLFLT, input) : Together with sx and \n"
18032  " sz, this specifies shear of the string. \n"
18033  "\n"
18034  " sz (PLFLT, input) : Together with sx and \n"
18035  " sy, this specifies shear of the string. \n"
18036  "\n"
18037  " just (PLFLT, input) : Specifies the position of the string relative\n"
18038  " to its reference point. If just=0., the reference point is at the\n"
18039  " left and if just=1., it is at the right of the string. Other\n"
18040  " values of just give intermediate justifications. \n"
18041  "\n"
18042  " text (const char *, input) : The string to be written out. \n"
18043  "\n"
18044  ""},
18045  { (char *)"plrandd", _wrap_plrandd, METH_VARARGS, (char *)"\n"
18046  "Random number generator returning a real random number in the range [0,1]. \n"
18047  "\n"
18048  "DESCRIPTION:\n"
18049  "\n"
18050  " Random number generator returning a real random number in the range\n"
18051  " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
18052  " / compilers provide their own random number generator, and so this is\n"
18053  " provided purely for convenience and to give a consistent random number\n"
18054  " generator across all languages supported by PLplot. This is\n"
18055  " particularly useful for comparing results from the test suite of\n"
18056  " examples. \n"
18057  "\n"
18058  " Redacted form: plrandd()\n"
18059  "\n"
18060  " This function is used in examples 17,21. \n"
18061  "\n"
18062  "\n"
18063  "\n"
18064  "SYNOPSIS:\n"
18065  "\n"
18066  "plrandd()\n"
18067  "\n"
18068  ""},
18069  { (char *)"plreplot", _wrap_plreplot, METH_VARARGS, (char *)"\n"
18070  "Replays contents of plot buffer to current device/file \n"
18071  "\n"
18072  "DESCRIPTION:\n"
18073  "\n"
18074  " Replays contents of plot buffer to current device/file. \n"
18075  "\n"
18076  " Redacted form: plreplot()\n"
18077  "\n"
18078  " This function is used in example 1,20. \n"
18079  "\n"
18080  "\n"
18081  "\n"
18082  "SYNOPSIS:\n"
18083  "\n"
18084  "plreplot()\n"
18085  "\n"
18086  ""},
18087  { (char *)"plrgbhls", _wrap_plrgbhls, METH_VARARGS, (char *)"\n"
18088  "Convert RGB color to HLS \n"
18089  "\n"
18090  "DESCRIPTION:\n"
18091  "\n"
18092  " Convert RGB color coordinates to HLS \n"
18093  "\n"
18094  " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18095  " Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n"
18096  "\n"
18097  "\n"
18098  " This function is used in example 2. \n"
18099  "\n"
18100  "\n"
18101  "\n"
18102  "SYNOPSIS:\n"
18103  "\n"
18104  "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18105  "\n"
18106  "ARGUMENTS:\n"
18107  "\n"
18108  " r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n"
18109  "\n"
18110  " g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n"
18111  "\n"
18112  " b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n"
18113  "\n"
18114  " p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n"
18115  " cone (0.0-360.0) \n"
18116  "\n"
18117  " p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n"
18118  " fraction of the axis of the colour cone (0.0-1.0) \n"
18119  "\n"
18120  " p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n"
18121  " fraction of the radius of the colour cone (0.0-1.0) \n"
18122  "\n"
18123  ""},
18124  { (char *)"plschr", _wrap_plschr, METH_VARARGS, (char *)"\n"
18125  "Set character size \n"
18126  "\n"
18127  "DESCRIPTION:\n"
18128  "\n"
18129  " This sets up the size of all subsequent characters drawn. The actual\n"
18130  " height of a character is the product of the default character size and\n"
18131  " a scaling factor. \n"
18132  "\n"
18133  " Redacted form: plschr(def, scale)\n"
18134  "\n"
18135  " This function is used in example 2,13,23,24. \n"
18136  "\n"
18137  "\n"
18138  "\n"
18139  "SYNOPSIS:\n"
18140  "\n"
18141  "plschr(def, scale)\n"
18142  "\n"
18143  "ARGUMENTS:\n"
18144  "\n"
18145  " def (PLFLT, input) : The default height of a character in\n"
18146  " millimeters, should be set to zero if the default height is to\n"
18147  " remain unchanged. \n"
18148  "\n"
18149  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
18150  " actual character height. \n"
18151  "\n"
18152  ""},
18153  { (char *)"plscmap0", _wrap_plscmap0, METH_VARARGS, (char *)"\n"
18154  "Set color map0 colors by 8-bit RGB values \n"
18155  "\n"
18156  "DESCRIPTION:\n"
18157  "\n"
18158  " Set color map0 colors using 8-bit RGB values (see the PLplot\n"
18159  " documentation). This sets the entire color map -- only as many colors\n"
18160  " as specified will be allocated. \n"
18161  "\n"
18162  " Redacted form: plscmap0(r, g, b, ncol0)\n"
18163  "\n"
18164  " This function is used in examples 2,24. \n"
18165  "\n"
18166  "\n"
18167  "\n"
18168  "SYNOPSIS:\n"
18169  "\n"
18170  "plscmap0(r, g, b, ncol0)\n"
18171  "\n"
18172  "ARGUMENTS:\n"
18173  "\n"
18174  " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18175  " integers (0-255) representing the degree of red in the color. \n"
18176  "\n"
18177  " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18178  " integers (0-255) representing the degree of green in the color. \n"
18179  "\n"
18180  " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18181  " integers (0-255) representing the degree of blue in the color. \n"
18182  "\n"
18183  " ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
18184  "\n"
18185  ""},
18186  { (char *)"plscmap0a", _wrap_plscmap0a, METH_VARARGS, (char *)"\n"
18187  "Set color map0 colors by 8-bit RGB values and double alpha value. \n"
18188  "\n"
18189  "DESCRIPTION:\n"
18190  "\n"
18191  " Set color map0 colors using 8-bit RGB values (see the PLplot\n"
18192  " documentation) and floating point alpha value. This sets the entire\n"
18193  " color map -- only as many colors as specified will be allocated. \n"
18194  "\n"
18195  " This function is used in examples 30. \n"
18196  "\n"
18197  "\n"
18198  "\n"
18199  "SYNOPSIS:\n"
18200  "\n"
18201  "plscmap0a(r, g, b, a, ncol0)\n"
18202  "\n"
18203  "ARGUMENTS:\n"
18204  "\n"
18205  " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18206  " integers (0-255) representing the degree of red in the color. \n"
18207  "\n"
18208  " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18209  " integers (0-255) representing the degree of green in the color. \n"
18210  "\n"
18211  " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18212  " integers (0-255) representing the degree of blue in the color. \n"
18213  "\n"
18214  " a (PLFLT *, input) : Pointer to array with set of PLFLT values (0.0\n"
18215  " - 1.0) representing the transparency of the color. \n"
18216  "\n"
18217  " ncol0 (PLINT, input) : Number of items in the r, g, b, and a\n"
18218  " arrays. \n"
18219  "\n"
18220  ""},
18221  { (char *)"plscmap0n", _wrap_plscmap0n, METH_VARARGS, (char *)"\n"
18222  "Set number of colors in color map0 \n"
18223  "\n"
18224  "DESCRIPTION:\n"
18225  "\n"
18226  " Set number of colors in color map0 (see the PLplot documentation).\n"
18227  " Allocate (or reallocate) color map0, and fill with default values for\n"
18228  " those colors not previously allocated. The first 16 default colors are\n"
18229  " given in the plcol0 documentation. For larger indices the default\n"
18230  " color is red. \n"
18231  "\n"
18232  " The drivers are not guaranteed to support more than 16 colors. \n"
18233  "\n"
18234  " Redacted form: plscmap0n(ncol0)\n"
18235  "\n"
18236  " This function is used in examples 15,16,24. \n"
18237  "\n"
18238  "\n"
18239  "\n"
18240  "SYNOPSIS:\n"
18241  "\n"
18242  "plscmap0n(ncol0)\n"
18243  "\n"
18244  "ARGUMENTS:\n"
18245  "\n"
18246  " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
18247  " the map0 palette. If this number is zero or less, then the value\n"
18248  " from the previous call to plscmap0n is used and if there is no\n"
18249  " previous call, then a default value is used. \n"
18250  "\n"
18251  ""},
18252  { (char *)"plscmap1", _wrap_plscmap1, METH_VARARGS, (char *)"\n"
18253  "Set color map1 colors using 8-bit RGB values \n"
18254  "\n"
18255  "DESCRIPTION:\n"
18256  "\n"
18257  " Set color map1 colors using 8-bit RGB values (see the PLplot\n"
18258  " documentation). This also sets the number of colors. \n"
18259  "\n"
18260  " Redacted form: plscmap1(r, g, b, ncol1)\n"
18261  "\n"
18262  " This function is used in example 31. \n"
18263  "\n"
18264  "\n"
18265  "\n"
18266  "SYNOPSIS:\n"
18267  "\n"
18268  "plscmap1(r, g, b, ncol1)\n"
18269  "\n"
18270  "ARGUMENTS:\n"
18271  "\n"
18272  " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18273  " integers (0-255) representing the degree of red in the color. \n"
18274  "\n"
18275  " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18276  " integers (0-255) representing the degree of green in the color. \n"
18277  "\n"
18278  " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18279  " integers (0-255) representing the degree of blue in the color. \n"
18280  "\n"
18281  " ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
18282  "\n"
18283  ""},
18284  { (char *)"plscmap1a", _wrap_plscmap1a, METH_VARARGS, (char *)"\n"
18285  "Set color map1 colors using 8-bit RGB values and double alpha values. \n"
18286  "\n"
18287  "DESCRIPTION:\n"
18288  "\n"
18289  " Set color map1 colors using 8-bit RGB values (see the PLplot\n"
18290  " documentation) and double alpha values. This also sets the number of\n"
18291  " colors.\n"
18292  "\n"
18293  " This function is used in example 31. \n"
18294  "\n"
18295  "\n"
18296  "\n"
18297  "SYNOPSIS:\n"
18298  "\n"
18299  "plscmap1a(r, g, b, a, ncol1)\n"
18300  "\n"
18301  "ARGUMENTS:\n"
18302  "\n"
18303  " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18304  " integers (0-255) representing the degree of red in the color. \n"
18305  "\n"
18306  " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18307  " integers (0-255) representing the degree of green in the color. \n"
18308  "\n"
18309  " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18310  " integers (0-255) representing the degree of blue in the color. \n"
18311  "\n"
18312  " a (PLFLT *, input) : Pointer to array with set of double values\n"
18313  " (0.0-1.0) representing the alpha value of the color. \n"
18314  "\n"
18315  " ncol1 (PLINT, input) : Number of items in the r, g, b, and a\n"
18316  " arrays. \n"
18317  "\n"
18318  ""},
18319  { (char *)"plscmap1l", _wrap_plscmap1l, METH_VARARGS, (char *)"\n"
18320  "Set color map1 colors using a piece-wise linear relationship \n"
18321  "\n"
18322  "DESCRIPTION:\n"
18323  "\n"
18324  " Set color map1 colors using a piece-wise linear relationship between\n"
18325  " position in the color map (from 0 to 1) and position in HLS or RGB\n"
18326  " color space (see the PLplot documentation). May be called at any\n"
18327  " time. \n"
18328  "\n"
18329  " The idea here is to specify a number of control points that define the\n"
18330  " mapping between palette 1 input positions (intensities) and HLS (or\n"
18331  " RGB). Between these points, linear interpolation is used which gives\n"
18332  " a smooth variation of color with input position. Any number of\n"
18333  " control points may be specified, located at arbitrary positions,\n"
18334  " although typically 2 - 4 are enough. Another way of stating this is\n"
18335  " that we are traversing a given number of lines through HLS (or RGB)\n"
18336  " space as we move through color map1 entries. The control points at\n"
18337  " the minimum and maximum position (0 and 1) must always be specified. \n"
18338  " By adding more control points you can get more variation. One good\n"
18339  " technique for plotting functions that vary about some expected average\n"
18340  " is to use an additional 2 control points in the center (position ~=\n"
18341  " 0.5) that are the same lightness as the background (typically white\n"
18342  " for paper output, black for crt), and same hue as the boundary control\n"
18343  " points. This allows the highs and lows to be very easily\n"
18344  " distinguished. \n"
18345  "\n"
18346  " Each control point must specify the position in color map1 as well as\n"
18347  " three coordinates in HLS or RGB space. The first point must\n"
18348  " correspond to position = 0, and the last to position = 1. \n"
18349  "\n"
18350  " The default behaviour is for the hue to be linearly interpolated \n"
18351  " between the control points. Since the hue lies in the range [0, 360]\n"
18352  " this corresponds to interpolation around the \"front\" of the color\n"
18353  " wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n"
18354  " alternative interpolation is used between control points i and i+1. If\n"
18355  " hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and\n"
18356  " hue[i+1] - 360, otherwise between hue[i] and hue[i+1] + 360. You can\n"
18357  " consider this as interpolation around the \"back\" or \"reverse\" of the\n"
18358  " color wheel. Specifying alt_hue_path=NULL is equivalent to setting\n"
18359  " alt_hue_path[] = false for every control point. \n"
18360  "\n"
18361  " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
18362  " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
18363  " 240]truegreen-yellow-red-magenta-blue[240\n"
18364  " 120]trueblue-magenta-red-yellow-green\n"
18365  "\n"
18366  " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
18367  " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
18368  " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
18369  "\n"
18370  " Redacted form: plscmap1l(itype, pos, coord1, coord2, coord3,\n"
18371  " alt_hue_path)\n"
18372  "\n"
18373  " This function is used in examples 8,11,12,15,20,21. \n"
18374  "\n"
18375  "\n"
18376  "\n"
18377  "SYNOPSIS:\n"
18378  "\n"
18379  "plscmap1l(itype, npts, pos, coord1, coord2, coord3, alt_hue_path)\n"
18380  "\n"
18381  "ARGUMENTS:\n"
18382  "\n"
18383  " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
18384  "\n"
18385  " npts (PLINT, input) : number of control points \n"
18386  "\n"
18387  " pos (PLFLT *, input) : position for each control point (between 0.0\n"
18388  " and 1.0, in ascending order) \n"
18389  "\n"
18390  " coord1 (PLFLT *, input) : first coordinate (H or R) for each\n"
18391  " control point \n"
18392  "\n"
18393  " coord2 (PLFLT *, input) : second coordinate (L or G) for each\n"
18394  " control point \n"
18395  "\n"
18396  " coord3 (PLFLT *, input) : third coordinate (S or B) for each\n"
18397  " control point \n"
18398  "\n"
18399  " alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n"
18400  " flag for each control point. (alt_hue_path[i] refers to the\n"
18401  " interpolation interval between the i and i + 1 control points). \n"
18402  "\n"
18403  ""},
18404  { (char *)"plscmap1la", _wrap_plscmap1la, METH_VARARGS, (char *)"\n"
18405  "Set color map1 colors using a piece-wise linear relationship \n"
18406  "\n"
18407  "DESCRIPTION:\n"
18408  "\n"
18409  " This is a version of plscmap1l that supports alpha transparency. It\n"
18410  " sets color map1 colors using a piece-wise linear relationship between\n"
18411  " position in the color map (from 0 to 1) and position in HLS or RGB\n"
18412  " color space (see the PLplot documentation) with alpha value (0.0 -\n"
18413  " 1.0). It may be called at any time. \n"
18414  "\n"
18415  " This function is used in example 30. \n"
18416  "\n"
18417  "\n"
18418  "\n"
18419  "SYNOPSIS:\n"
18420  "\n"
18421  "plscmap1la(itype, npts, pos, coord1, coord2, coord3, coord4, alt_hue_path)\n"
18422  "\n"
18423  "ARGUMENTS:\n"
18424  "\n"
18425  " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
18426  "\n"
18427  " npts (PLINT, input) : number of control points \n"
18428  "\n"
18429  " pos (PLFLT *, input) : position for each control point (between 0.0\n"
18430  " and 1.0, in ascending order) \n"
18431  "\n"
18432  " coord1 (PLFLT *, input) : first coordinate (H or R) for each\n"
18433  " control point \n"
18434  "\n"
18435  " coord2 (PLFLT *, input) : second coordinate (L or G) for each\n"
18436  " control point \n"
18437  "\n"
18438  " coord3 (PLFLT *, input) : third coordinate (S or B) for each\n"
18439  " control point \n"
18440  "\n"
18441  " coord4 (PLFLT *, input) : fourth coordinate, the alpha value for\n"
18442  " each control point \n"
18443  "\n"
18444  " alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n"
18445  " flag for each control point. (alt_hue_path[i] refers to the\n"
18446  " interpolation interval between the i and i + 1 control points). \n"
18447  "\n"
18448  ""},
18449  { (char *)"plscmap1n", _wrap_plscmap1n, METH_VARARGS, (char *)"\n"
18450  "Set number of colors in color map1 \n"
18451  "\n"
18452  "DESCRIPTION:\n"
18453  "\n"
18454  " Set number of colors in color map1, (re-)allocate color map1, and set\n"
18455  " default values if this is the first allocation (see the PLplot\n"
18456  " documentation). \n"
18457  "\n"
18458  " Redacted form: plscmap1n(ncol1)\n"
18459  "\n"
18460  " This function is used in examples 8,11,20,21. \n"
18461  "\n"
18462  "\n"
18463  "\n"
18464  "SYNOPSIS:\n"
18465  "\n"
18466  "plscmap1n(ncol1)\n"
18467  "\n"
18468  "ARGUMENTS:\n"
18469  "\n"
18470  " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
18471  " the map1 palette. If this number is zero or less, then the value\n"
18472  " from the previous call to plscmap1n is used and if there is no\n"
18473  " previous call, then a default value is used. \n"
18474  "\n"
18475  ""},
18476  { (char *)"plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, NULL},
18477  { (char *)"plgcmap1_range", _wrap_plgcmap1_range, METH_VARARGS, NULL},
18478  { (char *)"plscol0", _wrap_plscol0, METH_VARARGS, (char *)"\n"
18479  "Set a given color from color map0 by 8 bit RGB value \n"
18480  "\n"
18481  "ESCRIPTION:\n"
18482  "\n"
18483  " Set a given color by 8-bit RGB value for color map0 (see the PLplot\n"
18484  " documentation). Overwrites the previous color value for the given\n"
18485  " index and, thus, does not result in any additional allocation of space\n"
18486  " for colors. \n"
18487  "\n"
18488  " Redacted form: plscol0(icol0, r, g, b)\n"
18489  "\n"
18490  " This function is not used in any examples. \n"
18491  "\n"
18492  "\n"
18493  "\n"
18494  "YNOPSIS:\n"
18495  "\n"
18496  "lscol0(icol0, r, g, b)\n"
18497  "\n"
18498  "RGUMENTS:\n"
18499  "\n"
18500  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
18501  " number of colors (which is set by default, by plscmap0n, or even\n"
18502  " by plscmap0). \n"
18503  "\n"
18504  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18505  " degree of red in the color. \n"
18506  "\n"
18507  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18508  " degree of green in the color. \n"
18509  "\n"
18510  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18511  " degree of blue in the color. \n"
18512  "\n"
18513  ""},
18514  { (char *)"plscol0a", _wrap_plscol0a, METH_VARARGS, (char *)"\n"
18515  "Set a given color from color map0 by 8 bit RGB value and double alpha value. \n"
18516  "\n"
18517  "ESCRIPTION:\n"
18518  "\n"
18519  " Set a given color by 8-bit RGB value and double alpha value for color \n"
18520  " map0 (see the PLplot documentation). Overwrites the previous color\n"
18521  " value for the given index and, thus, does not result in any\n"
18522  " additional allocation of space for colors. \n"
18523  "\n"
18524  " This function is used in example 30. \n"
18525  "\n"
18526  "\n"
18527  "\n"
18528  "YNOPSIS:\n"
18529  "\n"
18530  "lscol0a(icol0, r, g, b, a)\n"
18531  "\n"
18532  "RGUMENTS:\n"
18533  "\n"
18534  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
18535  " number of colors (which is set by default, by plscmap0n, or even\n"
18536  " by plscmap0). \n"
18537  "\n"
18538  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18539  " degree of red in the color. \n"
18540  "\n"
18541  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18542  " degree of green in the color. \n"
18543  "\n"
18544  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18545  " degree of blue in the color. \n"
18546  "\n"
18547  " a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n"
18548  " value of the color. \n"
18549  "\n"
18550  ""},
18551  { (char *)"plscolbg", _wrap_plscolbg, METH_VARARGS, (char *)"\n"
18552  "Set the background color by 8-bit RGB value \n"
18553  "\n"
18554  "DESCRIPTION:\n"
18555  "\n"
18556  " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
18557  " (see the PLplot documentation). \n"
18558  "\n"
18559  " Redacted form: plscolbg(r, g, b)\n"
18560  "\n"
18561  " This function is used in examples 15,31. \n"
18562  "\n"
18563  "\n"
18564  "\n"
18565  "SYNOPSIS:\n"
18566  "\n"
18567  "plscolbg(r, g, b)\n"
18568  "\n"
18569  "ARGUMENTS:\n"
18570  "\n"
18571  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18572  " degree of red in the color. \n"
18573  "\n"
18574  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18575  " degree of green in the color. \n"
18576  "\n"
18577  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18578  " degree of blue in the color. \n"
18579  "\n"
18580  ""},
18581  { (char *)"plscolbga", _wrap_plscolbga, METH_VARARGS, (char *)"\n"
18582  "Set the background color by 8-bit RGB value and double alpha value. \n"
18583  "\n"
18584  "DESCRIPTION:\n"
18585  "\n"
18586  " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
18587  " (see the PLplot documentation) and double alpha value. \n"
18588  "\n"
18589  " This function is used in example 31. \n"
18590  "\n"
18591  "\n"
18592  "\n"
18593  "SYNOPSIS:\n"
18594  "\n"
18595  "plscolbga(r, g, b, a)\n"
18596  "\n"
18597  "ARGUMENTS:\n"
18598  "\n"
18599  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18600  " degree of red in the color. \n"
18601  "\n"
18602  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18603  " degree of green in the color. \n"
18604  "\n"
18605  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18606  " degree of blue in the color. \n"
18607  "\n"
18608  " a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n"
18609  " value of the color. \n"
18610  "\n"
18611  ""},
18612  { (char *)"plscolor", _wrap_plscolor, METH_VARARGS, (char *)"\n"
18613  "Used to globally turn color output on/off \n"
18614  "\n"
18615  "DESCRIPTION:\n"
18616  "\n"
18617  " Used to globally turn color output on/off for those drivers/devices\n"
18618  " that support it. \n"
18619  "\n"
18620  " Redacted form: plscolor(color)\n"
18621  "\n"
18622  " This function is used in example 31. \n"
18623  "\n"
18624  "\n"
18625  "\n"
18626  "SYNOPSIS:\n"
18627  "\n"
18628  "plscolor(color)\n"
18629  "\n"
18630  "ARGUMENTS:\n"
18631  "\n"
18632  " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
18633  " turned off. If non-zero, color is turned on. \n"
18634  "\n"
18635  ""},
18636  { (char *)"plscompression", _wrap_plscompression, METH_VARARGS, (char *)"\n"
18637  "Set device-compression level \n"
18638  "\n"
18639  "DESCRIPTION:\n"
18640  "\n"
18641  " Set device-compression level. Only used for drivers that provide\n"
18642  " compression. This function, if used, should be invoked before a call\n"
18643  " to plinit. \n"
18644  "\n"
18645  " Redacted form: plscompression(compression)\n"
18646  "\n"
18647  " This function is used in example 31. \n"
18648  "\n"
18649  "\n"
18650  "\n"
18651  "SYNOPSIS:\n"
18652  "\n"
18653  "plscompression(compression)\n"
18654  "\n"
18655  "ARGUMENTS:\n"
18656  "\n"
18657  " compression (PLINT, input) : The desired compression level. This is\n"
18658  " a device-dependent value. Currently only the jpeg and png devices\n"
18659  " use these values. For jpeg value is the jpeg quality which should\n"
18660  " normally be in the range 0-95. Higher values denote higher quality\n"
18661  " and hence larger image sizes. For png values are in the range -1\n"
18662  " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
18663  " A value of -1 denotes the default zlib compression level. Values\n"
18664  " in the range 10-99 are divided by 10 and then used as the zlib\n"
18665  " compression level. Higher compression levels correspond to greater\n"
18666  " compression and small file sizes at the expense of more\n"
18667  " computation. \n"
18668  "\n"
18669  ""},
18670  { (char *)"plsdev", _wrap_plsdev, METH_VARARGS, (char *)"\n"
18671  "Set the device (keyword) name \n"
18672  "\n"
18673  "DESCRIPTION:\n"
18674  "\n"
18675  " Set the device (keyword) name. \n"
18676  "\n"
18677  " Redacted form: plsdev(devname)\n"
18678  "\n"
18679  " This function is used in examples 1,14,20. \n"
18680  "\n"
18681  "\n"
18682  "\n"
18683  "SYNOPSIS:\n"
18684  "\n"
18685  "plsdev(devname)\n"
18686  "\n"
18687  "ARGUMENTS:\n"
18688  "\n"
18689  " devname (const char *, input) : Pointer to device (keyword) name\n"
18690  " string. \n"
18691  "\n"
18692  ""},
18693  { (char *)"plsdidev", _wrap_plsdidev, METH_VARARGS, (char *)"\n"
18694  "Set parameters that define current device-space window \n"
18695  "\n"
18696  "DESCRIPTION:\n"
18697  "\n"
18698  " Set relative margin width, aspect ratio, and relative justification\n"
18699  " that define current device-space window. If you want to just use the\n"
18700  " previous value for any of these, just pass in the magic value\n"
18701  " PL_NOTSET. It is unlikely that one should ever need to change the\n"
18702  " aspect ratio but it's in there for completeness. If plsdidev is not\n"
18703  " called the default values of mar, jx, and jy are all 0. aspect is set\n"
18704  " to a device-specific value. \n"
18705  "\n"
18706  " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
18707  "\n"
18708  " This function is used in example 31. \n"
18709  "\n"
18710  "\n"
18711  "\n"
18712  "SYNOPSIS:\n"
18713  "\n"
18714  "plsdidev(mar, aspect, jx, jy)\n"
18715  "\n"
18716  "ARGUMENTS:\n"
18717  "\n"
18718  " mar (PLFLT, input) : Relative margin width. \n"
18719  "\n"
18720  " aspect (PLFLT, input) : Aspect ratio. \n"
18721  "\n"
18722  " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
18723  " the range -0.5 to 0.5. \n"
18724  "\n"
18725  " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
18726  " the range -0.5 to 0.5. \n"
18727  "\n"
18728  ""},
18729  { (char *)"plsdimap", _wrap_plsdimap, METH_VARARGS, (char *)"\n"
18730  "Set up transformation from metafile coordinates \n"
18731  "\n"
18732  "DESCRIPTION:\n"
18733  "\n"
18734  " Set up transformation from metafile coordinates. The size of the plot\n"
18735  " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
18736  " general-purpose facility just yet (not sure why the user would need\n"
18737  " it, for one). \n"
18738  "\n"
18739  " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
18740  " dimypmm)\n"
18741  "\n"
18742  " This function is not used in any examples. \n"
18743  "\n"
18744  "\n"
18745  "\n"
18746  "SYNOPSIS:\n"
18747  "\n"
18748  "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
18749  "\n"
18750  "ARGUMENTS:\n"
18751  "\n"
18752  " dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n"
18753  "\n"
18754  " dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n"
18755  "\n"
18756  " dimymin (PLINT, input) : NEEDS DOCUMENTATION \n"
18757  "\n"
18758  " dimymax (PLINT, input) : NEEDS DOCUMENTATION \n"
18759  "\n"
18760  " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
18761  "\n"
18762  " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
18763  "\n"
18764  ""},
18765  { (char *)"plsdiori", _wrap_plsdiori, METH_VARARGS, (char *)"\n"
18766  "Set plot orientation \n"
18767  "\n"
18768  "DESCRIPTION:\n"
18769  "\n"
18770  " Set plot orientation parameter which is multiplied by 90 degrees to\n"
18771  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
18772  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
18773  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
18774  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
18775  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
18776  " not called the default value of rot is 0. \n"
18777  "\n"
18778  " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
18779  " probably want to change the aspect ratio to a value suitable for the\n"
18780  " plot orientation using a call to plsdidev or the command-line options\n"
18781  " -a or -freeaspect. For more documentation of those options see the\n"
18782  " PLplot documentation. Such command-line options can be set internally\n"
18783  " using plsetopt or set directly using the command line and parsed using\n"
18784  " a call to plparseopts. \n"
18785  "\n"
18786  " Redacted form: plsdiori(rot)\n"
18787  "\n"
18788  " This function is not used in any examples. \n"
18789  "\n"
18790  "\n"
18791  "\n"
18792  "SYNOPSIS:\n"
18793  "\n"
18794  "plsdiori(rot)\n"
18795  "\n"
18796  "ARGUMENTS:\n"
18797  "\n"
18798  " rot (PLFLT, input) : Plot orientation parameter. \n"
18799  "\n"
18800  ""},
18801  { (char *)"plsdiplt", _wrap_plsdiplt, METH_VARARGS, (char *)"\n"
18802  "Set parameters that define current plot-space window \n"
18803  "\n"
18804  "DESCRIPTION:\n"
18805  "\n"
18806  " Set relative minima and maxima that define the current plot-space\n"
18807  " window. If plsdiplt is not called the default values of xmin, ymin,\n"
18808  " xmax, and ymax are 0., 0., 1., and 1. \n"
18809  "\n"
18810  " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
18811  "\n"
18812  " This function is used in example 31. \n"
18813  "\n"
18814  "\n"
18815  "\n"
18816  "SYNOPSIS:\n"
18817  "\n"
18818  "plsdiplt(xmin, ymin, xmax, ymax)\n"
18819  "\n"
18820  "ARGUMENTS:\n"
18821  "\n"
18822  " xmin (PLFLT, input) : Relative minimum in x. \n"
18823  "\n"
18824  " ymin (PLFLT, input) : Relative minimum in y. \n"
18825  "\n"
18826  " xmax (PLFLT, input) : Relative maximum in x. \n"
18827  "\n"
18828  " ymax (PLFLT, input) : Relative maximum in y. \n"
18829  "\n"
18830  ""},
18831  { (char *)"plsdiplz", _wrap_plsdiplz, METH_VARARGS, (char *)"\n"
18832  "Set parameters incrementally (zoom mode) that define current plot-space window \n"
18833  "\n"
18834  "DESCRIPTION:\n"
18835  "\n"
18836  " Set relative minima and maxima incrementally (zoom mode) that define\n"
18837  " the current plot-space window. This function has the same effect as\n"
18838  " plsdiplt if that function has not been previously called. Otherwise,\n"
18839  " this function implements zoom mode using the transformation min_used =\n"
18840  " old_min + old_length*min and max_used = old_min + old_length*max for\n"
18841  " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
18842  " repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n"
18843  "\n"
18844  " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
18845  "\n"
18846  " This function is used in example 31. \n"
18847  "\n"
18848  "\n"
18849  "\n"
18850  "SYNOPSIS:\n"
18851  "\n"
18852  "plsdiplz(xmin, ymin, xmax, ymax)\n"
18853  "\n"
18854  "ARGUMENTS:\n"
18855  "\n"
18856  " xmin (PLFLT, input) : Relative (incremental) minimum in x. \n"
18857  "\n"
18858  " ymin (PLFLT, input) : Relative (incremental) minimum in y. \n"
18859  "\n"
18860  " xmax (PLFLT, input) : Relative (incremental) maximum in x. \n"
18861  "\n"
18862  " ymax (PLFLT, input) : Relative (incremental) maximum in y. \n"
18863  "\n"
18864  ""},
18865  { (char *)"plseed", _wrap_plseed, METH_VARARGS, (char *)"\n"
18866  "Set seed for internal random number generator. \n"
18867  "\n"
18868  "DESCRIPTION:\n"
18869  "\n"
18870  " Set the seed for the internal random number generator. See plrandd for\n"
18871  " further details. \n"
18872  "\n"
18873  " Redacted form: plseed(seed)\n"
18874  "\n"
18875  " This function is used in example 21. \n"
18876  "\n"
18877  "\n"
18878  "\n"
18879  "SYNOPSIS:\n"
18880  "\n"
18881  "plseed(seed)\n"
18882  "\n"
18883  "ARGUMENTS:\n"
18884  "\n"
18885  " seed (unsigned int, input) : Seed for random number generator. \n"
18886  "\n"
18887  ""},
18888  { (char *)"plsesc", _wrap_plsesc, METH_VARARGS, (char *)"\n"
18889  "Set the escape character for text strings \n"
18890  "\n"
18891  "DESCRIPTION:\n"
18892  "\n"
18893  " Set the escape character for text strings. From C (in contrast to\n"
18894  " Fortran 77, see plsescfortran77) you pass esc as a character. Only\n"
18895  " selected characters are allowed to prevent the user from shooting\n"
18896  " himself in the foot (For example, a \\ isn't allowed since it conflicts\n"
18897  " with C's use of backslash as a character escape). Here are the\n"
18898  " allowed escape characters and their corresponding decimal ASCII\n"
18899  " values: !, ASCII 33 \n"
18900  " #, ASCII 35 \n"
18901  " $, ASCII 36 \n"
18902  " %, ASCII 37 \n"
18903  " &, ASCII 38 \n"
18904  " *, ASCII 42 \n"
18905  " @, ASCII 64 \n"
18906  " ^, ASCII 94 \n"
18907  " ~, ASCII 126 \n"
18908  "\n"
18909  "\n"
18910  " Redacted form: General: plsesc(esc)\n"
18911  " Perl/PDL: Not available? \n"
18912  "\n"
18913  "\n"
18914  " This function is used in example 29. \n"
18915  "\n"
18916  "\n"
18917  "\n"
18918  "SYNOPSIS:\n"
18919  "\n"
18920  "plsesc(esc)\n"
18921  "\n"
18922  "ARGUMENTS:\n"
18923  "\n"
18924  " esc (char, input) : Escape character. \n"
18925  "\n"
18926  ""},
18927  { (char *)"plsetopt", _wrap_plsetopt, METH_VARARGS, (char *)"\n"
18928  "Set any command-line option \n"
18929  "\n"
18930  "DESCRIPTION:\n"
18931  "\n"
18932  " Set any command-line option internally from a program before it\n"
18933  " invokes plinit. opt is the name of the command-line option and optarg\n"
18934  " is the corresponding command-line option argument. \n"
18935  "\n"
18936  " This function returns 0 on success. \n"
18937  "\n"
18938  " Redacted form: plsetopt(opt, optarg)\n"
18939  "\n"
18940  " This function is used in example 14. \n"
18941  "\n"
18942  "\n"
18943  "\n"
18944  "SYNOPSIS:\n"
18945  "\n"
18946  "int plsetopt(opt, optarg)\n"
18947  "\n"
18948  "ARGUMENTS:\n"
18949  "\n"
18950  " opt (const char *, input) : Pointer to string containing the\n"
18951  " command-line option. \n"
18952  "\n"
18953  " optarg (const char *, input) : Pointer to string containing the\n"
18954  " argument of the command-line option. \n"
18955  "\n"
18956  ""},
18957  { (char *)"plsfam", _wrap_plsfam, METH_VARARGS, (char *)"\n"
18958  "Set family file parameters \n"
18959  "\n"
18960  "DESCRIPTION:\n"
18961  "\n"
18962  " Sets variables dealing with output file familying. Does nothing if\n"
18963  " familying not supported by the driver. This routine, if used, must be\n"
18964  " called before initializing PLplot. See the PLplot documentation for\n"
18965  " more information. \n"
18966  "\n"
18967  " Redacted form: plsfam(fam, num, bmax)\n"
18968  "\n"
18969  " This function is used in examples 14,31. \n"
18970  "\n"
18971  "\n"
18972  "\n"
18973  "SYNOPSIS:\n"
18974  "\n"
18975  "plsfam(fam, num, bmax)\n"
18976  "\n"
18977  "ARGUMENTS:\n"
18978  "\n"
18979  " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
18980  " is enabled. \n"
18981  "\n"
18982  " num (PLINT, input) : Current family file number. \n"
18983  "\n"
18984  " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
18985  " file. \n"
18986  "\n"
18987  ""},
18988  { (char *)"plsfci", _wrap_plsfci, METH_VARARGS, (char *)"\n"
18989  "Set FCI (font characterization integer) \n"
18990  "\n"
18991  "DESCRIPTION:\n"
18992  "\n"
18993  " Sets font characteristics to be used at the start of the next string\n"
18994  " using the FCI approach. See the PLplot documentation for more\n"
18995  " information. \n"
18996  "\n"
18997  " Redacted form: General: plsfci(fci)\n"
18998  " Perl/PDL: Not available? \n"
18999  "\n"
19000  "\n"
19001  " This function is used in example 23. \n"
19002  "\n"
19003  "\n"
19004  "\n"
19005  "SYNOPSIS:\n"
19006  "\n"
19007  "plsfci(fci)\n"
19008  "\n"
19009  "ARGUMENTS:\n"
19010  "\n"
19011  " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
19012  " of FCI. \n"
19013  "\n"
19014  ""},
19015  { (char *)"plsfnam", _wrap_plsfnam, METH_VARARGS, (char *)"\n"
19016  "Set output file name \n"
19017  "\n"
19018  "DESCRIPTION:\n"
19019  "\n"
19020  " Sets the current output file name, if applicable. If the file name\n"
19021  " has not been specified and is required by the driver, the user will be\n"
19022  " prompted for it. If using the X-windows output driver, this sets the\n"
19023  " display name. This routine, if used, must be called before\n"
19024  " initializing PLplot. \n"
19025  "\n"
19026  " Redacted form: plsfnam(fnam)\n"
19027  "\n"
19028  " This function is used in examples 1,20. \n"
19029  "\n"
19030  "\n"
19031  "\n"
19032  "SYNOPSIS:\n"
19033  "\n"
19034  "plsfnam(fnam)\n"
19035  "\n"
19036  "ARGUMENTS:\n"
19037  "\n"
19038  " fnam (const char *, input) : Pointer to file name string. \n"
19039  "\n"
19040  ""},
19041  { (char *)"plsfont", _wrap_plsfont, METH_VARARGS, (char *)"\n"
19042  "Set family, style and weight of the current font \n"
19043  "\n"
19044  "DESCRIPTION:\n"
19045  "\n"
19046  " Sets the current font. See the PLplot documentation for more\n"
19047  " information on font selection. \n"
19048  "\n"
19049  " Redacted form: plsfont(family, style, weight)\n"
19050  "\n"
19051  " This function is used in example 23. \n"
19052  "\n"
19053  "\n"
19054  "\n"
19055  "SYNOPSIS:\n"
19056  "\n"
19057  "plsfont(family, style, weight)\n"
19058  "\n"
19059  "ARGUMENTS:\n"
19060  "\n"
19061  " family (PLINT, input) : Font family to select for the current font.\n"
19062  " The available values are given by the PL_FCI_* constants in\n"
19063  " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF, \n"
19064  " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
19065  " signifies that the font family should not be altered. \n"
19066  "\n"
19067  " style (PLINT, input) : Font style to select for the current font.\n"
19068  " The available values are given by the PL_FCI_* constants in\n"
19069  " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
19070  " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
19071  " should not be altered. \n"
19072  "\n"
19073  " weight (PLINT, input) : Font weight to select for the current font.\n"
19074  " The available values are given by the PL_FCI_* constants in\n"
19075  " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
19076  " negative value signifies that the font weight should not be\n"
19077  " altered. \n"
19078  "\n"
19079  ""},
19080  { (char *)"plshades", _wrap_plshades, METH_VARARGS, (char *)"\n"
19081  "Shade regions on the basis of value \n"
19082  "\n"
19083  "DESCRIPTION:\n"
19084  "\n"
19085  " Shade regions on the basis of value. This is the high-level routine\n"
19086  " for making continuous color shaded plots with cmap1 while plshade (or\n"
19087  " plshade1) are used for individual shaded regions using either cmap0 or\n"
19088  " cmap1. examples/c/x16c.c shows a number of examples for using this\n"
19089  " function. See the following discussion of the arguments and the PLplot\n"
19090  " documentation for more information. \n"
19091  "\n"
19092  " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
19093  " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
19094  " pltr_data)\n"
19095  " Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n"
19096  " fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n"
19097  " pltr_data)\n"
19098  "\n"
19099  "\n"
19100  " This function is used in examples 16,21. \n"
19101  "\n"
19102  "\n"
19103  "\n"
19104  "SYNOPSIS:\n"
19105  "\n"
19106  "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
19107  "\n"
19108  "ARGUMENTS:\n"
19109  "\n"
19110  " a (PLFLT **, input) : Contains ** pointer to array to be plotted.\n"
19111  " The array must have been declared as PLFLT a[nx][ny]. \n"
19112  "\n"
19113  " nx (PLINT, input) : First dimension of array \"a\". \n"
19114  "\n"
19115  " ny (PLINT, input) : Second dimension of array \"a\". \n"
19116  "\n"
19117  " defined (PLINT (*) (PLFLT, PLFLT), input) : User function\n"
19118  " specifying regions excluded from the shading plot. This function\n"
19119  " accepts x and y coordinates as input arguments and must return 0\n"
19120  " if the point is in the excluded region or 1 otherwise. This\n"
19121  " argument can be NULL if all the values are valid. \n"
19122  "\n"
19123  " xmin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19124  " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19125  " at (xmax,ymin) and so on. \n"
19126  "\n"
19127  " xmax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19128  " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19129  " at (xmax,ymin) and so on. \n"
19130  "\n"
19131  " ymin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19132  " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19133  " at (xmax,ymin) and so on. \n"
19134  "\n"
19135  " ymax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19136  " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19137  " at (xmax,ymin) and so on. \n"
19138  "\n"
19139  " clevel (PLFLT *, input) : Pointer to array containing the data\n"
19140  " levels corresponding to the edges of each shaded region that will\n"
19141  " be plotted by this function. To work properly the levels should\n"
19142  " be monotonic. \n"
19143  "\n"
19144  " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
19145  " of shade edge values in clevel). \n"
19146  "\n"
19147  " fill_width (PLFLT, input) : Defines line width used by the fill\n"
19148  " pattern. \n"
19149  "\n"
19150  " cont_color (PLINT, input) : Defines pen color used for contours\n"
19151  " defining edges of shaded regions. The pen color is only temporary\n"
19152  " set for the contour drawing. Set this value to zero or less if no\n"
19153  " shade edge contours are wanted. \n"
19154  "\n"
19155  " cont_width (PLFLT, input) : Defines line width used for contours\n"
19156  " defining edges of shaded regions. This value may not be honored\n"
19157  " by all drivers. The pen width is only temporary set for the\n"
19158  " contour drawing. Set this value to zero or less if no shade edge\n"
19159  " contours are wanted. \n"
19160  "\n"
19161  " fill (void (*) (PLINT, PLFLT *, PLFLT *), input) : Routine used to\n"
19162  " fill the region. Use plfill. Future version of PLplot may have\n"
19163  " other fill routines. \n"
19164  "\n"
19165  " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
19166  " map to rectangles after coordinate transformation with pltrl. \n"
19167  " Otherwise, set rectangular to false. If rectangular is set to\n"
19168  " true, plshade tries to save time by filling large rectangles. \n"
19169  " This optimization fails if the coordinate transformation distorts\n"
19170  " the shape of rectangles. For example a plot in polar coordinates\n"
19171  " has to have rectangular set to false. \n"
19172  "\n"
19173  " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
19174  " Pointer to function that defines transformation between indices\n"
19175  " in array z and the world coordinates (C only). Transformation\n"
19176  " functions are provided in the PLplot library: pltr0 for identity\n"
19177  " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
19178  " defined by one- and two-dimensional arrays. In addition,\n"
19179  " user-supplied routines for the transformation can be used as well.\n"
19180  " Examples of all of these approaches are given in the PLplot\n"
19181  " documentation. The transformation function should have the form\n"
19182  " given by any of pltr0, pltr1, or pltr2. \n"
19183  "\n"
19184  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
19185  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
19186  " externally supplied. \n"
19187  "\n"
19188  ""},
19189  { (char *)"plshade", _wrap_plshade, METH_VARARGS, (char *)"\n"
19190  "Shade individual region on the basis of value \n"
19191  "\n"
19192  "ESCRIPTION:\n"
19193  "\n"
19194  " Shade individual region on the basis of value. Use plshades if you\n"
19195  " want to shade a number of regions using continuous colors. plshade is\n"
19196  " identical to plshade1 except for the type of the first parameter. See\n"
19197  " plshade1 for further discussion. \n"
19198  "\n"
19199  " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
19200  " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
19201  " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
19202  " Perl/PDL: Not available? \n"
19203  "\n"
19204  "\n"
19205  " This function is used in example 15. \n"
19206  "\n"
19207  "\n"
19208  "\n"
19209  "YNOPSIS:\n"
19210  "\n"
19211  "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"
19212  "\n"
19213  "RGUMENTS:\n"
19214  "\n"
19215  " a (PLFLT **, input) : \n"
19216  "\n"
19217  " nx (PLINT, input) : \n"
19218  "\n"
19219  " ny (PLINT, input) : \n"
19220  "\n"
19221  " defined (PLINT (*) (PLFLT, PLFLT), input) : \n"
19222  "\n"
19223  " xmin (PLFLT, input) : \n"
19224  "\n"
19225  " xmax (PLFLT, input) : \n"
19226  "\n"
19227  " ymin (PLFLT, input) : \n"
19228  "\n"
19229  " ymax (PLFLT, input) : \n"
19230  "\n"
19231  " shade_min (PLFLT, input) : \n"
19232  "\n"
19233  " shade_max (PLFLT, input) : \n"
19234  "\n"
19235  " sh_cmap (PLINT, input) : \n"
19236  "\n"
19237  " sh_color (PLFLT, input) : \n"
19238  "\n"
19239  " sh_width (PLFLT, input) : \n"
19240  "\n"
19241  " min_color (PLINT, input) : \n"
19242  "\n"
19243  " min_width (PLFLT, input) : \n"
19244  "\n"
19245  " max_color (PLINT, input) : \n"
19246  "\n"
19247  " max_width (PLFLT, input) : \n"
19248  "\n"
19249  " fill (void (*) (PLINT, PLFLT *, PLFLT *), input) : \n"
19250  "\n"
19251  " rectangular (PLBOOL, input) : \n"
19252  "\n"
19253  " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
19254  "\n"
19255  " pltr_data (PLPointer, input) : \n"
19256  "\n"
19257  ""},
19258  { (char *)"plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, (char *)"\n"
19259  "Assign a function to use for generating custom axis labels \n"
19260  "\n"
19261  "DESCRIPTION:\n"
19262  "\n"
19263  " This function allows a user to provide their own function to provide\n"
19264  " axis label text. The user function is given the numeric value for a\n"
19265  " point on an axis and returns a string label to correspond with that\n"
19266  " value. Custom axis labels can be enabled by passing appropriate\n"
19267  " arguments to plenv, plbox, plbox3 and similar functions. \n"
19268  "\n"
19269  " This function is used in example 19. \n"
19270  "\n"
19271  "\n"
19272  "\n"
19273  "SYNOPSIS:\n"
19274  "\n"
19275  "plslabelfunc(label_func, label_data)\n"
19276  "\n"
19277  "ARGUMENTS:\n"
19278  "\n"
19279  " label_func (void (*) (PLINT, PLFLT, char *, PLINT, void *), input) : \n"
19280  " This is the custom label function. In order to reset to the\n"
19281  " default labeling, set this to NULL. The labeling function\n"
19282  " parameters are, in order: axis: This indicates which axis a\n"
19283  " label is being requested for. The value will be one of PL_X_AXIS,\n"
19284  " PL_Y_AXIS or PL_Z_AXIS. \n"
19285  "\n"
19286  " value: This is the value along the axis which is being labeled. \n"
19287  "\n"
19288  " label_text: The string representation of the label value. \n"
19289  "\n"
19290  " length: The maximum length in characters allowed for label_text. \n"
19291  "\n"
19292  "\n"
19293  " label_data (void *, input) : This parameter may be used to pass\n"
19294  " data to the label_func function. \n"
19295  "\n"
19296  ""},
19297  { (char *)"plsmaj", _wrap_plsmaj, METH_VARARGS, (char *)"\n"
19298  "Set length of major ticks \n"
19299  "\n"
19300  "DESCRIPTION:\n"
19301  "\n"
19302  " This sets up the length of the major ticks. The actual length is the\n"
19303  " product of the default length and a scaling factor as for character\n"
19304  " height. \n"
19305  "\n"
19306  " Redacted form: plsmaj(def, scale)\n"
19307  "\n"
19308  " This function is used in example 29. \n"
19309  "\n"
19310  "\n"
19311  "\n"
19312  "SYNOPSIS:\n"
19313  "\n"
19314  "plsmaj(def, scale)\n"
19315  "\n"
19316  "ARGUMENTS:\n"
19317  "\n"
19318  " def (PLFLT, input) : The default length of a major tick in\n"
19319  " millimeters, should be set to zero if the default length is to\n"
19320  " remain unchanged. \n"
19321  "\n"
19322  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19323  " actual tick length. \n"
19324  "\n"
19325  ""},
19326  { (char *)"plsmem", _wrap_plsmem, METH_VARARGS, (char *)"\n"
19327  "Set the memory area to be plotted (RGB) \n"
19328  "\n"
19329  "DESCRIPTION:\n"
19330  "\n"
19331  " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
19332  " the dev member of the stream structure. Also set the number of pixels\n"
19333  " in the memory passed in \n"
19334  " plotmem, which is a block of memory \n"
19335  " maxy by \n"
19336  " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB) \n"
19337  "\n"
19338  " This memory will have to be freed by the user! \n"
19339  "\n"
19340  " Redacted form: plsmem(maxx, maxy, plotmem)\n"
19341  "\n"
19342  " This function is not used in any examples. \n"
19343  "\n"
19344  "\n"
19345  "\n"
19346  "SYNOPSIS:\n"
19347  "\n"
19348  "plsmem(maxx, maxy, plotmem)\n"
19349  "\n"
19350  "ARGUMENTS:\n"
19351  "\n"
19352  " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
19353  "\n"
19354  " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
19355  "\n"
19356  " plotmem (void *, input) : Pointer to the beginning of the\n"
19357  " user-supplied memory area. \n"
19358  "\n"
19359  ""},
19360  { (char *)"plsmema", _wrap_plsmema, METH_VARARGS, (char *)"\n"
19361  "Set the memory area to be plotted (RGBA) \n"
19362  "\n"
19363  "DESCRIPTION:\n"
19364  "\n"
19365  " Set the memory area to be plotted (with the memcairo driver) as the\n"
19366  " dev member of the stream structure. Also set the number of pixels in\n"
19367  " the memory passed in \n"
19368  " plotmem, which is a block of memory \n"
19369  " maxy by \n"
19370  " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA) \n"
19371  "\n"
19372  " This memory will have to be freed by the user! \n"
19373  "\n"
19374  " Redacted form: plsmema(maxx, maxy, plotmem)\n"
19375  "\n"
19376  " This function is not used in any examples. \n"
19377  "\n"
19378  "\n"
19379  "\n"
19380  "SYNOPSIS:\n"
19381  "\n"
19382  "plsmema(maxx, maxy, plotmem)\n"
19383  "\n"
19384  "ARGUMENTS:\n"
19385  "\n"
19386  " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
19387  "\n"
19388  " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
19389  "\n"
19390  " plotmem (void *, input) : Pointer to the beginning of the\n"
19391  " user-supplied memory area. \n"
19392  "\n"
19393  ""},
19394  { (char *)"plsmin", _wrap_plsmin, METH_VARARGS, (char *)"\n"
19395  "Set length of minor ticks \n"
19396  "\n"
19397  "DESCRIPTION:\n"
19398  "\n"
19399  " This sets up the length of the minor ticks and the length of the\n"
19400  " terminals on error bars. The actual length is the product of the\n"
19401  " default length and a scaling factor as for character height. \n"
19402  "\n"
19403  " Redacted form: plsmin(def, scale)\n"
19404  "\n"
19405  " This function is used in example 29. \n"
19406  "\n"
19407  "\n"
19408  "\n"
19409  "SYNOPSIS:\n"
19410  "\n"
19411  "plsmin(def, scale)\n"
19412  "\n"
19413  "ARGUMENTS:\n"
19414  "\n"
19415  " def (PLFLT, input) : The default length of a minor tick in\n"
19416  " millimeters, should be set to zero if the default length is to\n"
19417  " remain unchanged. \n"
19418  "\n"
19419  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19420  " actual tick length. \n"
19421  "\n"
19422  ""},
19423  { (char *)"plsori", _wrap_plsori, METH_VARARGS, (char *)"\n"
19424  "Set orientation \n"
19425  "\n"
19426  "DESCRIPTION:\n"
19427  "\n"
19428  " Set integer plot orientation parameter. This function is identical to\n"
19429  " plsdiori except for the type of the argument, and should be used in\n"
19430  " the same way. See the PLplot documentation for details. \n"
19431  "\n"
19432  " Redacted form: plsori(ori)\n"
19433  "\n"
19434  " This function is used in example 3. \n"
19435  "\n"
19436  "\n"
19437  "\n"
19438  "SYNOPSIS:\n"
19439  "\n"
19440  "plsori(ori)\n"
19441  "\n"
19442  "ARGUMENTS:\n"
19443  "\n"
19444  " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
19445  " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
19446  " angle. \n"
19447  "\n"
19448  ""},
19449  { (char *)"plspage", _wrap_plspage, METH_VARARGS, (char *)"\n"
19450  "Set page parameters \n"
19451  "\n"
19452  "DESCRIPTION:\n"
19453  "\n"
19454  " Sets the page configuration (optional). If an individual parameter is\n"
19455  " zero then that parameter value is not updated. Not all parameters are\n"
19456  " recognized by all drivers and the interpretation is device-dependent.\n"
19457  " The X-window driver uses the length and offset parameters to determine\n"
19458  " the window size and location. The length and offset values are\n"
19459  " expressed in units that are specific to the current driver. For\n"
19460  " instance: screen drivers will usually interpret them as number of\n"
19461  " pixels, whereas printer drivers will usually use mm. This routine, if\n"
19462  " used, must be called before initializing PLplot. \n"
19463  "\n"
19464  " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
19465  "\n"
19466  " This function is used in examples 14 and 31. \n"
19467  "\n"
19468  "\n"
19469  "\n"
19470  "SYNOPSIS:\n"
19471  "\n"
19472  "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
19473  "\n"
19474  "ARGUMENTS:\n"
19475  "\n"
19476  " xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n"
19477  "\n"
19478  " yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n"
19479  "\n"
19480  " xleng (PLINT , input) : Page length, x. \n"
19481  "\n"
19482  " yleng (PLINT, input) : Page length, y. \n"
19483  "\n"
19484  " xoff (PLINT, input) : Page offset, x. \n"
19485  "\n"
19486  " yoff (PLINT, input) : Page offset, y. \n"
19487  "\n"
19488  ""},
19489  { (char *)"plspal0", _wrap_plspal0, METH_VARARGS, (char *)"\n"
19490  "Set the colors for color table 0 from a cmap0 file \n"
19491  "\n"
19492  "DESCRIPTION:\n"
19493  "\n"
19494  " Set the colors for color table 0 from a cmap0 file \n"
19495  "\n"
19496  " Redacted form: plspal0(filename)\n"
19497  "\n"
19498  " This function is in example 16. \n"
19499  "\n"
19500  "\n"
19501  "\n"
19502  "SYNOPSIS:\n"
19503  "\n"
19504  "plspal0(filename)\n"
19505  "\n"
19506  "ARGUMENTS:\n"
19507  "\n"
19508  " filename (const char *, input) : The name of the cmap0 file, or a\n"
19509  " empty to string to specify the default cmap0 file. \n"
19510  "\n"
19511  ""},
19512  { (char *)"plspal1", _wrap_plspal1, METH_VARARGS, (char *)"\n"
19513  "Set the colors for color table 1 from a cmap1 file \n"
19514  "\n"
19515  "DESCRIPTION:\n"
19516  "\n"
19517  " Set the colors for color table 1 from a cmap1 file \n"
19518  "\n"
19519  " Redacted form: plspal1(filename)\n"
19520  "\n"
19521  " This function is in example 16. \n"
19522  "\n"
19523  "\n"
19524  "\n"
19525  "SYNOPSIS:\n"
19526  "\n"
19527  "plspal1(filename)\n"
19528  "\n"
19529  "ARGUMENTS:\n"
19530  "\n"
19531  " filename (const char *, input) : The name of the cmap1 file, or a\n"
19532  " empty to string to specify the default cmap1 file. \n"
19533  "\n"
19534  ""},
19535  { (char *)"plspause", _wrap_plspause, METH_VARARGS, (char *)"\n"
19536  "Set the pause (on end-of-page) status \n"
19537  "\n"
19538  "DESCRIPTION:\n"
19539  "\n"
19540  " Set the pause (on end-of-page) status. \n"
19541  "\n"
19542  " Redacted form: plspause(pause)\n"
19543  "\n"
19544  " This function is in examples 14,20. \n"
19545  "\n"
19546  "\n"
19547  "\n"
19548  "SYNOPSIS:\n"
19549  "\n"
19550  "plspause(pause)\n"
19551  "\n"
19552  "ARGUMENTS:\n"
19553  "\n"
19554  " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
19555  " end-of-page for those drivers which support this. Otherwise there\n"
19556  " is no pause. \n"
19557  "\n"
19558  ""},
19559  { (char *)"plsstrm", _wrap_plsstrm, METH_VARARGS, (char *)"\n"
19560  "Set current output stream \n"
19561  "\n"
19562  "DESCRIPTION:\n"
19563  "\n"
19564  " Sets the number of the current output stream. The stream number\n"
19565  " defaults to 0 unless changed by this routine. The first use of this\n"
19566  " routine must be followed by a call initializing PLplot (e.g. plstar). \n"
19567  "\n"
19568  " Redacted form: plsstrm(strm)\n"
19569  "\n"
19570  " This function is examples 1,14,20. \n"
19571  "\n"
19572  "\n"
19573  "\n"
19574  "SYNOPSIS:\n"
19575  "\n"
19576  "plsstrm(strm)\n"
19577  "\n"
19578  "ARGUMENTS:\n"
19579  "\n"
19580  " strm (PLINT, input) : The current stream number. \n"
19581  "\n"
19582  ""},
19583  { (char *)"plssub", _wrap_plssub, METH_VARARGS, (char *)"\n"
19584  "Set the number of subpages in x and y \n"
19585  "\n"
19586  "DESCRIPTION:\n"
19587  "\n"
19588  " Set the number of subpages in x and y. \n"
19589  "\n"
19590  " Redacted form: plssub(nx, ny)\n"
19591  "\n"
19592  " This function is examples 1,2,14,21,25,27. \n"
19593  "\n"
19594  "\n"
19595  "\n"
19596  "SYNOPSIS:\n"
19597  "\n"
19598  "plssub(nx, ny)\n"
19599  "\n"
19600  "ARGUMENTS:\n"
19601  "\n"
19602  " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
19603  " of window columns). \n"
19604  "\n"
19605  " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
19606  " of window rows). \n"
19607  "\n"
19608  ""},
19609  { (char *)"plssym", _wrap_plssym, METH_VARARGS, (char *)"\n"
19610  "Set symbol size \n"
19611  "\n"
19612  "DESCRIPTION:\n"
19613  "\n"
19614  " This sets up the size of all subsequent symbols drawn by plpoin and\n"
19615  " plsym. The actual height of a symbol is the product of the default\n"
19616  " symbol size and a scaling factor as for the character height. \n"
19617  "\n"
19618  " Redacted form: plssym(def, scale)\n"
19619  "\n"
19620  " This function is used in example 29. \n"
19621  "\n"
19622  "\n"
19623  "\n"
19624  "SYNOPSIS:\n"
19625  "\n"
19626  "plssym(def, scale)\n"
19627  "\n"
19628  "ARGUMENTS:\n"
19629  "\n"
19630  " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
19631  " should be set to zero if the default height is to remain\n"
19632  " unchanged. \n"
19633  "\n"
19634  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19635  " actual symbol height. \n"
19636  "\n"
19637  ""},
19638  { (char *)"plstar", _wrap_plstar, METH_VARARGS, (char *)"\n"
19639  "Initialization \n"
19640  "\n"
19641  "DESCRIPTION:\n"
19642  "\n"
19643  " Initializing the plotting package. The program prompts for the device\n"
19644  " keyword or number of the desired output device. Hitting a RETURN in\n"
19645  " response to the prompt is the same as selecting the first device. If\n"
19646  " only one device is enabled when PLplot is installed, plstar will issue\n"
19647  " no prompt. The output device is divided into nx by ny subpages, each\n"
19648  " of which may be used independently. The subroutine pladv is used to\n"
19649  " advance from one subpage to the next. \n"
19650  "\n"
19651  " Redacted form: plstar(nx, ny)\n"
19652  "\n"
19653  " This function is used in example 1. \n"
19654  "\n"
19655  "\n"
19656  "\n"
19657  "SYNOPSIS:\n"
19658  "\n"
19659  "plstar(nx, ny)\n"
19660  "\n"
19661  "ARGUMENTS:\n"
19662  "\n"
19663  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
19664  " horizontal direction. \n"
19665  "\n"
19666  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
19667  " vertical direction. \n"
19668  "\n"
19669  ""},
19670  { (char *)"plstart", _wrap_plstart, METH_VARARGS, (char *)"\n"
19671  "Initialization \n"
19672  "\n"
19673  "DESCRIPTION:\n"
19674  "\n"
19675  " Alternative to plstar for initializing the plotting package. The\n"
19676  " device name keyword for the desired output device must be supplied as\n"
19677  " an argument. The device keywords are the same as those printed out by\n"
19678  " plstar. If the requested device is not available, or if the input\n"
19679  " string is empty or begins with ``?'', the prompted startup of plstar\n"
19680  " is used. This routine also divides the output device into nx by ny\n"
19681  " subpages, each of which may be used independently. The subroutine\n"
19682  " pladv is used to advance from one subpage to the next. \n"
19683  "\n"
19684  " Redacted form: General: plstart(device, nx, ny)\n"
19685  " Perl/PDL: plstart(nx, ny, device)\n"
19686  "\n"
19687  "\n"
19688  " This function is not used in any examples. \n"
19689  "\n"
19690  "\n"
19691  "\n"
19692  "SYNOPSIS:\n"
19693  "\n"
19694  "plstart(device, nx, ny)\n"
19695  "\n"
19696  "ARGUMENTS:\n"
19697  "\n"
19698  " device (const char *, input) : Device name (keyword) of the\n"
19699  " required output device. If NULL or if the first character is a\n"
19700  " ``?'', the normal (prompted) startup is used. \n"
19701  "\n"
19702  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
19703  " horizontal direction. \n"
19704  "\n"
19705  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
19706  " vertical direction. \n"
19707  "\n"
19708  ""},
19709  { (char *)"plstransform", _wrap_plstransform, METH_VARARGS, (char *)"\n"
19710  "Set a global coordinate transform function \n"
19711  "\n"
19712  "DESCRIPTION:\n"
19713  "\n"
19714  " This function can be used to define a coordinate transformation which\n"
19715  " affects all elements drawn within the current plot window. The\n"
19716  " transformation function is similar to that provided for the plmap and\n"
19717  " plmeridians functions. The data parameter may be used to pass extra\n"
19718  " data to transform_fun. \n"
19719  "\n"
19720  " Redacted form: General: plstransform(transform_fun, data)\n"
19721  "\n"
19722  "\n"
19723  " This function is used in example 19. \n"
19724  "\n"
19725  "\n"
19726  "\n"
19727  "SYNOPSIS:\n"
19728  "\n"
19729  "plstransform(transform_fun, data)\n"
19730  "\n"
19731  "ARGUMENTS:\n"
19732  "\n"
19733  " transform_fun (void (*) (PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer) ,\n"
19734  " input) : Pointer to a function that defines a transformation\n"
19735  " from the input (x, y) coordinate to a new plot world coordiante. \n"
19736  "\n"
19737  " data (PLPointer, input) : Optional extra data for \n"
19738  " transform_fun. \n"
19739  "\n"
19740  ""},
19741  { (char *)"plstring", _wrap_plstring, METH_VARARGS, (char *)"\n"
19742  "Plot a glyph at the specified points \n"
19743  "\n"
19744  "DESCRIPTION:\n"
19745  "\n"
19746  " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
19747  " because many[!] more glyphs are accessible with plstring.) The glyph\n"
19748  " is specified with a PLplot user string. Note that the user string is\n"
19749  " not actually limited to one glyph so it is possible (but not normally\n"
19750  " useful) to plot more than one glyph at the specified points with this\n"
19751  " function. As with plmtex and plptex, the user string can contain FCI\n"
19752  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
19753  " else PLplot escapes for Hershey or unicode text to determine the\n"
19754  " glyph. \n"
19755  "\n"
19756  " Redacted form: plstring(x, y, string)\n"
19757  "\n"
19758  " This function is used in examples 4, 21 and 26. \n"
19759  "\n"
19760  "\n"
19761  "\n"
19762  "SYNOPSIS:\n"
19763  "\n"
19764  "plstring(n, x, y, string)\n"
19765  "\n"
19766  "ARGUMENTS:\n"
19767  "\n"
19768  " n (PLINT, input) : Number of points in the x and y arrays. \n"
19769  "\n"
19770  " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
19771  " points. \n"
19772  "\n"
19773  " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
19774  " points. \n"
19775  "\n"
19776  " string (const char *, input) : PLplot user string corresponding to\n"
19777  " the glyph to be plotted at each of the n points. \n"
19778  "\n"
19779  ""},
19780  { (char *)"plstring3", _wrap_plstring3, METH_VARARGS, (char *)"\n"
19781  "Plot a glyph at the specified 3D points \n"
19782  "\n"
19783  "DESCRIPTION:\n"
19784  "\n"
19785  " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
19786  " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
19787  " this function similar to what is done for plline3. The glyph is\n"
19788  " specified with a PLplot user string. Note that the user string is not\n"
19789  " actually limited to one glyph so it is possible (but not normally\n"
19790  " useful) to plot more than one glyph at the specified points with this\n"
19791  " function. As with plmtex and plptex, the user string can contain FCI\n"
19792  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
19793  " else PLplot escapes for Hershey or unicode text to determine the\n"
19794  " glyph. \n"
19795  "\n"
19796  " Redacted form: plstring3(x, y, z, string)\n"
19797  "\n"
19798  " This function is used in example 18. \n"
19799  "\n"
19800  "\n"
19801  "\n"
19802  "SYNOPSIS:\n"
19803  "\n"
19804  "plstring3(n, x, y, z, string)\n"
19805  "\n"
19806  "ARGUMENTS:\n"
19807  "\n"
19808  " n (PLINT, input) : Number of points in the x, y, and z arrays. \n"
19809  "\n"
19810  " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
19811  " points. \n"
19812  "\n"
19813  " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
19814  " points. \n"
19815  "\n"
19816  " z (PLFLT *, input) : Pointer to an array with Z coordinates of\n"
19817  " points. \n"
19818  "\n"
19819  " string (const char *, input) : PLplot user string corresponding to\n"
19820  " the glyph to be plotted at each of the n points. \n"
19821  "\n"
19822  ""},
19823  { (char *)"plstripa", _wrap_plstripa, METH_VARARGS, (char *)"\n"
19824  "Add a point to a stripchart \n"
19825  "\n"
19826  "DESCRIPTION:\n"
19827  "\n"
19828  " Add a point to a given pen of a given stripchart. There is no need for\n"
19829  " all pens to have the same number of points or to be equally sampled in\n"
19830  " the x coordinate. Allocates memory and rescales as necessary. \n"
19831  "\n"
19832  " Redacted form: plstripa(id, p, x, y)\n"
19833  "\n"
19834  " This function is used in example 17. \n"
19835  "\n"
19836  "\n"
19837  "\n"
19838  "SYNOPSIS:\n"
19839  "\n"
19840  "plstripa(id, p, x, y)\n"
19841  "\n"
19842  "ARGUMENTS:\n"
19843  "\n"
19844  " id (PLINT, input) : Identification number (set up in plstripc) of\n"
19845  " the stripchart. \n"
19846  "\n"
19847  " p (PLINT, input) : Pen number (ranges from 0 to 3). \n"
19848  "\n"
19849  " x (PLFLT, input) : X coordinate of point to plot. \n"
19850  "\n"
19851  " y (PLFLT, input) : Y coordinate of point to plot. \n"
19852  "\n"
19853  ""},
19854  { (char *)"plstripc", _wrap_plstripc, METH_VARARGS, (char *)"\n"
19855  "Create a 4-pen stripchart \n"
19856  "\n"
19857  "DESCRIPTION:\n"
19858  "\n"
19859  " Create a 4-pen stripchart, to be used afterwards by plstripa\n"
19860  "\n"
19861  " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
19862  " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
19863  " styline, legline, labx, laby, labz)\n"
19864  " Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n"
19865  " ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n"
19866  " ypsec, legline, labx, laby, labtop)\n"
19867  "\n"
19868  "\n"
19869  " This function is used in example 17. \n"
19870  "\n"
19871  "\n"
19872  "\n"
19873  "SYNOPSIS:\n"
19874  "\n"
19875  "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
19876  "\n"
19877  "ARGUMENTS:\n"
19878  "\n"
19879  " id (PLINT *, output) : Identification number of stripchart to use\n"
19880  " on plstripa and plstripd. \n"
19881  "\n"
19882  " xspec (char *, input) : X-axis specification as in plbox. \n"
19883  "\n"
19884  " yspec (char *, input) : Y-axis specification as in plbox. \n"
19885  "\n"
19886  " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
19887  " change as data are added. \n"
19888  "\n"
19889  " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
19890  " change as data are added. \n"
19891  "\n"
19892  " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
19893  " is multiplied by the factor (1 + \n"
19894  " xjump). \n"
19895  "\n"
19896  " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
19897  " change as data are added. \n"
19898  "\n"
19899  " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
19900  " change as data are added. \n"
19901  "\n"
19902  " xlpos (PLFLT, input) : X legend box position (range from 0 to 1). \n"
19903  "\n"
19904  " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1). \n"
19905  "\n"
19906  " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
19907  " true, otherwise not. \n"
19908  "\n"
19909  " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
19910  " otherwise slide display. \n"
19911  "\n"
19912  " colbox (PLINT, input) : Plot box color index (cmap0). \n"
19913  "\n"
19914  " collab (PLINT, input) : Legend color index (cmap0). \n"
19915  "\n"
19916  " colline (PLINT *, input) : Pointer to array with color indices\n"
19917  " (cmap0) for the 4 pens. \n"
19918  "\n"
19919  " styline (PLINT *, input) : Pointer to array with line styles for\n"
19920  " the 4 pens. \n"
19921  "\n"
19922  " legline (char **, input) : Pointer to character array containing\n"
19923  " legends for the 4 pens. \n"
19924  "\n"
19925  " labx (char *, input) : X-axis label. \n"
19926  "\n"
19927  " laby (char *, input) : Y-axis label. \n"
19928  "\n"
19929  " labtop (char *, input) : Plot title. \n"
19930  "\n"
19931  ""},
19932  { (char *)"plstripd", _wrap_plstripd, METH_VARARGS, (char *)"\n"
19933  "Deletes and releases memory used by a stripchart \n"
19934  "\n"
19935  "DESCRIPTION:\n"
19936  "\n"
19937  " Deletes and releases memory used by a stripchart. \n"
19938  "\n"
19939  " Redacted form: plstripd(id)\n"
19940  "\n"
19941  " This function is used in example 17. \n"
19942  "\n"
19943  "\n"
19944  "\n"
19945  "SYNOPSIS:\n"
19946  "\n"
19947  "plstripd(id)\n"
19948  "\n"
19949  "ARGUMENTS:\n"
19950  "\n"
19951  " id (PLINT, input) : Identification number of stripchart to delete. \n"
19952  "\n"
19953  ""},
19954  { (char *)"plstyl", _wrap_plstyl, METH_VARARGS, (char *)"\n"
19955  "Set line style \n"
19956  "\n"
19957  "DESCRIPTION:\n"
19958  "\n"
19959  " This sets up the line style for all lines subsequently drawn. A line\n"
19960  " consists of segments in which the pen is alternately down and up. The\n"
19961  " lengths of these segments are passed in the arrays mark and space\n"
19962  " respectively. The number of mark-space pairs is specified by nels. \n"
19963  " In order to return the line style to the default continuous line,\n"
19964  " plstyl should be called with nels=0.(see also pllsty) \n"
19965  "\n"
19966  " Redacted form: plstyl(mark, space)\n"
19967  "\n"
19968  " This function is used in examples 1,9,14. \n"
19969  "\n"
19970  "\n"
19971  "\n"
19972  "SYNOPSIS:\n"
19973  "\n"
19974  "plstyl(nels, mark, space)\n"
19975  "\n"
19976  "ARGUMENTS:\n"
19977  "\n"
19978  " nels (PLINT, input) : The number of mark and space elements in a\n"
19979  " line. Thus a simple broken line can be obtained by setting\n"
19980  " nels=1. A continuous line is specified by setting nels=0. \n"
19981  "\n"
19982  " mark (PLINT *, input) : Pointer to array with the lengths of the\n"
19983  " segments during which the pen is down, measured in micrometers. \n"
19984  "\n"
19985  " space (PLINT *, input) : Pointer to array with the lengths of the\n"
19986  " segments during which the pen is up, measured in micrometers. \n"
19987  "\n"
19988  ""},
19989  { (char *)"plsvect", _wrap_plsvect, METH_VARARGS, (char *)"\n"
19990  "Set arrow style for vector plots \n"
19991  "\n"
19992  "DESCRIPTION:\n"
19993  "\n"
19994  " Set the style for the arrow used by plvect to plot vectors. \n"
19995  "\n"
19996  " Redacted form: plsvect(arrowx, arrowy, fill)\n"
19997  "\n"
19998  " This function is used in example 22. \n"
19999  "\n"
20000  "\n"
20001  "\n"
20002  "SYNOPSIS:\n"
20003  "\n"
20004  "plsvect(arrowx, arrowy, npts, fill)\n"
20005  "\n"
20006  "ARGUMENTS:\n"
20007  "\n"
20008  " arrowx, arrowy (PLFLT *,input) : Pointers to a pair of arrays\n"
20009  " containing the x and y points which make up the arrow. The arrow\n"
20010  " is plotted by joining these points to form a polygon. The scaling\n"
20011  " assumes that the x and y points in the arrow lie in the range -0.5\n"
20012  " <= x,y <= 0.5. \n"
20013  "\n"
20014  " npts (PLINT,input) : Number of points in the arrays arrowx and\n"
20015  " arrowy. \n"
20016  "\n"
20017  " fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n"
20018  " fill is false then the arrow is open. \n"
20019  "\n"
20020  ""},
20021  { (char *)"plsvpa", _wrap_plsvpa, METH_VARARGS, (char *)"\n"
20022  "Specify viewport in absolute coordinates \n"
20023  "\n"
20024  "DESCRIPTION:\n"
20025  "\n"
20026  " Alternate routine to plvpor for setting up the viewport. This routine\n"
20027  " should be used only if the viewport is required to have a definite\n"
20028  " size in millimeters. The routine plgspa is useful for finding out the\n"
20029  " size of the current subpage. \n"
20030  "\n"
20031  " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
20032  "\n"
20033  " This function is used in example 10. \n"
20034  "\n"
20035  "\n"
20036  "\n"
20037  "SYNOPSIS:\n"
20038  "\n"
20039  "plsvpa(xmin, xmax, ymin, ymax)\n"
20040  "\n"
20041  "ARGUMENTS:\n"
20042  "\n"
20043  " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
20044  " viewport from the left-hand edge of the subpage in millimeters. \n"
20045  "\n"
20046  " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
20047  " viewport from the left-hand edge of the subpage in millimeters. \n"
20048  "\n"
20049  " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
20050  " viewport from the bottom edge of the subpage in millimeters. \n"
20051  "\n"
20052  " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
20053  " from the bottom edge of the subpage in millimeters. \n"
20054  "\n"
20055  ""},
20056  { (char *)"plsxax", _wrap_plsxax, METH_VARARGS, (char *)"\n"
20057  "Set x axis parameters \n"
20058  "\n"
20059  "DESCRIPTION:\n"
20060  "\n"
20061  " Sets values of the digmax and digits flags for the x axis. See the\n"
20062  " PLplot documentation for more information. \n"
20063  "\n"
20064  " Redacted form: plsxax(digmax, digits)\n"
20065  "\n"
20066  " This function is used in example 31. \n"
20067  "\n"
20068  "\n"
20069  "\n"
20070  "SYNOPSIS:\n"
20071  "\n"
20072  "plsxax(digmax, digits)\n"
20073  "\n"
20074  "ARGUMENTS:\n"
20075  "\n"
20076  " digmax (PLINT, input) : Variable to set the maximum number of\n"
20077  " digits for the x axis. If nonzero, the printed label will be\n"
20078  " switched to a floating point representation when the number of\n"
20079  " digits exceeds digmax. \n"
20080  "\n"
20081  " digits (PLINT, input) : Field digits value. Currently, changing\n"
20082  " its value here has no effect since it is set only by plbox or\n"
20083  " plbox3. However, the user may obtain its value after a call to\n"
20084  " either of these functions by calling plgxax. \n"
20085  "\n"
20086  ""},
20087  { (char *)"plsyax", _wrap_plsyax, METH_VARARGS, (char *)"\n"
20088  "Set y axis parameters \n"
20089  "\n"
20090  "DESCRIPTION:\n"
20091  "\n"
20092  " Identical to plsxax, except that arguments are flags for y axis. See\n"
20093  " the description of plsxax for more detail. \n"
20094  "\n"
20095  " Redacted form: plsyax(digmax, digits)\n"
20096  "\n"
20097  " This function is used in examples 1,14,31. \n"
20098  "\n"
20099  "\n"
20100  "\n"
20101  "SYNOPSIS:\n"
20102  "\n"
20103  "plsyax(digmax, digits)\n"
20104  "\n"
20105  "ARGUMENTS:\n"
20106  "\n"
20107  " digmax (PLINT, input) : Variable to set the maximum number of\n"
20108  " digits for the y axis. If nonzero, the printed label will be\n"
20109  " switched to a floating point representation when the number of\n"
20110  " digits exceeds digmax. \n"
20111  "\n"
20112  " digits (PLINT, input) : Field digits value. Currently, changing\n"
20113  " its value here has no effect since it is set only by plbox or\n"
20114  " plbox3. However, the user may obtain its value after a call to\n"
20115  " either of these functions by calling plgyax. \n"
20116  "\n"
20117  ""},
20118  { (char *)"plsym", _wrap_plsym, METH_VARARGS, (char *)"\n"
20119  "Plot a glyph at the specified points \n"
20120  "\n"
20121  "DESCRIPTION:\n"
20122  "\n"
20123  " Plot a glyph at the specified points. (This function is largely\n"
20124  " superseded by plstring which gives access to many[!] more glyphs.) \n"
20125  "\n"
20126  " Redacted form: plsym(x, y, code)\n"
20127  "\n"
20128  " This function is used in example 7. \n"
20129  "\n"
20130  "\n"
20131  "\n"
20132  "SYNOPSIS:\n"
20133  "\n"
20134  "plsym(n, x, y, code)\n"
20135  "\n"
20136  "ARGUMENTS:\n"
20137  "\n"
20138  " n (PLINT, input) : Number of points in the x and y arrays. \n"
20139  "\n"
20140  " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
20141  " points. \n"
20142  "\n"
20143  " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
20144  " points. \n"
20145  "\n"
20146  " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
20147  " to be plotted at each of the n points. \n"
20148  "\n"
20149  ""},
20150  { (char *)"plszax", _wrap_plszax, METH_VARARGS, (char *)"\n"
20151  "Set z axis parameters \n"
20152  "\n"
20153  "DESCRIPTION:\n"
20154  "\n"
20155  " Identical to plsxax, except that arguments are flags for z axis. See\n"
20156  " the description of plsxax for more detail. \n"
20157  "\n"
20158  " Redacted form: plszax(digmax, digits)\n"
20159  "\n"
20160  " This function is used in example 31. \n"
20161  "\n"
20162  "\n"
20163  "\n"
20164  "SYNOPSIS:\n"
20165  "\n"
20166  "plszax(digmax, digits)\n"
20167  "\n"
20168  "ARGUMENTS:\n"
20169  "\n"
20170  " digmax (PLINT, input) : Variable to set the maximum number of\n"
20171  " digits for the z axis. If nonzero, the printed label will be\n"
20172  " switched to a floating point representation when the number of\n"
20173  " digits exceeds digmax. \n"
20174  "\n"
20175  " digits (PLINT, input) : Field digits value. Currently, changing\n"
20176  " its value here has no effect since it is set only by plbox or\n"
20177  " plbox3. However, the user may obtain its value after a call to\n"
20178  " either of these functions by calling plgzax. \n"
20179  "\n"
20180  ""},
20181  { (char *)"pltext", _wrap_pltext, METH_VARARGS, (char *)"\n"
20182  "Switch to text screen \n"
20183  "\n"
20184  "DESCRIPTION:\n"
20185  "\n"
20186  " Sets an interactive device to text mode, used in conjunction with\n"
20187  " plgra to allow graphics and text to be interspersed. On a device\n"
20188  " which supports separate text and graphics windows, this command causes\n"
20189  " control to be switched to the text window. This can be useful for\n"
20190  " printing diagnostic messages or getting user input, which would\n"
20191  " otherwise interfere with the plots. The program must switch back to\n"
20192  " the graphics window before issuing plot commands, as the text (or\n"
20193  " console) device will probably become quite confused otherwise. If\n"
20194  " already in text mode, this command is ignored. It is also ignored on\n"
20195  " devices which only support a single window or use a different method\n"
20196  " for shifting focus (see also plgra). \n"
20197  "\n"
20198  " Redacted form: pltext()\n"
20199  "\n"
20200  " This function is used in example 1. \n"
20201  "\n"
20202  "\n"
20203  "\n"
20204  "SYNOPSIS:\n"
20205  "\n"
20206  "pltext()\n"
20207  "\n"
20208  ""},
20209  { (char *)"pltimefmt", _wrap_pltimefmt, METH_VARARGS, (char *)"\n"
20210  "Set format for date / time labels \n"
20211  "\n"
20212  "DESCRIPTION:\n"
20213  "\n"
20214  " Sets the format for date / time labels. To enable date / time format\n"
20215  " labels see the options to plbox and plenv. \n"
20216  "\n"
20217  " Redacted form: pltimefmt(fmt)\n"
20218  "\n"
20219  " This function is used in example 29. \n"
20220  "\n"
20221  "\n"
20222  "\n"
20223  "SYNOPSIS:\n"
20224  "\n"
20225  "pltimefmt(fmt)\n"
20226  "\n"
20227  "ARGUMENTS:\n"
20228  "\n"
20229  " fmt (const char *, fmt) : This string is passed directly to the\n"
20230  " system strftime. See the system documentation for a full list of\n"
20231  " conversion specifications for your system. All conversion\n"
20232  " specifications take the form of a '%' character followed by\n"
20233  " further conversion specification character. All other text is\n"
20234  " printed as-is. Common options include: %c: The preferred date and\n"
20235  " time representation for the current locale. \n"
20236  " %d: The day of the month as a decimal number. \n"
20237  " %H: The hour as a decimal number using a 24-hour clock. \n"
20238  " %j: The day of the year as a decimal number. \n"
20239  " %m: The month as a decimal number. \n"
20240  " %M: The minute as a decimal number. \n"
20241  " %S: The second as a decimal number. \n"
20242  " %y: The year as a decimal number without a century. \n"
20243  " %Y: The year as a decimal number including a century. \n"
20244  "\n"
20245  ""},
20246  { (char *)"plvasp", _wrap_plvasp, METH_VARARGS, (char *)"\n"
20247  "Specify viewport using aspect ratio only \n"
20248  "\n"
20249  "DESCRIPTION:\n"
20250  "\n"
20251  " Sets the viewport so that the ratio of the length of the y axis to\n"
20252  " that of the x axis is equal to aspect. \n"
20253  "\n"
20254  " Redacted form: plvasp(aspect)\n"
20255  "\n"
20256  " This function is used in example 13. \n"
20257  "\n"
20258  "\n"
20259  "\n"
20260  "SYNOPSIS:\n"
20261  "\n"
20262  "plvasp(aspect)\n"
20263  "\n"
20264  "ARGUMENTS:\n"
20265  "\n"
20266  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
20267  " axis. \n"
20268  "\n"
20269  ""},
20270  { (char *)"plvect", _wrap_plvect, METH_VARARGS, (char *)"\n"
20271  "Vector plot \n"
20272  "\n"
20273  "DESCRIPTION:\n"
20274  "\n"
20275  " Draws a vector plot of the vector (\n"
20276  " u[\n"
20277  " nx][\n"
20278  " ny],\n"
20279  " v[\n"
20280  " nx][\n"
20281  " ny]). The scaling factor for the vectors is given by scale. A\n"
20282  " transformation routine pointed to by pltr with a pointer pltr_data for\n"
20283  " additional data required by the transformation routine is used to map\n"
20284  " indices within the array to the world coordinates. The style of the\n"
20285  " vector arrow may be set using plsvect. \n"
20286  "\n"
20287  " Redacted form: plvect(u, v, scale, pltr, pltr_data)\n"
20288  "\n"
20289  " This function is used in example 22. \n"
20290  "\n"
20291  "\n"
20292  "\n"
20293  "SYNOPSIS:\n"
20294  "\n"
20295  "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
20296  "\n"
20297  "ARGUMENTS:\n"
20298  "\n"
20299  " u, v (PLFLT **, input) : Pointers to a pair of vectored\n"
20300  " two-dimensional arrays containing the x and y components of the\n"
20301  " vector data to be plotted. \n"
20302  "\n"
20303  " nx, ny (PLINT, input) : Physical dimensions of the arrays u and v. \n"
20304  "\n"
20305  " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
20306  " the vectors for plotting. If scale = 0 then the scaling factor is\n"
20307  " automatically calculated for the data. If scale < 0 then the\n"
20308  " scaling factor is automatically calculated for the data and then\n"
20309  " multiplied by -\n"
20310  " scale. If scale > 0 then the scaling factor is set to scale. \n"
20311  "\n"
20312  " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
20313  " Pointer to function that defines transformation between indices\n"
20314  " in array z and the world coordinates (C only). Transformation\n"
20315  " functions are provided in the PLplot library: pltr0 for identity\n"
20316  " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
20317  " defined by one- and two-dimensional arrays. In addition,\n"
20318  " user-supplied routines for the transformation can be used as well.\n"
20319  " Examples of all of these approaches are given in the PLplot\n"
20320  " documentation. The transformation function should have the form\n"
20321  " given by any of pltr0, pltr1, or pltr2. \n"
20322  "\n"
20323  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20324  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20325  " externally supplied. \n"
20326  "\n"
20327  ""},
20328  { (char *)"plvpas", _wrap_plvpas, METH_VARARGS, (char *)"\n"
20329  "Specify viewport using coordinates and aspect ratio \n"
20330  "\n"
20331  "DESCRIPTION:\n"
20332  "\n"
20333  " Device-independent routine for setting up the viewport. The viewport\n"
20334  " is chosen to be the largest with the given aspect ratio that fits\n"
20335  " within the specified region (in terms of normalized subpage\n"
20336  " coordinates). This routine is functionally equivalent to plvpor when\n"
20337  " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
20338  " routine reserves no extra space at the edges for labels. \n"
20339  "\n"
20340  " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
20341  "\n"
20342  " This function is used in example 9. \n"
20343  "\n"
20344  "\n"
20345  "\n"
20346  "SYNOPSIS:\n"
20347  "\n"
20348  "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
20349  "\n"
20350  "ARGUMENTS:\n"
20351  "\n"
20352  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
20353  " left-hand edge of the viewport. \n"
20354  "\n"
20355  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
20356  " right-hand edge of the viewport. \n"
20357  "\n"
20358  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
20359  " bottom edge of the viewport. \n"
20360  "\n"
20361  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
20362  " edge of the viewport. \n"
20363  "\n"
20364  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
20365  " axis. \n"
20366  "\n"
20367  ""},
20368  { (char *)"plvpor", _wrap_plvpor, METH_VARARGS, (char *)"\n"
20369  "Specify viewport using coordinates \n"
20370  "\n"
20371  "DESCRIPTION:\n"
20372  "\n"
20373  " Device-independent routine for setting up the viewport. This defines\n"
20374  " the viewport in terms of normalized subpage coordinates which run from\n"
20375  " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
20376  " current subpage. Use the alternate routine plsvpa in order to create\n"
20377  " a viewport of a definite size. \n"
20378  "\n"
20379  " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
20380  "\n"
20381  " This function is used in examples\n"
20382  " 2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n"
20383  "\n"
20384  "\n"
20385  "\n"
20386  "SYNOPSIS:\n"
20387  "\n"
20388  "plvpor(xmin, xmax, ymin, ymax)\n"
20389  "\n"
20390  "ARGUMENTS:\n"
20391  "\n"
20392  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
20393  " left-hand edge of the viewport. \n"
20394  "\n"
20395  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
20396  " right-hand edge of the viewport. \n"
20397  "\n"
20398  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
20399  " bottom edge of the viewport. \n"
20400  "\n"
20401  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
20402  " edge of the viewport. \n"
20403  "\n"
20404  ""},
20405  { (char *)"plvsta", _wrap_plvsta, METH_VARARGS, (char *)"\n"
20406  "Select standard viewport \n"
20407  "\n"
20408  "DESCRIPTION:\n"
20409  "\n"
20410  " Sets up a standard viewport, leaving a left-hand margin of seven\n"
20411  " character heights, and four character heights around the other three\n"
20412  " sides. \n"
20413  "\n"
20414  " Redacted form: plvsta()\n"
20415  "\n"
20416  " This function is used in examples 1,12,14,17,25,29. \n"
20417  "\n"
20418  "\n"
20419  "\n"
20420  "SYNOPSIS:\n"
20421  "\n"
20422  "plvsta()\n"
20423  "\n"
20424  ""},
20425  { (char *)"plw3d", _wrap_plw3d, METH_VARARGS, (char *)"\n"
20426  "Set up window for 3-d plotting \n"
20427  "\n"
20428  "DESCRIPTION:\n"
20429  "\n"
20430  " Sets up a window for a three-dimensional surface plot within the\n"
20431  " currently defined two-dimensional window. The enclosing box for the\n"
20432  " surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n"
20433  " user-coordinate space is mapped into a box of world coordinate size\n"
20434  " basex by basey by height so that xmin maps to -\n"
20435  " basex/2, xmax maps to basex/2, ymin maps to -\n"
20436  " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
20437  " The resulting world-coordinate box is then viewed by an observer at\n"
20438  " altitude alt and azimuth az. This routine must be called before\n"
20439  " plbox3 or plot3d. For a more complete description of\n"
20440  " three-dimensional plotting see the PLplot documentation. \n"
20441  "\n"
20442  " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
20443  " zmin, zmax, alt, az)\n"
20444  "\n"
20445  " This function is examples 8,11,18,21. \n"
20446  "\n"
20447  "\n"
20448  "\n"
20449  "SYNOPSIS:\n"
20450  "\n"
20451  "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
20452  "\n"
20453  "ARGUMENTS:\n"
20454  "\n"
20455  " basex (PLFLT, input) : The x coordinate size of the\n"
20456  " world-coordinate box. \n"
20457  "\n"
20458  " basey (PLFLT, input) : The y coordinate size of the\n"
20459  " world-coordinate box. \n"
20460  "\n"
20461  " height (PLFLT, input) : The z coordinate size of the\n"
20462  " world-coordinate box. \n"
20463  "\n"
20464  " xmin (PLFLT, input) : The minimum user x coordinate value. \n"
20465  "\n"
20466  " xmax (PLFLT, input) : The maximum user x coordinate value. \n"
20467  "\n"
20468  " ymin (PLFLT, input) : The minimum user y coordinate value. \n"
20469  "\n"
20470  " ymax (PLFLT, input) : The maximum user y coordinate value. \n"
20471  "\n"
20472  " zmin (PLFLT, input) : The minimum user z coordinate value. \n"
20473  "\n"
20474  " zmax (PLFLT, input) : The maximum user z coordinate value. \n"
20475  "\n"
20476  " alt (PLFLT, input) : The viewing altitude in degrees above the XY\n"
20477  " plane. \n"
20478  "\n"
20479  " az (PLFLT, input) : The viewing azimuth in degrees. When az=0, the\n"
20480  " observer is looking face onto the ZX plane, and as az is\n"
20481  " increased, the observer moves clockwise around the box when viewed\n"
20482  " from above the XY plane. \n"
20483  "\n"
20484  ""},
20485  { (char *)"plwidth", _wrap_plwidth, METH_VARARGS, (char *)"\n"
20486  "Set pen width \n"
20487  "\n"
20488  "DESCRIPTION:\n"
20489  "\n"
20490  " Sets the pen width. \n"
20491  "\n"
20492  " Redacted form: plwidth(width)\n"
20493  "\n"
20494  " This function is used in examples 1,2. \n"
20495  "\n"
20496  "\n"
20497  "\n"
20498  "SYNOPSIS:\n"
20499  "\n"
20500  "plwidth(width)\n"
20501  "\n"
20502  "ARGUMENTS:\n"
20503  "\n"
20504  " width (PLINT, input) : The desired pen width. If width is negative\n"
20505  " or the same as the previous value no action is taken. width = 0\n"
20506  " should be interpreted as as the minimum valid pen width for the\n"
20507  " device. The interpretation of positive width values is also\n"
20508  " device dependent. \n"
20509  "\n"
20510  ""},
20511  { (char *)"plwind", _wrap_plwind, METH_VARARGS, (char *)"\n"
20512  "Specify world coordinates of viewport boundaries \n"
20513  "\n"
20514  "DESCRIPTION:\n"
20515  "\n"
20516  " Sets up the world coordinates of the edges of the viewport. \n"
20517  "\n"
20518  " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
20519  "\n"
20520  " This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n"
20521  "\n"
20522  "\n"
20523  "\n"
20524  "SYNOPSIS:\n"
20525  "\n"
20526  "plwind(xmin, xmax, ymin, ymax)\n"
20527  "\n"
20528  "ARGUMENTS:\n"
20529  "\n"
20530  " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
20531  " of the viewport. \n"
20532  "\n"
20533  " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
20534  " of the viewport. \n"
20535  "\n"
20536  " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
20537  " the viewport. \n"
20538  "\n"
20539  " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
20540  " viewport. \n"
20541  "\n"
20542  ""},
20543  { (char *)"plxormod", _wrap_plxormod, METH_VARARGS, (char *)"\n"
20544  "Enter or leave xor mode \n"
20545  "\n"
20546  "DESCRIPTION:\n"
20547  "\n"
20548  " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
20549  " those drivers (e.g., the xwin driver) that support it. Enables\n"
20550  " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
20551  " is not capable of xor operation it returns a status of false. \n"
20552  "\n"
20553  " Redacted form: plxormod(mode, status)\n"
20554  "\n"
20555  " This function is used in examples 1,20. \n"
20556  "\n"
20557  "\n"
20558  "\n"
20559  "SYNOPSIS:\n"
20560  "\n"
20561  "plxormod(mode, status)\n"
20562  "\n"
20563  "ARGUMENTS:\n"
20564  "\n"
20565  " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
20566  " is false means leave xor mode. \n"
20567  "\n"
20568  " status (PLBOOL *, output) : Pointer to status. Returned modestatus\n"
20569  " of true (false) means driver is capable (incapable) of xor mode. \n"
20570  "\n"
20571  ""},
20572  { (char *)"plmap", _wrap_plmap, METH_VARARGS, (char *)"\n"
20573  "Plot continental outline in world coordinates. \n"
20574  "\n"
20575  "DESCRIPTION:\n"
20576  "\n"
20577  " Plots continental outlines in world coordinates. examples/c/x19c\n"
20578  " demonstrates how to use this function to create different\n"
20579  " projections. \n"
20580  "\n"
20581  " Redacted form: General: plmap(mapform, type, minlong, maxlong,\n"
20582  " minlat, maxlat)\n"
20583  " F95, Java, Perl/PDL, Python: Not implemented? \n"
20584  "\n"
20585  "\n"
20586  " This function is used in example 19. \n"
20587  "\n"
20588  "\n"
20589  "\n"
20590  "SYNOPSIS:\n"
20591  "\n"
20592  "plmap(mapform, type, minlong, maxlong, minlat, maxlat)\n"
20593  "\n"
20594  "ARGUMENTS:\n"
20595  "\n"
20596  " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
20597  " supplied function to transform the coordinate longitudes and\n"
20598  " latitudes to a plot coordinate system. By using this transform,\n"
20599  " we can change from a longitude, latitude coordinate to a polar\n"
20600  " stereographic project, for example. Initially, x[0]..[n-1] are\n"
20601  " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
20602  " After the call to mapform(), x[] and y[] should be replaced by\n"
20603  " the corresponding plot coordinates. If no transform is desired,\n"
20604  " mapform can be replaced by NULL. \n"
20605  "\n"
20606  " type (char *, input) : type is a character string. The value of\n"
20607  " this parameter determines the type of background. The possible\n"
20608  " values are: \"globe\" -- continental outlines \n"
20609  " \"usa\" -- USA and state boundaries \n"
20610  " \"cglobe\" -- continental outlines and countries \n"
20611  " \"usaglobe\" -- USA, state boundaries and continental outlines \n"
20612  "\n"
20613  "\n"
20614  " minlong (PLFLT, input) : The value of the longitude on the left\n"
20615  " side of the plot. The value of minlong must be less than the\n"
20616  " value of maxlong, and the quantity maxlong-minlong must be less\n"
20617  " than or equal to 360. \n"
20618  "\n"
20619  " maxlong (PLFLT, input) : The value of the longitude on the right\n"
20620  " side of the plot. \n"
20621  "\n"
20622  " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
20623  " background. One can always use -90.0 as the boundary outside the\n"
20624  " plot window will be automatically eliminated. However, the\n"
20625  " program will be faster if one can reduce the size of the\n"
20626  " background plotted. \n"
20627  "\n"
20628  " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
20629  " background. One can always use 90.0 as the boundary outside the\n"
20630  " plot window will be automatically eliminated. \n"
20631  "\n"
20632  ""},
20633  { (char *)"plmeridians", _wrap_plmeridians, METH_VARARGS, (char *)"\n"
20634  "Plot latitude and longitude lines. \n"
20635  "\n"
20636  "DESCRIPTION:\n"
20637  "\n"
20638  " Displays latitude and longitude on the current plot. The lines are\n"
20639  " plotted in the current color and line style. \n"
20640  "\n"
20641  " Redacted form: General: plmeridians(mapform, dlong, dlat, minlong,\n"
20642  " maxlong, minlat, maxlat)\n"
20643  " F95, Java, Perl/PDL, Python: Not implemented? \n"
20644  "\n"
20645  "\n"
20646  " This function is used in example 19. \n"
20647  "\n"
20648  "\n"
20649  "\n"
20650  "SYNOPSIS:\n"
20651  "\n"
20652  "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
20653  "\n"
20654  "ARGUMENTS:\n"
20655  "\n"
20656  " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
20657  " supplied function to transform the coordinate longitudes and\n"
20658  " latitudes to a plot coordinate system. By using this transform,\n"
20659  " we can change from a longitude, latitude coordinate to a polar\n"
20660  " stereographic project, for example. Initially, x[0]..[n-1] are\n"
20661  " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
20662  " After the call to mapform(), x[] and y[] should be replaced by\n"
20663  " the corresponding plot coordinates. If no transform is desired,\n"
20664  " mapform can be replaced by NULL. \n"
20665  "\n"
20666  " dlong (PLFLT, input) : The interval in degrees at which the\n"
20667  " longitude lines are to be plotted. \n"
20668  "\n"
20669  " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
20670  " lines are to be plotted. \n"
20671  "\n"
20672  " minlong (PLFLT, input) : The value of the longitude on the left\n"
20673  " side of the plot. The value of minlong must be less than the\n"
20674  " value of maxlong, and the quantity maxlong-minlong must be less\n"
20675  " than or equal to 360. \n"
20676  "\n"
20677  " maxlong (PLFLT, input) : The value of the longitude on the right\n"
20678  " side of the plot. \n"
20679  "\n"
20680  " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
20681  " background. One can always use -90.0 as the boundary outside the\n"
20682  " plot window will be automatically eliminated. However, the\n"
20683  " program will be faster if one can reduce the size of the\n"
20684  " background plotted. \n"
20685  "\n"
20686  " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
20687  " background. One can always use 90.0 as the boundary outside the\n"
20688  " plot window will be automatically eliminated. \n"
20689  "\n"
20690  ""},
20691  { (char *)"plimage", _wrap_plimage, METH_VARARGS, (char *)"\n"
20692  "Plot a 2D matrix using color map1 with automatic colour adjustment \n"
20693  "\n"
20694  "DESCRIPTION:\n"
20695  "\n"
20696  " Plot a 2D matrix using color palette 1. The color scale is\n"
20697  " automatically adjusted to use the maximum and minimum values in idata\n"
20698  " as valuemin and valuemax in a call to plimagefr. \n"
20699  "\n"
20700  " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
20701  " zmax, Dxmin, Dxmax, Dymin, Dymax) \n"
20702  "\n"
20703  "\n"
20704  " This function is used in example 20. \n"
20705  "\n"
20706  "\n"
20707  "\n"
20708  "SYNOPSIS:\n"
20709  "\n"
20710  "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
20711  "\n"
20712  "ARGUMENTS:\n"
20713  "\n"
20714  " idata (PLFLT**, input) : A 2D array of values (intensities) to\n"
20715  " plot. Should have dimensions idata[nx][ny]. \n"
20716  "\n"
20717  " nx, ny (PLINT, input) : Dimensions of idata \n"
20718  "\n"
20719  " xmin, xmax, ymin, ymax (PLFLT, input) : Plot coordinates to strecth\n"
20720  " the image data to. idata[0][0] corresponds to (xmin, ymin) and\n"
20721  " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
20722  "\n"
20723  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
20724  " (inclusive) will be plotted. \n"
20725  "\n"
20726  " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
20727  " points whose plot coordinates fall inside the window of (Dxmin,\n"
20728  " Dymin) to (Dxmax, Dymax). \n"
20729  "\n"
20730  ""},
20731  { (char *)"plimagefr", _wrap_plimagefr, METH_VARARGS, (char *)"\n"
20732  "Plot a 2D matrix using color map1 \n"
20733  "\n"
20734  "DESCRIPTION:\n"
20735  "\n"
20736  " Plot a 2D matrix using color map1. \n"
20737  "\n"
20738  " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax,\n"
20739  " zmin, zmax, valuemin, valuemax, pltr, pltr_data) \n"
20740  "\n"
20741  "\n"
20742  " This function is used in example 20. \n"
20743  "\n"
20744  "\n"
20745  "\n"
20746  "SYNOPSIS:\n"
20747  "\n"
20748  "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
20749  "\n"
20750  "ARGUMENTS:\n"
20751  "\n"
20752  " idata (PLFLT**, input) : A 2D array of values (intensities) to\n"
20753  " plot. Should have dimensions idata[nx][ny]. \n"
20754  "\n"
20755  " nx, ny (PLINT, input) : Dimensions of idata \n"
20756  "\n"
20757  " xmin, xmax, ymin, ymax (PLFLT, input) : Stretch image data to these\n"
20758  " Plot coordinates. idata[0][0] corresponds to (xmin, ymin) and\n"
20759  " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
20760  "\n"
20761  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
20762  " (inclusive) will be plotted. \n"
20763  "\n"
20764  " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
20765  " values to use for value to color mappings. A datum equal to or\n"
20766  " less than valuemin will be plotted with color 0.0, while a datum\n"
20767  " equal to or greater than valuemax will be plotted with color 1.0. \n"
20768  " Data between valuemin and valuemax map linearly to colors between\n"
20769  " 0.0 and 1.0. \n"
20770  "\n"
20771  " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
20772  " Pointer to function that defines a transformation between the\n"
20773  " data in the array idata and world coordinates. An input\n"
20774  " coordinate of (0, 0) corresponds to the \"top-left\" corner of idata\n"
20775  " while (nx, ny) corresponds to the \"bottom-right\" corner of idata. \n"
20776  " Some transformation functions are provided in the PLplot library:\n"
20777  " pltr0 for identity mapping, and pltr1 and pltr2 for arbitrary\n"
20778  " mappings respectively defined by one- and two-dimensional arrays. \n"
20779  " In addition, user-supplied routines for the transformation can be\n"
20780  " used as well. Examples of all of these approaches are given in\n"
20781  " the PLplot documentation. The transformation function should have\n"
20782  " the form given by any of pltr0, pltr1, or pltr2. \n"
20783  "\n"
20784  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20785  " information to pltr0, pltr1, pltr2, or whatever routine is\n"
20786  " externally supplied. \n"
20787  "\n"
20788  ""},
20789  { (char *)"plClearOpts", _wrap_plClearOpts, METH_VARARGS, NULL},
20790  { (char *)"plResetOpts", _wrap_plResetOpts, METH_VARARGS, NULL},
20791  { (char *)"plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
20792  { (char *)"plOptUsage", _wrap_plOptUsage, METH_VARARGS, NULL},
20793  { (char *)"plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_VARARGS, NULL},
20794  { (char *)"plGetCursor", _wrap_plGetCursor, METH_VARARGS, NULL},
20795  { NULL, NULL, 0, NULL }
20796 };
20797 
20798 
20799 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20800 
20801 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
20802 static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
20803 static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
20804 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
20805 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
20806 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};
20807 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};
20808 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};
20809 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};
20810 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};
20811 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
20812 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
20813 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
20814 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
20815 
20820  &_swigt__p_char,
20827  &_swigt__p_int,
20831 };
20832 
20833 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
20834 static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
20835 static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
20836 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
20837 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
20843 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
20844 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
20845 static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
20846 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
20847 
20859  _swigc__p_int,
20863 };
20864 
20865 
20866 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
20867 
20869 {0, 0, 0, 0.0, 0, 0}};
20870 
20871 #ifdef __cplusplus
20872 }
20873 #endif
20874 /* -----------------------------------------------------------------------------
20875  * Type initialization:
20876  * This problem is tough by the requirement that no dynamic
20877  * memory is used. Also, since swig_type_info structures store pointers to
20878  * swig_cast_info structures and swig_cast_info structures store pointers back
20879  * to swig_type_info structures, we need some lookup code at initialization.
20880  * The idea is that swig generates all the structures that are needed.
20881  * The runtime then collects these partially filled structures.
20882  * The SWIG_InitializeModule function takes these initial arrays out of
20883  * swig_module, and does all the lookup, filling in the swig_module.types
20884  * array with the correct data and linking the correct swig_cast_info
20885  * structures together.
20886  *
20887  * The generated swig_type_info structures are assigned staticly to an initial
20888  * array. We just loop through that array, and handle each type individually.
20889  * First we lookup if this type has been already loaded, and if so, use the
20890  * loaded structure instead of the generated one. Then we have to fill in the
20891  * cast linked list. The cast data is initially stored in something like a
20892  * two-dimensional array. Each row corresponds to a type (there are the same
20893  * number of rows as there are in the swig_type_initial array). Each entry in
20894  * a column is one of the swig_cast_info structures for that type.
20895  * The cast_initial array is actually an array of arrays, because each row has
20896  * a variable number of columns. So to actually build the cast linked list,
20897  * we find the array of casts associated with the type, and loop through it
20898  * adding the casts to the list. The one last trick we need to do is making
20899  * sure the type pointer in the swig_cast_info struct is correct.
20900  *
20901  * First off, we lookup the cast->type name to see if it is already loaded.
20902  * There are three cases to handle:
20903  * 1) If the cast->type has already been loaded AND the type we are adding
20904  * casting info to has not been loaded (it is in this module), THEN we
20905  * replace the cast->type pointer with the type pointer that has already
20906  * been loaded.
20907  * 2) If BOTH types (the one we are adding casting info to, and the
20908  * cast->type) are loaded, THEN the cast info has already been loaded by
20909  * the previous module so we just ignore it.
20910  * 3) Finally, if cast->type has not already been loaded, then we add that
20911  * swig_cast_info to the linked list (because the cast->type) pointer will
20912  * be correct.
20913  * ----------------------------------------------------------------------------- */
20914 
20915 #ifdef __cplusplus
20916 extern "C" {
20917 #if 0
20918 } /* c-mode */
20919 #endif
20920 #endif
20921 
20922 #if 0
20923 #define SWIGRUNTIME_DEBUG
20924 #endif
20925 
20926 
20927 SWIGRUNTIME void
20928 SWIG_InitializeModule(void *clientdata) {
20929  size_t i;
20930  swig_module_info *module_head, *iter;
20931  int found, init;
20932 
20933  /* check to see if the circular list has been setup, if not, set it up */
20934  if (swig_module.next==0) {
20935  /* Initialize the swig_module */
20936  swig_module.type_initial = swig_type_initial;
20937  swig_module.cast_initial = swig_cast_initial;
20938  swig_module.next = &swig_module;
20939  init = 1;
20940  } else {
20941  init = 0;
20942  }
20943 
20944  /* Try and load any already created modules */
20945  module_head = SWIG_GetModule(clientdata);
20946  if (!module_head) {
20947  /* This is the first module loaded for this interpreter */
20948  /* so set the swig module into the interpreter */
20949  SWIG_SetModule(clientdata, &swig_module);
20950  module_head = &swig_module;
20951  } else {
20952  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
20953  found=0;
20954  iter=module_head;
20955  do {
20956  if (iter==&swig_module) {
20957  found=1;
20958  break;
20959  }
20960  iter=iter->next;
20961  } while (iter!= module_head);
20962 
20963  /* if the is found in the list, then all is done and we may leave */
20964  if (found) return;
20965  /* otherwise we must add out module into the list */
20966  swig_module.next = module_head->next;
20967  module_head->next = &swig_module;
20968  }
20969 
20970  /* When multiple interpreters are used, a module could have already been initialized in
20971  a different interpreter, but not yet have a pointer in this interpreter.
20972  In this case, we do not want to continue adding types... everything should be
20973  set up already */
20974  if (init == 0) return;
20975 
20976  /* Now work on filling in swig_module.types */
20977 #ifdef SWIGRUNTIME_DEBUG
20978  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
20979 #endif
20980  for (i = 0; i < swig_module.size; ++i) {
20981  swig_type_info *type = 0;
20982  swig_type_info *ret;
20983  swig_cast_info *cast;
20984 
20985 #ifdef SWIGRUNTIME_DEBUG
20986  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
20987 #endif
20988 
20989  /* if there is another module already loaded */
20990  if (swig_module.next != &swig_module) {
20991  type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
20992  }
20993  if (type) {
20994  /* Overwrite clientdata field */
20995 #ifdef SWIGRUNTIME_DEBUG
20996  printf("SWIG_InitializeModule: found type %s\n", type->name);
20997 #endif
20998  if (swig_module.type_initial[i]->clientdata) {
20999  type->clientdata = swig_module.type_initial[i]->clientdata;
21000 #ifdef SWIGRUNTIME_DEBUG
21001  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
21002 #endif
21003  }
21004  } else {
21005  type = swig_module.type_initial[i];
21006  }
21007 
21008  /* Insert casting types */
21009  cast = swig_module.cast_initial[i];
21010  while (cast->type) {
21011  /* Don't need to add information already in the list */
21012  ret = 0;
21013 #ifdef SWIGRUNTIME_DEBUG
21014  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
21015 #endif
21016  if (swig_module.next != &swig_module) {
21017  ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
21018 #ifdef SWIGRUNTIME_DEBUG
21019  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
21020 #endif
21021  }
21022  if (ret) {
21023  if (type == swig_module.type_initial[i]) {
21024 #ifdef SWIGRUNTIME_DEBUG
21025  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
21026 #endif
21027  cast->type = ret;
21028  ret = 0;
21029  } else {
21030  /* Check for casting already in the list */
21031  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
21032 #ifdef SWIGRUNTIME_DEBUG
21033  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
21034 #endif
21035  if (!ocast) ret = 0;
21036  }
21037  }
21038 
21039  if (!ret) {
21040 #ifdef SWIGRUNTIME_DEBUG
21041  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
21042 #endif
21043  if (type->cast) {
21044  type->cast->prev = cast;
21045  cast->next = type->cast;
21046  }
21047  type->cast = cast;
21048  }
21049  cast++;
21050  }
21051  /* Set entry in modules->types array equal to the type */
21052  swig_module.types[i] = type;
21053  }
21054  swig_module.types[i] = 0;
21055 
21056 #ifdef SWIGRUNTIME_DEBUG
21057  printf("**** SWIG_InitializeModule: Cast List ******\n");
21058  for (i = 0; i < swig_module.size; ++i) {
21059  int j = 0;
21060  swig_cast_info *cast = swig_module.cast_initial[i];
21061  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
21062  while (cast->type) {
21063  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
21064  cast++;
21065  ++j;
21066  }
21067  printf("---- Total casts: %d\n",j);
21068  }
21069  printf("**** SWIG_InitializeModule: Cast List ******\n");
21070 #endif
21071 }
21072 
21073 /* This function will propagate the clientdata field of type to
21074 * any new swig_type_info structures that have been added into the list
21075 * of equivalent types. It is like calling
21076 * SWIG_TypeClientData(type, clientdata) a second time.
21077 */
21078 SWIGRUNTIME void
21080  size_t i;
21081  swig_cast_info *equiv;
21082  static int init_run = 0;
21083 
21084  if (init_run) return;
21085  init_run = 1;
21086 
21087  for (i = 0; i < swig_module.size; i++) {
21088  if (swig_module.types[i]->clientdata) {
21089  equiv = swig_module.types[i]->cast;
21090  while (equiv) {
21091  if (!equiv->converter) {
21092  if (equiv->type && !equiv->type->clientdata)
21093  SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
21094  }
21095  equiv = equiv->next;
21096  }
21097  }
21098  }
21099 }
21100 
21101 #ifdef __cplusplus
21102 #if 0
21103 {
21104  /* c-mode */
21105 #endif
21106 }
21107 #endif
21108 
21109 
21110 
21111 #ifdef __cplusplus
21112 extern "C" {
21113 #endif
21114 
21115  /* Python-specific SWIG API */
21116 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21117 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21118 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21119 
21120  /* -----------------------------------------------------------------------------
21121  * global variable support code.
21122  * ----------------------------------------------------------------------------- */
21123 
21124  typedef struct swig_globalvar {
21125  char *name; /* Name of global variable */
21126  PyObject *(*get_attr)(void); /* Return the current value */
21127  int (*set_attr)(PyObject *); /* Set the value */
21129  } swig_globalvar;
21130 
21131  typedef struct swig_varlinkobject {
21132  PyObject_HEAD
21135 
21136  SWIGINTERN PyObject *
21138 #if PY_VERSION_HEX >= 0x03000000
21139  return PyUnicode_InternFromString("<Swig global variables>");
21140 #else
21141  return PyString_FromString("<Swig global variables>");
21142 #endif
21143  }
21144 
21145  SWIGINTERN PyObject *
21147 #if PY_VERSION_HEX >= 0x03000000
21148  PyObject *str = PyUnicode_InternFromString("(");
21149  PyObject *tail;
21150  PyObject *joined;
21151  swig_globalvar *var;
21152  for (var = v->vars; var; var=var->next) {
21153  tail = PyUnicode_FromString(var->name);
21154  joined = PyUnicode_Concat(str, tail);
21155  Py_DecRef(str);
21156  Py_DecRef(tail);
21157  str = joined;
21158  if (var->next) {
21159  tail = PyUnicode_InternFromString(", ");
21160  joined = PyUnicode_Concat(str, tail);
21161  Py_DecRef(str);
21162  Py_DecRef(tail);
21163  str = joined;
21164  }
21165  }
21166  tail = PyUnicode_InternFromString(")");
21167  joined = PyUnicode_Concat(str, tail);
21168  Py_DecRef(str);
21169  Py_DecRef(tail);
21170  str = joined;
21171 #else
21172  PyObject *str = PyString_FromString("(");
21173  swig_globalvar *var;
21174  for (var = v->vars; var; var=var->next) {
21175  PyString_ConcatAndDel(&str,PyString_FromString(var->name));
21176  if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
21177  }
21178  PyString_ConcatAndDel(&str,PyString_FromString(")"));
21179 #endif
21180  return str;
21181  }
21182 
21183  SWIGINTERN int
21185  char *tmp;
21186  PyObject *str = swig_varlink_str(v);
21187  fprintf(fp,"Swig global variables ");
21188  fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
21190  Py_DECREF(str);
21191  return 0;
21192  }
21193 
21194  SWIGINTERN void
21196  swig_globalvar *var = v->vars;
21197  while (var) {
21198  swig_globalvar *n = var->next;
21199  free(var->name);
21200  free(var);
21201  var = n;
21202  }
21203  }
21204 
21205  SWIGINTERN PyObject *
21207  PyObject *res = NULL;
21208  swig_globalvar *var = v->vars;
21209  while (var) {
21210  if (strcmp(var->name,n) == 0) {
21211  res = (*var->get_attr)();
21212  break;
21213  }
21214  var = var->next;
21215  }
21216  if (res == NULL && !PyErr_Occurred()) {
21217  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21218  }
21219  return res;
21220  }
21221 
21222  SWIGINTERN int
21223  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
21224  int res = 1;
21225  swig_globalvar *var = v->vars;
21226  while (var) {
21227  if (strcmp(var->name,n) == 0) {
21228  res = (*var->set_attr)(p);
21229  break;
21230  }
21231  var = var->next;
21232  }
21233  if (res == 1 && !PyErr_Occurred()) {
21234  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21235  }
21236  return res;
21237  }
21238 
21239  SWIGINTERN PyTypeObject*
21241  static char varlink__doc__[] = "Swig var link object";
21242  static PyTypeObject varlink_type;
21243  static int type_init = 0;
21244  if (!type_init) {
21245  const PyTypeObject tmp = {
21246  /* PyObject header changed in Python 3 */
21247 #if PY_VERSION_HEX >= 0x03000000
21248  PyVarObject_HEAD_INIT(NULL, 0)
21249 #else
21250  PyObject_HEAD_INIT(NULL)
21251  0, /* ob_size */
21252 #endif
21253  (char *)"swigvarlink", /* tp_name */
21254  sizeof(swig_varlinkobject), /* tp_basicsize */
21255  0, /* tp_itemsize */
21256  (destructor) swig_varlink_dealloc, /* tp_dealloc */
21257  (printfunc) swig_varlink_print, /* tp_print */
21258  (getattrfunc) swig_varlink_getattr, /* tp_getattr */
21259  (setattrfunc) swig_varlink_setattr, /* tp_setattr */
21260  0, /* tp_compare */
21261  (reprfunc) swig_varlink_repr, /* tp_repr */
21262  0, /* tp_as_number */
21263  0, /* tp_as_sequence */
21264  0, /* tp_as_mapping */
21265  0, /* tp_hash */
21266  0, /* tp_call */
21267  (reprfunc) swig_varlink_str, /* tp_str */
21268  0, /* tp_getattro */
21269  0, /* tp_setattro */
21270  0, /* tp_as_buffer */
21271  0, /* tp_flags */
21272  varlink__doc__, /* tp_doc */
21273  0, /* tp_traverse */
21274  0, /* tp_clear */
21275  0, /* tp_richcompare */
21276  0, /* tp_weaklistoffset */
21277 #if PY_VERSION_HEX >= 0x02020000
21278  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
21279 #endif
21280 #if PY_VERSION_HEX >= 0x02030000
21281  0, /* tp_del */
21282 #endif
21283 #if PY_VERSION_HEX >= 0x02060000
21284  0, /* tp_version */
21285 #endif
21286 #ifdef COUNT_ALLOCS
21287  0,0,0,0 /* tp_alloc -> tp_next */
21288 #endif
21289  };
21290  varlink_type = tmp;
21291  type_init = 1;
21292 #if PY_VERSION_HEX < 0x02020000
21293  varlink_type.ob_type = &PyType_Type;
21294 #else
21295  if (PyType_Ready(&varlink_type) < 0)
21296  return NULL;
21297 #endif
21298  }
21299  return &varlink_type;
21300  }
21301 
21302  /* Create a variable linking object for use later */
21303  SWIGINTERN PyObject *
21305  swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
21306  if (result) {
21307  result->vars = 0;
21308  }
21309  return ((PyObject*) result);
21310  }
21311 
21312  SWIGINTERN void
21313  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
21315  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
21316  if (gv) {
21317  size_t size = strlen(name)+1;
21318  gv->name = (char *)malloc(size);
21319  if (gv->name) {
21320  strncpy(gv->name,name,size);
21321  gv->get_attr = get_attr;
21322  gv->set_attr = set_attr;
21323  gv->next = v->vars;
21324  }
21325  }
21326  v->vars = gv;
21327  }
21328 
21329  SWIGINTERN PyObject *
21331  static PyObject *_SWIG_globals = 0;
21332  if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
21333  return _SWIG_globals;
21334  }
21335 
21336  /* -----------------------------------------------------------------------------
21337  * constants/methods manipulation
21338  * ----------------------------------------------------------------------------- */
21339 
21340  /* Install Constants */
21341  SWIGINTERN void
21342  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
21343  PyObject *obj = 0;
21344  size_t i;
21345  for (i = 0; constants[i].type; ++i) {
21346  switch(constants[i].type) {
21347  case SWIG_PY_POINTER:
21348  obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
21349  break;
21350  case SWIG_PY_BINARY:
21351  obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21352  break;
21353  default:
21354  obj = 0;
21355  break;
21356  }
21357  if (obj) {
21358  PyDict_SetItemString(d, constants[i].name, obj);
21359  Py_DECREF(obj);
21360  }
21361  }
21362  }
21363 
21364  /* -----------------------------------------------------------------------------*/
21365  /* Fix SwigMethods to carry the callback ptrs when needed */
21366  /* -----------------------------------------------------------------------------*/
21367 
21368  SWIGINTERN void
21369  SWIG_Python_FixMethods(PyMethodDef *methods,
21370  swig_const_info *const_table,
21371  swig_type_info **types,
21372  swig_type_info **types_initial) {
21373  size_t i;
21374  for (i = 0; methods[i].ml_name; ++i) {
21375  const char *c = methods[i].ml_doc;
21376  if (c && (c = strstr(c, "swig_ptr: "))) {
21377  int j;
21378  swig_const_info *ci = 0;
21379  const char *name = c + 10;
21380  for (j = 0; const_table[j].type; ++j) {
21381  if (strncmp(const_table[j].name, name,
21382  strlen(const_table[j].name)) == 0) {
21383  ci = &(const_table[j]);
21384  break;
21385  }
21386  }
21387  if (ci) {
21388  void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
21389  if (ptr) {
21390  size_t shift = (ci->ptype) - types;
21391  swig_type_info *ty = types_initial[shift];
21392  size_t ldoc = (c - methods[i].ml_doc);
21393  size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
21394  char *ndoc = (char*)malloc(ldoc + lptr + 10);
21395  if (ndoc) {
21396  char *buff = ndoc;
21397  strncpy(buff, methods[i].ml_doc, ldoc);
21398  buff += ldoc;
21399  strncpy(buff, "swig_ptr: ", 10);
21400  buff += 10;
21401  SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
21402  methods[i].ml_doc = ndoc;
21403  }
21404  }
21405  }
21406  }
21407  }
21408  }
21409 
21410 #ifdef __cplusplus
21411 }
21412 #endif
21413 
21414 /* -----------------------------------------------------------------------------*
21415  * Partial Init method
21416  * -----------------------------------------------------------------------------*/
21417 
21418 #ifdef __cplusplus
21419 extern "C"
21420 #endif
21421 
21422 SWIGEXPORT
21423 #if PY_VERSION_HEX >= 0x03000000
21424 PyObject*
21425 #else
21426 void
21427 #endif
21428 SWIG_init(void) {
21429  PyObject *m, *d, *md;
21430 #if PY_VERSION_HEX >= 0x03000000
21431  static struct PyModuleDef SWIG_module = {
21432 # if PY_VERSION_HEX >= 0x03020000
21433  PyModuleDef_HEAD_INIT,
21434 # else
21435  {
21436  PyObject_HEAD_INIT(NULL)
21437  NULL, /* m_init */
21438  0, /* m_index */
21439  NULL, /* m_copy */
21440  },
21441 # endif
21442  (char *) SWIG_name,
21443  NULL,
21444  -1,
21445  SwigMethods,
21446  NULL,
21447  NULL,
21448  NULL,
21449  NULL
21450  };
21451 #endif
21452 
21453 #if defined(SWIGPYTHON_BUILTIN)
21454  static SwigPyClientData SwigPyObject_clientdata = {
21455  0, 0, 0, 0, 0, 0, 0
21456  };
21457  static PyGetSetDef this_getset_def = {
21458  (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
21459  };
21460  static SwigPyGetSet thisown_getset_closure = {
21461  (PyCFunction) SwigPyObject_own,
21462  (PyCFunction) SwigPyObject_own
21463  };
21464  static PyGetSetDef thisown_getset_def = {
21465  (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
21466  };
21467  PyObject *metatype_args;
21468  PyTypeObject *builtin_pytype;
21469  int builtin_base_count;
21470  swig_type_info *builtin_basetype;
21471  PyObject *tuple;
21472  PyGetSetDescrObject *static_getset;
21473  PyTypeObject *metatype;
21474  SwigPyClientData *cd;
21475  PyObject *public_interface, *public_symbol;
21476  PyObject *this_descr;
21477  PyObject *thisown_descr;
21478  int i;
21479 
21480  (void)builtin_pytype;
21481  (void)builtin_base_count;
21482  (void)builtin_basetype;
21483  (void)tuple;
21484  (void)static_getset;
21485 
21486  /* metatype is used to implement static member variables. */
21487  metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
21488  assert(metatype_args);
21489  metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
21490  assert(metatype);
21491  Py_DECREF(metatype_args);
21492  metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
21493  assert(PyType_Ready(metatype) >= 0);
21494 #endif
21495 
21496  /* Fix SwigMethods to carry the callback ptrs when needed */
21497  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
21498 
21499 #if PY_VERSION_HEX >= 0x03000000
21500  m = PyModule_Create(&SWIG_module);
21501 #else
21502  m = Py_InitModule((char *) SWIG_name, SwigMethods);
21503 #endif
21504  md = d = PyModule_GetDict(m);
21505  (void)md;
21506 
21508 
21509 #ifdef SWIGPYTHON_BUILTIN
21510  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
21511  assert(SwigPyObject_stype);
21512  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
21513  if (!cd) {
21514  SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
21515  SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
21516  } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
21517  PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
21518 # if PY_VERSION_HEX >= 0x03000000
21519  return NULL;
21520 # else
21521  return;
21522 # endif
21523  }
21524 
21525  /* All objects have a 'this' attribute */
21526  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
21527  (void)this_descr;
21528 
21529  /* All objects have a 'thisown' attribute */
21530  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
21531  (void)thisown_descr;
21532 
21533  public_interface = PyList_New(0);
21534  public_symbol = 0;
21535  (void)public_symbol;
21536 
21537  PyDict_SetItemString(md, "__all__", public_interface);
21538  Py_DECREF(public_interface);
21539  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
21540  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
21541  for (i = 0; swig_const_table[i].name != 0; ++i)
21542  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
21543 #endif
21544 
21546 
21547 
21548  import_array();
21549 
21550  SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
21551  SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
21552  SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
21553  SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
21554  SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
21555  SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
21556  SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
21557  SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
21558  SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
21559  SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
21560  SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
21561  SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
21562  SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
21563  SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
21564  SWIG_Python_SetConstant(d, "PLESC_PLFLTBUFFERING",SWIG_From_int((int)(15)));
21565  SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
21566  SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
21567  SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
21568  SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
21569  SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
21570  SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
21571  SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
21572  SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x01)));
21573  SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x02)));
21574  SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x03)));
21575  SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x04)));
21576  SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x08)));
21577  SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x10)));
21578  SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x20)));
21579  SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x40)));
21580  SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x80)));
21581  SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
21582  SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0)));
21583  SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(1)));
21584  SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(2)));
21585  SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(4)));
21586  SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0)));
21587  SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(1)));
21588  SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(2)));
21589  SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(8)));
21590  SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(16)));
21591  SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(1)));
21592  SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(2)));
21593  SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(4)));
21594  SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(8)));
21595  SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(16)));
21596  SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(32)));
21597  SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(64)));
21598  SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(128)));
21599  SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(1)));
21600  SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(2)));
21601  SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(4)));
21602  SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(8)));
21603  SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(16)));
21604  SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(32)));
21605  SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(64)));
21606  SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(128)));
21607  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
21608  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
21609  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
21610  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
21611  SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
21612  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
21613  SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
21614  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
21615  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
21616  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
21617  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
21618  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
21619  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
21620  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
21621  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
21622  SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
21623  SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
21624  SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
21625  SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
21626  SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
21627  SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
21628  SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
21629  SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
21630  SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
21631  SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
21632  SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
21633  SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
21634  SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
21635  SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
21636  SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
21637  SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
21638  SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
21639  SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
21640  SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
21641  SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
21642  SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
21643  SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
21644  SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
21645  SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
21646  SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
21647  SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
21648  SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
21649  SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
21650  SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
21651  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
21652  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
21653  SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
21654  SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
21655  SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
21656  SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
21657  SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
21658  SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
21659  SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
21660  SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
21661  SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
21662  SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
21663  SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
21664  SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
21665  SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
21666  SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
21667  SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
21668  SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
21669  SWIG_Python_SetConstant(d, "PLESPLFLTBUFFERING_ENABLE",SWIG_From_int((int)(1)));
21670  SWIG_Python_SetConstant(d, "PLESPLFLTBUFFERING_DISABLE",SWIG_From_int((int)(2)));
21671  SWIG_Python_SetConstant(d, "PLESPLFLTBUFFERING_QUERY",SWIG_From_int((int)(3)));
21672  SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
21673  SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
21674  SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
21675  SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
21676  SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
21677  SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
21678 #if PY_VERSION_HEX >= 0x03000000
21679  return m;
21680 #else
21681  return;
21682 #endif
21683 }
21684 
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
intobjargproc ssizeobjargproc
subroutine plbox(xopt, xtick, nxsub, yopt, ytick, nysub)
Definition: sfstubs.f90:148
PyObject_HEAD void * ptr
#define SWIG_SetModule(clientdata, pointer)
#define plsfam
Definition: plplot.h:709
SWIGINTERN PyObject * _wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v)
#define plw3d
Definition: plplot.h:754
SWIGRUNTIMEINLINE const char * SwigPyObject_GetDesc(PyObject *self)
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * name
Definition: tkMain.c:131
#define SWIG_PY_POINTER
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void plimagefr(PLFLT **idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgxax
Definition: plplot.h:642
static PLcGrid tmpGrid1
#define SWIG_IsOK(r)
#define plsstrm
Definition: plplot.h:727
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void cleanup_PLPointer(void)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void cleanup_PLcGrid2(void)
#define PyObject_DEL
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_globalvar swig_globalvar
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plspage
Definition: plplot.h:723
PyObject_HEAD swig_globalvar * vars
SWIGINTERN PyObject * SwigPyObject_disown(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
#define plvpor
Definition: plplot.h:752
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
#define SWIG_IsNewObj(r)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_BUFFER_SIZE
#define SWIG_OverflowError
void do_ct_callback(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_Python_str_FromFormat
static swig_cast_info _swigc__p_char[]
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plerry
Definition: plplot.h:610
PLFLT * xg
Definition: plplot.h:428
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
#define plsyax
Definition: plplot.h:744
SWIGINTERN PyTypeObject * swig_varlink_type(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plschr
Definition: plplot.h:683
enum callback_type pltr_type
SWIGINTERN PyObject * SwigPyObject_own(PyObject *v, PyObject *args)
subroutine plmtex3(side, disp, pos, xjust, text)
Definition: sfstubs.f90:722
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
SWIGRUNTIME int SWIG_Python_ArgFail(int argnum)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyObject * swig_this
int min(int a, int b)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyObject * python_f2eval
#define PyObject_GenericGetAttr
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
subroutine plsfnam(fnam)
Definition: sfstubs.f90:92
static long PyNumber_AsSsize_t(PyObject *x, void *SWIGUNUSEDPARM(exc))
#define pllegend
Definition: plplot.h:653
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
#define SWIGTYPE_p_int
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGINTERNINLINE
void cleanup_ct(void)
#define PySequence_Size
#define SWIG_CAST_NEW_MEMORY
#define plshade
Definition: plplot.h:713
struct swig_globalvar * next
#define plscompression
Definition: plplot.h:699
#define SWIG_STATIC_POINTER(var)
#define plarc
Definition: plplot.h:588
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
PLUINT PLUNICODE
Definition: plplot.h:195
subroutine plstring3(x, y, z, string)
Definition: sfstubs.f90:327
intargfunc ssizeargfunc
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
static PLINT Xlen
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max)
static swig_type_info _swigt__p_char
static swig_cast_info _swigc__p_int[]
static swig_type_info _swigt__p_f_double_double__int
#define plot3dc
Definition: plplot.h:667
void do_mapform_callback(PLINT n, PLFLT *x, PLFLT *y)
void plgriddata(PLFLT *x, PLFLT *y, PLFLT *z, int npts, PLFLT *xg, int nptsx, PLFLT *yg, int nptsy, PLFLT **zg, int type, PLFLT data)
#define SWIGRUNTIME
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
#define t_output_helper
SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plot3dcl
Definition: plplot.h:668
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
inquiry lenfunc
static swig_type_info _swigt__p_PLcGrid
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
PyArrayObject * pltr_yg
SWIGRUNTIME int SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
#define pllsty
Definition: plplot.h:658
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsmin
Definition: plplot.h:720
#define plwind
Definition: plplot.h:757
SWIGINTERN PyObject * _wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plclear
Definition: plplot.h:596
#define plfill
Definition: plplot.h:612
#define plconfigtime
Definition: plplot.h:600
#define SWIG_ValueError
#define plsurf3dl
Definition: plplot.h:740
#define SWIG_name
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyObject_HEAD void * pack
void plimage(PLFLT **data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax)
#define plbtime
Definition: plplot.h:594
subroutine plmtex(side, disp, pos, xjust, text)
Definition: sfstubs.f90:705
#define pl_setcontlabelparam
Definition: plplot.h:586
#define SWIG_MemoryError
static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[]
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void do_pltr_callback(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscolbg
Definition: plplot.h:696
SWIGINTERN PyObject * swig_varlink_getattr(swig_varlinkobject *v, char *n)
intintargfunc ssizessizeargfunc
swig_dycast_func dcast
char string[PL_MAXKEY]
Definition: plplot.h:360
struct swig_cast_info * cast
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
#define plfont
Definition: plplot.h:615
SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
#define plstyl
Definition: plplot.h:738
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
void destroy(GtkWidget *widget, gpointer data)
Definition: gcw-lib.c:187
#define plpoly3
Definition: plplot.h:673
subroutine plstring(x, y, string)
Definition: sfstubs.f90:309
SWIGINTERNINLINE PyObject * SWIG_From_int(int value)
swig_type_info * type
SWIGINTERN PyObject * _wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
SWIGRUNTIME void SwigPyPacked_dealloc(PyObject *v)
#define SWIG_ArgError(r)
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module)
SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v)
#define plfontld
Definition: plplot.h:616
subroutine plgdev(dnam)
Definition: sfstubs.f90:80
#define SWIG_SystemError
#define plscolbga
Definition: plplot.h:697
SWIGRUNTIME void SWIG_Python_DestroyModule(void *vptr)
SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op)
SWIGRUNTIME PyObject * SwigPyObject_next(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
#define plbin
Definition: plplot.h:590
PLFLT * yg
Definition: plplot.h:428
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsdiori
Definition: plplot.h:703
static swig_type_info _swigt__p_p_char
#define SWIG_RuntimeError
#define Py_NotImplemented
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plparseopts
Definition: plplot.h:669
#define plsym
Definition: plplot.h:745
#define plscmap1
Definition: plplot.h:687
#define SWIG_as_voidptrptr(a)
#define plinit
Definition: plplot.h:650
void PLFLT PLINT PLINT PLFLT x
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
#define SWIGUNUSEDPARM(p)
#define plctime
Definition: plplot.h:603
#define plscmap1n
Definition: plplot.h:691
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plbop
Definition: plplot.h:591
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_f_double_double__int[]
SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj)
#define plsdiplt
Definition: plplot.h:704
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsvect
Definition: plplot.h:741
#define plscmap1a
Definition: plplot.h:688
#define plssub
Definition: plplot.h:728
static PLINT Alen
struct swig_varlinkobject swig_varlinkobject
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_PLGraphicsIn
#define SWIG_PYTHON_THREAD_END_BLOCK
void * PLPointer
Definition: plplot.h:201
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_unsigned_int[]
#define plmeshc
Definition: plplot.h:662
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgcompression
Definition: plplot.h:622
SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own)
#define plszax
Definition: plplot.h:746
#define SWIG_PY_BINARY
#define plvsta
Definition: plplot.h:753
SWIGINTERN PyObject * SWIG_Python_AppendOutput(PyObject *result, PyObject *obj)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyMappingMethods as_mapping
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define Py_TYPE(op)
SWIGRUNTIME PyTypeObject * SwigPyPacked_type(void)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty)
#define SWIG_IOError
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgpage
Definition: plplot.h:633
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsori
Definition: plplot.h:722
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void cleanup_pltr(void)
#define SWIG_Python_str_DelForPy3(x)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
#define plgdiplt
Definition: plplot.h:626
void cleanup_mapform(void)
#define SWIG_InternalNewPointerObj(ptr, type, flags)
#define plscmap0a
Definition: plplot.h:685
PLINT ny
Definition: plplot.h:441
#define PySequence_Fast_GET_ITEM
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plfamadv
Definition: plplot.h:611
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
subroutine plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)
Definition: sfstubs.f90:166
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plend
Definition: plplot.h:604
#define SWIGINTERN
#define SWIGTYPE_p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_long(PyObject *obj, long *val)
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void *(* swig_converter_func)(void *, int *)
#define plsmem
Definition: plplot.h:718
#define plmap
Definition: plplot.h:659
#define plgfont
Definition: plplot.h:631
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plend1
Definition: plplot.h:605
int PLINT
Definition: plplot.h:175
#define plenv0
Definition: plplot.h:607
SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj)
#define SWIG_RUNTIME_VERSION
#define plgdiori
Definition: plplot.h:625
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plshades
Definition: plplot.h:715
PLINT PLBOOL
Definition: plplot.h:198
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
#define SWIG_AddNewMask(r)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plssym
Definition: plplot.h:729
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
SWIGINTERN int SWIG_AsVal_char(PyObject *obj, char *val)
SWIGRUNTIME PyObject * SWIG_Python_ErrorType(int code)
#define pljoin
Definition: plplot.h:651
#define plgzax
Definition: plplot.h:644
static PLINT Ylen
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_NewPackedObj(ptr, sz, type)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgfam
Definition: plplot.h:628
SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLINT ny
Definition: plplot.h:429
#define plgdidev
Definition: plplot.h:624
SWIGRUNTIME PyObject * SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg)
#define SWIGRUNTIMEINLINE
#define SWIG_NewClientData(obj)
#define plstar
Definition: plplot.h:730
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
#define SWIG_GetModule(clientdata)
#define NPY_PLFLT
#define myArray_ContiguousFromObject
PyObject * python_ct
#define plcpstrm
Definition: plplot.h:602
static PyMethodDef swigobject_methods[]
#define plcalc_world
Definition: plplot.h:595
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
#define SWIGEXPORT
static swig_type_info _swigt__p_double
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGTYPE_p_double
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
SWIGRUNTIME void SWIG_PropagateClientData(void)
#define plhist
Definition: plplot.h:645
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type)
#define PyString_AsStringAndSize(obj, s, len)
SWIGRUNTIME PyTypeObject * SwigPyObject_TypeOnce(void)
SWIGINTERN PyObject * PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
#define SWIG_DelNewMask(r)
SWIGINTERN PyObject * _wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
#define plgchr
Definition: plplot.h:617
static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
struct swig_module_info * next
plGetCursor
Definition: plplotc.py:6962
#define plsdidev
Definition: plplot.h:701
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
plSetUsage
Definition: plplotc.py:6950
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plfill3
Definition: plplot.h:613
#define SWIG_PYBUFFER_SIZE
SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c)
#define plsmema
Definition: plplot.h:719
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
subroutine plgver(ver)
Definition: sfstubs.f90:117
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyPacked_TypeOnce(void)
void PLFLT PLINT PLINT PLFLT PLFLT y
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
getreadbufferproc readbufferproc
swig_converter_func converter
PLFLT ** xg
Definition: plplot.h:440
subroutine plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)
Definition: sfstubs.f90:130
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
#define plseed
Definition: plplot.h:706
plOptUsage
Definition: plplotc.py:6954
#define plstransform
Definition: plplot.h:732
#define plvect
Definition: plplot.h:750
SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty)
int(* set_attr)(PyObject *)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscmap1la
Definition: plplot.h:690
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_From_double
static swig_module_info swig_module
#define SWIG_TMPOBJ
#define SWIG_POINTER_DISOWN
#define plcont
Definition: plplot.h:601
#define plsxax
Definition: plplot.h:743
SWIGINTERNINLINE PyObject * SWIG_From_unsigned_SS_int(unsigned int value)
static swig_cast_info _swigc__p_PLcGrid[]
plClearOpts
Definition: plplotc.py:6942
subroutine plspal0(filename)
Definition: sfstubs.f90:676
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pleop
Definition: plplot.h:608
#define plmesh
Definition: plplot.h:661
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plhlsrgb
Definition: plplot.h:647
swig_type_info ** types
SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject *obj)
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void swig_varlink_dealloc(swig_varlinkobject *v)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsmaj
Definition: plplot.h:717
PLINT nx
Definition: plplot.h:441
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
destructor freefunc
SWIGRUNTIME int SWIG_Python_AddErrMesg(const char *mesg, int infront)
SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plcol1
Definition: plplot.h:598
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pllightsource
Definition: plplot.h:654
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
#define SWIG_exception_fail(code, msg)
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
pl_setcontlabelformat
Definition: tclgen_s.h:1
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pltext
Definition: plplot.h:747
static swig_cast_info _swigc__p_p_char[]
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_TYPE_TABLE_NAME
SWIGINTERN int SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
#define SWIG_ERROR
plMinMax2dGrid
Definition: plplotc.py:6958
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plwidth
Definition: plplot.h:756
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscol0a
Definition: plplot.h:695
#define SWIG_NewPointerObj(ptr, type, flags)
static swig_cast_info _swigc__p_double[]
subroutine plsetopt(opt, optarg)
Definition: sfstubs.f90:39
#define plsdiplz
Definition: plplot.h:705
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static char buf[200]
Definition: tclAPI.c:819
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyArrayObject * pltr_xg
SWIGRUNTIME PyObject * SwigPyPacked_str(SwigPyPacked *v)
static swig_type_info * swig_type_initial[]
#define plspause
Definition: plplot.h:726
subroutine plptex(x, y, dx, dy, xjust, text)
Definition: sfstubs.f90:739
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define plline3
Definition: plplot.h:657
#define plstripd
Definition: plplot.h:737
#define SWIG_MangledTypeQuery(name)
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define plgfci
Definition: plplot.h:629
#define plgspa
Definition: plplot.h:637
#define plgcolbg
Definition: plplot.h:620
#define plstripc
Definition: plplot.h:736
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
SWIGINTERN PyObject * swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v))
#define plstripa
Definition: plplot.h:735
void
Definition: f95/scstubs.c:588
SWIGRUNTIME PyObject * SwigPyObject_hex(SwigPyObject *v)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
subroutine plgfnam(fnam)
Definition: sfstubs.f90:105
PyObject *(* get_attr)(void)
#define SWIG_BUILTIN_TP_INIT
SWIGINTERN int swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p)
PyObject * python_mapform
SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char *mesg)
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
static swig_cast_info _swigc__p_PLGraphicsIn[]
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plvpas
Definition: plplot.h:751
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyMethodDef SwigMethods[]
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PySequenceMethods as_sequence
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op)
#define plsfont
Definition: plplot.h:712
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define PyInt_FromSize_t(x)
#define SWIG_ConvertPtr(obj, pptr, type, flags)
subroutine pllab(xlab, ylab, title)
Definition: sfstubs.f90:658
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata))
#define plpsty
Definition: plplot.h:675
#define PyOS_snprintf
#define SWIG_as_voidptr(a)
PLFLT ** yg
Definition: plplot.h:440
SWIGRUNTIMEINLINE PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
static PLFLT value(double n1, double n2, double hue)
Definition: plctrl.c:1203
#define plgvpd
Definition: plplot.h:640
#define plpoin
Definition: plplot.h:671
static swig_type_info _swigt__p_unsigned_int
#define plgvpw
Definition: plplot.h:641
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char *carray, size_t size)
struct swig_type_info swig_type_info
static swig_type_info _swigt__p_p_double
static swig_type_info _swigt__p_PLcGrid2
SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags)
subroutine plsdev(dnam)
Definition: sfstubs.f90:67
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_CheckState(r)
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_IndexError
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
int max(int a, int b)
#define SWIG_fail
pltr_func marshal_pltr(PyObject *input)
SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIMEINLINE PyObject * _SWIG_This(void)
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags)
getwritebufferproc writebufferproc
PLPointer marshal_PLPointer(PyObject *input, int isimg)
SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj)
PyObject * python_pltr
SWIGINTERN PyObject * _wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
intintobjargproc ssizessizeobjargproc
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
#define plmkstrm
Definition: plplot.h:663
float PLFLT
Definition: plplot.h:159
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscol0
Definition: plplot.h:694
#define SWIG_TypeQuery(name)
static swig_cast_info _swigc__p_PLcGrid2[]
#define plxormod
Definition: plplot.h:758
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_cast_info swig_cast_info
#define plflush
Definition: plplot.h:614
#define SWIG_AddCast(r)
#define plerrx
Definition: plplot.h:609
#define plgcol0a
Definition: plplot.h:619
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_TypeError
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgcolbga
Definition: plplot.h:621
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
SWIGINTERN PyObject * SWIG_globals(void)
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyObject * PyString_FromFormat(const char *fmt,...)
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_DivisionByZero
SWIGINTERN int SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
#define plgyax
Definition: plplot.h:643
SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own)
#define plsesc
Definition: plplot.h:707
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plenv
Definition: plplot.h:606
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PLcGrid2 tmpGrid2
SWIGINTERN PyObject * SWIG_Python_newvarlink(void)
struct swig_cast_info * next
SWIGINTERN int SWIG_AsVal_int(PyObject *obj, int *val)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define MY_BLOCK_THREADS
subroutine plspal1(filename, interpolate)
Definition: sfstubs.f90:690
#define plgcmap1_range
Definition: plplot.h:693
#define plcol0
Definition: plplot.h:597
SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args)
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_module_info swig_module_info
static swig_cast_info * swig_cast_initial[]
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
subroutine plstart(devname, nx, ny)
Definition: sfstubs.f90:769
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plglevel
Definition: plplot.h:632
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyObject * python_label
#define plpoin3
Definition: plplot.h:672
getsegcountproc segcountproc
#define plscmap0n
Definition: plplot.h:686
subroutine plptex3(x, y, z, dx, dy, dz, sx, sy, sz, xjust, text)
Definition: sfstubs.f90:754
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscolor
Definition: plplot.h:698
#define plsvpa
Definition: plplot.h:742
SWIGRUNTIME PyObject * SwigPyObject_format(const char *fmt, SwigPyObject *v)
#define SWIG_newvarlink()
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static tclMatrixXtnsnDescr * tail
Definition: tclMatrix.c:407
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plpat
Definition: plplot.h:670
#define plscmap1_range
Definition: plplot.h:692
#define SWIG_IsTmpObj(r)
struct swig_cast_info * prev
struct swig_const_info swig_const_info
#define plgcol0
Definition: plplot.h:618
#define SWIG_Python_CallFunctor(functor, obj)
SWIGINTERN int swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
getcharbufferproc charbufferproc
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
#define plreplot
Definition: plplot.h:679
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
swig_cast_info ** cast_initial
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val)
ct_func marshal_ct(PyObject *input)
#define SWIG_POINTER_NEW
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void cleanup_PLcGrid1(void)
SWIGRUNTIME PyObject * SwigPyObject_oct(SwigPyObject *v)
static swig_cast_info _swigc__p_p_double[]
#define plscmap1l
Definition: plplot.h:689
#define NPY_PLINT
SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val)
#define plprec
Definition: plplot.h:674
#define SWIG_OLDOBJ
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plline
Definition: plplot.h:655
SWIGINTERN int PyModule_AddObject(PyObject *m, char *name, PyObject *o)
SWIGRUNTIME PyObject * SWIG_This(void)
#define SWIG_InstallConstants(d, constants)
mapform_func marshal_mapform(PyObject *input)
SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData *data)
#define SWIG_init
#define SWIG_SyntaxError
#define plgradient
Definition: plplot.h:635
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
swig_type_info ** type_initial
#define MY_UNBLOCK_THREADS
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pladv
Definition: plplot.h:587
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
static swig_type_info _swigt__p_int
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
#define SWIG_AttributeError
#define plvasp
Definition: plplot.h:749
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_type_info *(* swig_dycast_func)(void **)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plrandd
Definition: plplot.h:678
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plmeridians
Definition: plplot.h:660
SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[])
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscmap0
Definition: plplot.h:684
static PyObject * PyBool_FromLong(long ok)
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgstrm
Definition: plplot.h:638
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
#define plsfci
Definition: plplot.h:710
static swig_type_info * swig_types[15]
#define SWIG_POINTER_OWN
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_append(PyObject *v, PyObject *next)
plResetOpts
Definition: plplotc.py:6946
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
subroutine pltimefmt(fmt)
Definition: sfstubs.f90:784
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plrgbhls
Definition: plplot.h:682
SWIGINTERN PyObject * _wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsurf3d
Definition: plplot.h:739
PLINT(* defined_func)(PLFLT, PLFLT)
void plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, const PLINT *label_opts, const char *const *label, PLINT n_axes, const char *const *axis_opts, const PLFLT *ticks, const PLINT *sub_ticks, const PLINT *n_values, const PLFLT *const *values) void my_plcolorbar(PLFLT *p_colorbar_width
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgra
Definition: plplot.h:634
#define SWIG_OK
SWIGINTERN PyObject * SwigPyObject_getattr(SwigPyObject *sobj, char *name)
#define plsdimap
Definition: plplot.h:702
#define SWIG_POINTER_NOSHADOW
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plot3d
Definition: plplot.h:666
SWIGINTERN PyObject * swig_varlink_str(swig_varlinkobject *v)
PyArrayObject * myIntArray_ContiguousFromObject(PyObject *in, int type, int mindims, int maxdims)
SWIGINTERN char * SWIG_Python_str_AsChar(PyObject *str)
#define plslabelfunc
Definition: plplot.h:716
static swig_const_info swig_const_table[]
PLINT nx
Definition: plplot.h:429
#define SWIG_NEWOBJ
#define SWIGTYPE_p_unsigned_int
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_POINTER_IMPLICIT_CONV