PLplot  5.15.0
plplotcPYTHON_wrap.c
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 4.0.2
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 
12 #ifndef SWIGPYTHON
13 #define SWIGPYTHON
14 #endif
15 
16 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
17 
18 /* -----------------------------------------------------------------------------
19  * This section contains generic SWIG labels for method/variable
20  * declarations/attributes, and other compiler dependent labels.
21  * ----------------------------------------------------------------------------- */
22 
23 /* template workaround for compilers that cannot correctly implement the C++ standard */
24 #ifndef SWIGTEMPLATEDISAMBIGUATOR
25 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
26 # define SWIGTEMPLATEDISAMBIGUATOR template
27 # elif defined(__HP_aCC)
28 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
29 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
30 # define SWIGTEMPLATEDISAMBIGUATOR template
31 # else
32 # define SWIGTEMPLATEDISAMBIGUATOR
33 # endif
34 #endif
35 
36 /* inline attribute */
37 #ifndef SWIGINLINE
38 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
39 # define SWIGINLINE inline
40 # else
41 # define SWIGINLINE
42 # endif
43 #endif
44 
45 /* attribute recognised by some compilers to avoid 'unused' warnings */
46 #ifndef SWIGUNUSED
47 # if defined(__GNUC__)
48 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
49 # define SWIGUNUSED __attribute__ ((__unused__))
50 # else
51 # define SWIGUNUSED
52 # endif
53 # elif defined(__ICC)
54 # define SWIGUNUSED __attribute__ ((__unused__))
55 # else
56 # define SWIGUNUSED
57 # endif
58 #endif
59 
60 #ifndef SWIG_MSC_UNSUPPRESS_4505
61 # if defined(_MSC_VER)
62 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
63 # endif
64 #endif
65 
66 #ifndef SWIGUNUSEDPARM
67 # ifdef __cplusplus
68 # define SWIGUNUSEDPARM(p)
69 # else
70 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
71 # endif
72 #endif
73 
74 /* internal SWIG method */
75 #ifndef SWIGINTERN
76 # define SWIGINTERN static SWIGUNUSED
77 #endif
78 
79 /* internal inline SWIG method */
80 #ifndef SWIGINTERNINLINE
81 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
82 #endif
83 
84 /* exporting methods */
85 #if defined(__GNUC__)
86 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
87 # ifndef GCC_HASCLASSVISIBILITY
88 # define GCC_HASCLASSVISIBILITY
89 # endif
90 # endif
91 #endif
92 
93 #ifndef SWIGEXPORT
94 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
95 # if defined(STATIC_LINKED)
96 # define SWIGEXPORT
97 # else
98 # define SWIGEXPORT __declspec(dllexport)
99 # endif
100 # else
101 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
102 # define SWIGEXPORT __attribute__ ((visibility("default")))
103 # else
104 # define SWIGEXPORT
105 # endif
106 # endif
107 #endif
108 
109 /* calling conventions for Windows */
110 #ifndef SWIGSTDCALL
111 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
112 # define SWIGSTDCALL __stdcall
113 # else
114 # define SWIGSTDCALL
115 # endif
116 #endif
117 
118 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
119 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
120 # define _CRT_SECURE_NO_DEPRECATE
121 #endif
122 
123 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
124 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
125 # define _SCL_SECURE_NO_DEPRECATE
126 #endif
127 
128 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
129 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
130 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
131 #endif
132 
133 /* Intel's compiler complains if a variable which was never initialised is
134  * cast to void, which is a common idiom which we use to indicate that we
135  * are aware a variable isn't used. So we just silence that warning.
136  * See: https://github.com/swig/swig/issues/192 for more discussion.
137  */
138 #ifdef __INTEL_COMPILER
139 # pragma warning disable 592
140 #endif
141 
142 
143 #if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
144 /* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
145 # include <math.h>
146 #endif
147 
148 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
149 /* Use debug wrappers with the Python release dll */
150 # undef _DEBUG
151 # include <Python.h>
152 # define _DEBUG 1
153 #else
154 # include <Python.h>
155 #endif
156 
157 /* -----------------------------------------------------------------------------
158  * swigrun.swg
159  *
160  * This file contains generic C API SWIG runtime support for pointer
161  * type checking.
162  * ----------------------------------------------------------------------------- */
163 
164 /* This should only be incremented when either the layout of swig_type_info changes,
165  or for whatever reason, the runtime changes incompatibly */
166 #define SWIG_RUNTIME_VERSION "4"
167 
168 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
169 #ifdef SWIG_TYPE_TABLE
170 # define SWIG_QUOTE_STRING(x) #x
171 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
172 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
173 #else
174 # define SWIG_TYPE_TABLE_NAME
175 #endif
176 
177 /*
178  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
179  creating a static or dynamic library from the SWIG runtime code.
180  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
181 
182  But only do this if strictly necessary, ie, if you have problems
183  with your compiler or suchlike.
184 */
185 
186 #ifndef SWIGRUNTIME
187 # define SWIGRUNTIME SWIGINTERN
188 #endif
189 
190 #ifndef SWIGRUNTIMEINLINE
191 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
192 #endif
193 
194 /* Generic buffer size */
195 #ifndef SWIG_BUFFER_SIZE
196 # define SWIG_BUFFER_SIZE 1024
197 #endif
198 
199 /* Flags for pointer conversions */
200 #define SWIG_POINTER_DISOWN 0x1
201 #define SWIG_CAST_NEW_MEMORY 0x2
202 #define SWIG_POINTER_NO_NULL 0x4
203 
204 /* Flags for new pointer objects */
205 #define SWIG_POINTER_OWN 0x1
206 
207 
208 /*
209  Flags/methods for returning states.
210 
211  The SWIG conversion methods, as ConvertPtr, return an integer
212  that tells if the conversion was successful or not. And if not,
213  an error code can be returned (see swigerrors.swg for the codes).
214 
215  Use the following macros/flags to set or process the returning
216  states.
217 
218  In old versions of SWIG, code such as the following was usually written:
219 
220  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
221  // success code
222  } else {
223  //fail code
224  }
225 
226  Now you can be more explicit:
227 
228  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
229  if (SWIG_IsOK(res)) {
230  // success code
231  } else {
232  // fail code
233  }
234 
235  which is the same really, but now you can also do
236 
237  Type *ptr;
238  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
239  if (SWIG_IsOK(res)) {
240  // success code
241  if (SWIG_IsNewObj(res) {
242  ...
243  delete *ptr;
244  } else {
245  ...
246  }
247  } else {
248  // fail code
249  }
250 
251  I.e., now SWIG_ConvertPtr can return new objects and you can
252  identify the case and take care of the deallocation. Of course that
253  also requires SWIG_ConvertPtr to return new result values, such as
254 
255  int SWIG_ConvertPtr(obj, ptr,...) {
256  if (<obj is ok>) {
257  if (<need new object>) {
258  *ptr = <ptr to new allocated object>;
259  return SWIG_NEWOBJ;
260  } else {
261  *ptr = <ptr to old object>;
262  return SWIG_OLDOBJ;
263  }
264  } else {
265  return SWIG_BADOBJ;
266  }
267  }
268 
269  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
270  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
271  SWIG errors code.
272 
273  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
274  allows to return the 'cast rank', for example, if you have this
275 
276  int food(double)
277  int fooi(int);
278 
279  and you call
280 
281  food(1) // cast rank '1' (1 -> 1.0)
282  fooi(1) // cast rank '0'
283 
284  just use the SWIG_AddCast()/SWIG_CheckState()
285 */
286 
287 #define SWIG_OK (0)
288 #define SWIG_ERROR (-1)
289 #define SWIG_IsOK(r) (r >= 0)
290 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
291 
292 /* The CastRankLimit says how many bits are used for the cast rank */
293 #define SWIG_CASTRANKLIMIT (1 << 8)
294 /* The NewMask denotes the object was created (using new/malloc) */
295 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
296 /* The TmpMask is for in/out typemaps that use temporal objects */
297 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
298 /* Simple returning values */
299 #define SWIG_BADOBJ (SWIG_ERROR)
300 #define SWIG_OLDOBJ (SWIG_OK)
301 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
302 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
303 /* Check, add and del mask methods */
304 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
305 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
306 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
307 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
308 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
309 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
310 
311 /* Cast-Rank Mode */
312 #if defined(SWIG_CASTRANK_MODE)
313 # ifndef SWIG_TypeRank
314 # define SWIG_TypeRank unsigned long
315 # endif
316 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
317 # define SWIG_MAXCASTRANK (2)
318 # endif
319 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
320 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
321 SWIGINTERNINLINE int SWIG_AddCast(int r) {
322  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
323 }
325  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
326 }
327 #else /* no cast-rank mode */
328 # define SWIG_AddCast(r) (r)
329 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
330 #endif
331 
332 
333 #include <string.h>
334 
335 #ifdef __cplusplus
336 extern "C" {
337 #endif
338 
339 typedef void *(*swig_converter_func)(void *, int *);
340 typedef struct swig_type_info *(*swig_dycast_func)(void **);
341 
342 /* Structure to store information on one type */
343 typedef struct swig_type_info {
344  const char *name; /* mangled name of this type */
345  const char *str; /* human readable name of this type */
346  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
347  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
348  void *clientdata; /* language specific type data */
349  int owndata; /* flag if the structure owns the clientdata */
351 
352 /* Structure to store a type and conversion function used for casting */
353 typedef struct swig_cast_info {
354  swig_type_info *type; /* pointer to type that is equivalent to this type */
355  swig_converter_func converter; /* function to cast the void pointers */
356  struct swig_cast_info *next; /* pointer to next cast in linked list */
357  struct swig_cast_info *prev; /* pointer to the previous cast */
359 
360 /* Structure used to store module information
361  * Each module generates one structure like this, and the runtime collects
362  * all of these structures and stores them in a circularly linked list.*/
363 typedef struct swig_module_info {
364  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
365  size_t size; /* Number of types in this module */
366  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
367  swig_type_info **type_initial; /* Array of initially generated type structures */
368  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
369  void *clientdata; /* Language specific module data */
371 
372 /*
373  Compare two type names skipping the space characters, therefore
374  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
375 
376  Return 0 when the two name types are equivalent, as in
377  strncmp, but skipping ' '.
378 */
379 SWIGRUNTIME int
380 SWIG_TypeNameComp(const char *f1, const char *l1,
381  const char *f2, const char *l2) {
382  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
383  while ((*f1 == ' ') && (f1 != l1)) ++f1;
384  while ((*f2 == ' ') && (f2 != l2)) ++f2;
385  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
386  }
387  return (int)((l1 - f1) - (l2 - f2));
388 }
389 
390 /*
391  Check type equivalence in a name list like <name1>|<name2>|...
392  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
393 */
394 SWIGRUNTIME int
395 SWIG_TypeCmp(const char *nb, const char *tb) {
396  int equiv = 1;
397  const char* te = tb + strlen(tb);
398  const char* ne = nb;
399  while (equiv != 0 && *ne) {
400  for (nb = ne; *ne; ++ne) {
401  if (*ne == '|') break;
402  }
403  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
404  if (*ne) ++ne;
405  }
406  return equiv;
407 }
408 
409 /*
410  Check type equivalence in a name list like <name1>|<name2>|...
411  Return 0 if not equal, 1 if equal
412 */
413 SWIGRUNTIME int
414 SWIG_TypeEquiv(const char *nb, const char *tb) {
415  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
416 }
417 
418 /*
419  Check the typename
420 */
422 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
423  if (ty) {
424  swig_cast_info *iter = ty->cast;
425  while (iter) {
426  if (strcmp(iter->type->name, c) == 0) {
427  if (iter == ty->cast)
428  return iter;
429  /* Move iter to the top of the linked list */
430  iter->prev->next = iter->next;
431  if (iter->next)
432  iter->next->prev = iter->prev;
433  iter->next = ty->cast;
434  iter->prev = 0;
435  if (ty->cast) ty->cast->prev = iter;
436  ty->cast = iter;
437  return iter;
438  }
439  iter = iter->next;
440  }
441  }
442  return 0;
443 }
444 
445 /*
446  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
447 */
450  if (ty) {
451  swig_cast_info *iter = ty->cast;
452  while (iter) {
453  if (iter->type == from) {
454  if (iter == ty->cast)
455  return iter;
456  /* Move iter to the top of the linked list */
457  iter->prev->next = iter->next;
458  if (iter->next)
459  iter->next->prev = iter->prev;
460  iter->next = ty->cast;
461  iter->prev = 0;
462  if (ty->cast) ty->cast->prev = iter;
463  ty->cast = iter;
464  return iter;
465  }
466  iter = iter->next;
467  }
468  }
469  return 0;
470 }
471 
472 /*
473  Cast a pointer up an inheritance hierarchy
474 */
475 SWIGRUNTIMEINLINE void *
476 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
477  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
478 }
479 
480 /*
481  Dynamic pointer casting. Down an inheritance hierarchy
482 */
485  swig_type_info *lastty = ty;
486  if (!ty || !ty->dcast) return ty;
487  while (ty && (ty->dcast)) {
488  ty = (*ty->dcast)(ptr);
489  if (ty) lastty = ty;
490  }
491  return lastty;
492 }
493 
494 /*
495  Return the name associated with this type
496 */
497 SWIGRUNTIMEINLINE const char *
499  return ty->name;
500 }
501 
502 /*
503  Return the pretty name associated with this type,
504  that is an unmangled type name in a form presentable to the user.
505 */
506 SWIGRUNTIME const char *
508  /* The "str" field contains the equivalent pretty names of the
509  type, separated by vertical-bar characters. We choose
510  to print the last name, as it is often (?) the most
511  specific. */
512  if (!type) return NULL;
513  if (type->str != NULL) {
514  const char *last_name = type->str;
515  const char *s;
516  for (s = type->str; *s; s++)
517  if (*s == '|') last_name = s+1;
518  return last_name;
519  }
520  else
521  return type->name;
522 }
523 
524 /*
525  Set the clientdata field for a type
526 */
527 SWIGRUNTIME void
529  swig_cast_info *cast = ti->cast;
530  /* if (ti->clientdata == clientdata) return; */
531  ti->clientdata = clientdata;
532 
533  while (cast) {
534  if (!cast->converter) {
535  swig_type_info *tc = cast->type;
536  if (!tc->clientdata) {
538  }
539  }
540  cast = cast->next;
541  }
542 }
543 SWIGRUNTIME void
546  ti->owndata = 1;
547 }
548 
549 /*
550  Search for a swig_type_info structure only by mangled name
551  Search is a O(log #types)
552 
553  We start searching at module start, and finish searching when start == end.
554  Note: if start == end at the beginning of the function, we go all the way around
555  the circular list.
556 */
559  swig_module_info *end,
560  const char *name) {
561  swig_module_info *iter = start;
562  do {
563  if (iter->size) {
564  size_t l = 0;
565  size_t r = iter->size - 1;
566  do {
567  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
568  size_t i = (l + r) >> 1;
569  const char *iname = iter->types[i]->name;
570  if (iname) {
571  int compare = strcmp(name, iname);
572  if (compare == 0) {
573  return iter->types[i];
574  } else if (compare < 0) {
575  if (i) {
576  r = i - 1;
577  } else {
578  break;
579  }
580  } else if (compare > 0) {
581  l = i + 1;
582  }
583  } else {
584  break; /* should never happen */
585  }
586  } while (l <= r);
587  }
588  iter = iter->next;
589  } while (iter != end);
590  return 0;
591 }
592 
593 /*
594  Search for a swig_type_info structure for either a mangled name or a human readable name.
595  It first searches the mangled names of the types, which is a O(log #types)
596  If a type is not found it then searches the human readable names, which is O(#types).
597 
598  We start searching at module start, and finish searching when start == end.
599  Note: if start == end at the beginning of the function, we go all the way around
600  the circular list.
601 */
604  swig_module_info *end,
605  const char *name) {
606  /* STEP 1: Search the name field using binary search */
607  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
608  if (ret) {
609  return ret;
610  } else {
611  /* STEP 2: If the type hasn't been found, do a complete search
612  of the str field (the human readable name) */
613  swig_module_info *iter = start;
614  do {
615  size_t i = 0;
616  for (; i < iter->size; ++i) {
617  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
618  return iter->types[i];
619  }
620  iter = iter->next;
621  } while (iter != end);
622  }
623 
624  /* neither found a match */
625  return 0;
626 }
627 
628 /*
629  Pack binary data into a string
630 */
631 SWIGRUNTIME char *
632 SWIG_PackData(char *c, void *ptr, size_t sz) {
633  static const char hex[17] = "0123456789abcdef";
634  const unsigned char *u = (unsigned char *) ptr;
635  const unsigned char *eu = u + sz;
636  for (; u != eu; ++u) {
637  unsigned char uu = *u;
638  *(c++) = hex[(uu & 0xf0) >> 4];
639  *(c++) = hex[uu & 0xf];
640  }
641  return c;
642 }
643 
644 /*
645  Unpack binary data from a string
646 */
647 SWIGRUNTIME const char *
648 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
649  unsigned char *u = (unsigned char *) ptr;
650  const unsigned char *eu = u + sz;
651  for (; u != eu; ++u) {
652  char d = *(c++);
653  unsigned char uu;
654  if ((d >= '0') && (d <= '9'))
655  uu = (unsigned char)((d - '0') << 4);
656  else if ((d >= 'a') && (d <= 'f'))
657  uu = (unsigned char)((d - ('a'-10)) << 4);
658  else
659  return (char *) 0;
660  d = *(c++);
661  if ((d >= '0') && (d <= '9'))
662  uu |= (unsigned char)(d - '0');
663  else if ((d >= 'a') && (d <= 'f'))
664  uu |= (unsigned char)(d - ('a'-10));
665  else
666  return (char *) 0;
667  *u = uu;
668  }
669  return c;
670 }
671 
672 /*
673  Pack 'void *' into a string buffer.
674 */
675 SWIGRUNTIME char *
676 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
677  char *r = buff;
678  if ((2*sizeof(void *) + 2) > bsz) return 0;
679  *(r++) = '_';
680  r = SWIG_PackData(r,&ptr,sizeof(void *));
681  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
682  strcpy(r,name);
683  return buff;
684 }
685 
686 SWIGRUNTIME const char *
687 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
688  if (*c != '_') {
689  if (strcmp(c,"NULL") == 0) {
690  *ptr = (void *) 0;
691  return name;
692  } else {
693  return 0;
694  }
695  }
696  return SWIG_UnpackData(++c,ptr,sizeof(void *));
697 }
698 
699 SWIGRUNTIME char *
700 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
701  char *r = buff;
702  size_t lname = (name ? strlen(name) : 0);
703  if ((2*sz + 2 + lname) > bsz) return 0;
704  *(r++) = '_';
705  r = SWIG_PackData(r,ptr,sz);
706  if (lname) {
707  strncpy(r,name,lname+1);
708  } else {
709  *r = 0;
710  }
711  return buff;
712 }
713 
714 SWIGRUNTIME const char *
715 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
716  if (*c != '_') {
717  if (strcmp(c,"NULL") == 0) {
718  memset(ptr,0,sz);
719  return name;
720  } else {
721  return 0;
722  }
723  }
724  return SWIG_UnpackData(++c,ptr,sz);
725 }
726 
727 #ifdef __cplusplus
728 }
729 #endif
730 
731 /* Errors in SWIG */
732 #define SWIG_UnknownError -1
733 #define SWIG_IOError -2
734 #define SWIG_RuntimeError -3
735 #define SWIG_IndexError -4
736 #define SWIG_TypeError -5
737 #define SWIG_DivisionByZero -6
738 #define SWIG_OverflowError -7
739 #define SWIG_SyntaxError -8
740 #define SWIG_ValueError -9
741 #define SWIG_SystemError -10
742 #define SWIG_AttributeError -11
743 #define SWIG_MemoryError -12
744 #define SWIG_NullReferenceError -13
745 
746 
747 
748 /* Compatibility macros for Python 3 */
749 #if PY_VERSION_HEX >= 0x03000000
750 
751 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
752 #define PyInt_Check(x) PyLong_Check(x)
753 #define PyInt_AsLong(x) PyLong_AsLong(x)
754 #define PyInt_FromLong(x) PyLong_FromLong(x)
755 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
756 #define PyString_Check(name) PyBytes_Check(name)
757 #define PyString_FromString(x) PyUnicode_FromString(x)
758 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
759 #define PyString_AsString(str) PyBytes_AsString(str)
760 #define PyString_Size(str) PyBytes_Size(str)
761 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
762 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
763 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
764 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
765 
766 #endif
767 
768 #ifndef Py_TYPE
769 # define Py_TYPE(op) ((op)->ob_type)
770 #endif
771 
772 /* SWIG APIs for compatibility of both Python 2 & 3 */
773 
774 #if PY_VERSION_HEX >= 0x03000000
775 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
776 #else
777 # define SWIG_Python_str_FromFormat PyString_FromFormat
778 #endif
779 
780 
781 /* Warning: This function will allocate a new string in Python 3,
782  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
783  */
784 SWIGINTERN char*
786 {
787 #if PY_VERSION_HEX >= 0x03030000
788  return (char *)PyUnicode_AsUTF8(str);
789 #elif PY_VERSION_HEX >= 0x03000000
790  char *newstr = 0;
791  str = PyUnicode_AsUTF8String(str);
792  if (str) {
793  char *cstr;
794  Py_ssize_t len;
795  if (PyBytes_AsStringAndSize(str, &cstr, &len) != -1) {
796  newstr = (char *) malloc(len+1);
797  if (newstr)
798  memcpy(newstr, cstr, len+1);
799  }
800  Py_XDECREF(str);
801  }
802  return newstr;
803 #else
804  return PyString_AsString(str);
805 #endif
806 }
807 
808 #if PY_VERSION_HEX >= 0x03030000 || PY_VERSION_HEX < 0x03000000
809 # define SWIG_Python_str_DelForPy3(x)
810 #else
811 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
812 #endif
813 
814 
815 SWIGINTERN PyObject*
817 {
818 #if PY_VERSION_HEX >= 0x03000000
819  return PyUnicode_FromString(c);
820 #else
821  return PyString_FromString(c);
822 #endif
823 }
824 
825 #ifndef PyObject_DEL
826 # define PyObject_DEL PyObject_Del
827 #endif
828 
829 // SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user
830 // interface files check for it.
831 # define SWIGPY_USE_CAPSULE
832 # define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
833 
834 #if PY_VERSION_HEX < 0x03020000
835 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
836 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
837 #define Py_hash_t long
838 #endif
839 
840 /* -----------------------------------------------------------------------------
841  * error manipulation
842  * ----------------------------------------------------------------------------- */
843 
844 SWIGRUNTIME PyObject*
846  PyObject* type = 0;
847  switch(code) {
848  case SWIG_MemoryError:
849  type = PyExc_MemoryError;
850  break;
851  case SWIG_IOError:
852  type = PyExc_IOError;
853  break;
854  case SWIG_RuntimeError:
855  type = PyExc_RuntimeError;
856  break;
857  case SWIG_IndexError:
858  type = PyExc_IndexError;
859  break;
860  case SWIG_TypeError:
861  type = PyExc_TypeError;
862  break;
863  case SWIG_DivisionByZero:
864  type = PyExc_ZeroDivisionError;
865  break;
866  case SWIG_OverflowError:
867  type = PyExc_OverflowError;
868  break;
869  case SWIG_SyntaxError:
870  type = PyExc_SyntaxError;
871  break;
872  case SWIG_ValueError:
873  type = PyExc_ValueError;
874  break;
875  case SWIG_SystemError:
876  type = PyExc_SystemError;
877  break;
878  case SWIG_AttributeError:
879  type = PyExc_AttributeError;
880  break;
881  default:
882  type = PyExc_RuntimeError;
883  }
884  return type;
885 }
886 
887 
888 SWIGRUNTIME void
889 SWIG_Python_AddErrorMsg(const char* mesg)
890 {
891  PyObject *type = 0;
892  PyObject *value = 0;
893  PyObject *traceback = 0;
894 
895  if (PyErr_Occurred())
896  PyErr_Fetch(&type, &value, &traceback);
897  if (value) {
898  PyObject *old_str = PyObject_Str(value);
899  const char *tmp = SWIG_Python_str_AsChar(old_str);
900  PyErr_Clear();
901  Py_XINCREF(type);
902  if (tmp)
903  PyErr_Format(type, "%s %s", tmp, mesg);
904  else
905  PyErr_Format(type, "%s", mesg);
907  Py_DECREF(old_str);
908  Py_DECREF(value);
909  } else {
910  PyErr_SetString(PyExc_RuntimeError, mesg);
911  }
912 }
913 
914 SWIGRUNTIME int
916 {
917  PyObject *error;
918  if (obj)
919  return 0;
920  error = PyErr_Occurred();
921  return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
922 }
923 
924 SWIGRUNTIME void
926 {
927  if (SWIG_Python_TypeErrorOccurred(NULL)) {
928  /* Use existing TypeError to preserve stacktrace and enhance with given message */
929  PyObject *newvalue;
930  PyObject *type = NULL, *value = NULL, *traceback = NULL;
931  PyErr_Fetch(&type, &value, &traceback);
932 #if PY_VERSION_HEX >= 0x03000000
933  newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
934 #else
935  newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
936 #endif
937  Py_XDECREF(value);
938  PyErr_Restore(type, newvalue, traceback);
939  } else {
940  /* Raise TypeError using given message */
941  PyErr_SetString(PyExc_TypeError, message);
942  }
943 }
944 
945 #if defined(SWIG_PYTHON_NO_THREADS)
946 # if defined(SWIG_PYTHON_THREADS)
947 # undef SWIG_PYTHON_THREADS
948 # endif
949 #endif
950 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
951 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
952 # define SWIG_PYTHON_USE_GIL
953 # endif
954 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
955 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
956 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
957 # endif
958 # ifdef __cplusplus /* C++ code */
959  class SWIG_Python_Thread_Block {
960  bool status;
961  PyGILState_STATE state;
962  public:
963  void end() { if (status) { PyGILState_Release(state); status = false;} }
964  SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
965  ~SWIG_Python_Thread_Block() { end(); }
966  };
967  class SWIG_Python_Thread_Allow {
968  bool status;
969  PyThreadState *save;
970  public:
971  void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
972  SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
973  ~SWIG_Python_Thread_Allow() { end(); }
974  };
975 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
976 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
977 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
978 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
979 # else /* C code */
980 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
981 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
982 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
983 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
984 # endif
985 # else /* Old thread way, not implemented, user must provide it */
986 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
987 # define SWIG_PYTHON_INITIALIZE_THREADS
988 # endif
989 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
990 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
991 # endif
992 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
993 # define SWIG_PYTHON_THREAD_END_BLOCK
994 # endif
995 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
996 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
997 # endif
998 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
999 # define SWIG_PYTHON_THREAD_END_ALLOW
1000 # endif
1001 # endif
1002 #else /* No thread support */
1003 # define SWIG_PYTHON_INITIALIZE_THREADS
1004 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1005 # define SWIG_PYTHON_THREAD_END_BLOCK
1006 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1007 # define SWIG_PYTHON_THREAD_END_ALLOW
1008 #endif
1009 
1010 /* -----------------------------------------------------------------------------
1011  * Python API portion that goes into the runtime
1012  * ----------------------------------------------------------------------------- */
1013 
1014 #ifdef __cplusplus
1015 extern "C" {
1016 #endif
1017 
1018 /* -----------------------------------------------------------------------------
1019  * Constant declarations
1020  * ----------------------------------------------------------------------------- */
1021 
1022 /* Constant Types */
1023 #define SWIG_PY_POINTER 4
1024 #define SWIG_PY_BINARY 5
1025 
1026 /* Constant information structure */
1027 typedef struct swig_const_info {
1028  int type;
1029  const char *name;
1030  long lvalue;
1031  double dvalue;
1032  void *pvalue;
1035 
1036 #ifdef __cplusplus
1037 }
1038 #endif
1039 
1040 
1041 /* -----------------------------------------------------------------------------
1042  * pyrun.swg
1043  *
1044  * This file contains the runtime support for Python modules
1045  * and includes code for managing global variables and pointer
1046  * type checking.
1047  *
1048  * ----------------------------------------------------------------------------- */
1049 
1050 #if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
1051 # error "This version of SWIG only supports Python >= 2.7"
1052 #endif
1053 
1054 #if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000
1055 # error "This version of SWIG only supports Python 3 >= 3.2"
1056 #endif
1057 
1058 /* Common SWIG API */
1059 
1060 /* for raw pointers */
1061 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1062 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1063 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1064 
1065 #ifdef SWIGPYTHON_BUILTIN
1066 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1067 #else
1068 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1069 #endif
1070 
1071 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1072 
1073 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1074 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1075 #define swig_owntype int
1076 
1077 /* for raw packed data */
1078 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1079 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1080 
1081 /* for class or struct pointers */
1082 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1083 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1084 
1085 /* for C or C++ function pointers */
1086 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1087 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1088 
1089 /* for C++ member pointers, ie, member methods */
1090 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1091 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1092 
1093 
1094 /* Runtime API */
1095 
1096 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1097 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1098 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1099 
1100 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1101 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1102 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1103 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1104 #define SWIG_fail goto fail
1105 
1106 
1107 /* Runtime API implementation */
1108 
1109 /* Error manipulation */
1110 
1111 SWIGINTERN void
1112 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1114  PyErr_SetObject(errtype, obj);
1115  Py_DECREF(obj);
1117 }
1118 
1119 SWIGINTERN void
1120 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1122  PyErr_SetString(errtype, msg);
1124 }
1125 
1126 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1127 
1128 /* Set a constant value */
1129 
1130 #if defined(SWIGPYTHON_BUILTIN)
1131 
1132 SWIGINTERN void
1133 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1134  PyObject *s = PyString_InternFromString(key);
1135  PyList_Append(seq, s);
1136  Py_DECREF(s);
1137 }
1138 
1139 SWIGINTERN void
1140 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1141  PyDict_SetItemString(d, name, obj);
1142  Py_DECREF(obj);
1143  if (public_interface)
1144  SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1145 }
1146 
1147 #else
1148 
1149 SWIGINTERN void
1150 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1151  PyDict_SetItemString(d, name, obj);
1152  Py_DECREF(obj);
1153 }
1154 
1155 #endif
1156 
1157 /* Append a value to the result obj */
1158 
1159 SWIGINTERN PyObject*
1160 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1161  if (!result) {
1162  result = obj;
1163  } else if (result == Py_None) {
1164  Py_DECREF(result);
1165  result = obj;
1166  } else {
1167  if (!PyList_Check(result)) {
1168  PyObject *o2 = result;
1169  result = PyList_New(1);
1170  PyList_SetItem(result, 0, o2);
1171  }
1172  PyList_Append(result,obj);
1173  Py_DECREF(obj);
1174  }
1175  return result;
1176 }
1177 
1178 /* Unpack the argument tuple */
1179 
1180 SWIGINTERN Py_ssize_t
1181 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1182 {
1183  if (!args) {
1184  if (!min && !max) {
1185  return 1;
1186  } else {
1187  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1188  name, (min == max ? "" : "at least "), (int)min);
1189  return 0;
1190  }
1191  }
1192  if (!PyTuple_Check(args)) {
1193  if (min <= 1 && max >= 1) {
1194  Py_ssize_t i;
1195  objs[0] = args;
1196  for (i = 1; i < max; ++i) {
1197  objs[i] = 0;
1198  }
1199  return 2;
1200  }
1201  PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1202  return 0;
1203  } else {
1204  Py_ssize_t l = PyTuple_GET_SIZE(args);
1205  if (l < min) {
1206  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1207  name, (min == max ? "" : "at least "), (int)min, (int)l);
1208  return 0;
1209  } else if (l > max) {
1210  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1211  name, (min == max ? "" : "at most "), (int)max, (int)l);
1212  return 0;
1213  } else {
1214  Py_ssize_t i;
1215  for (i = 0; i < l; ++i) {
1216  objs[i] = PyTuple_GET_ITEM(args, i);
1217  }
1218  for (; l < max; ++l) {
1219  objs[l] = 0;
1220  }
1221  return i + 1;
1222  }
1223  }
1224 }
1225 
1226 SWIGINTERN int
1227 SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
1228  int no_kwargs = 1;
1229  if (kwargs) {
1230  assert(PyDict_Check(kwargs));
1231  if (PyDict_Size(kwargs) > 0) {
1232  PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
1233  no_kwargs = 0;
1234  }
1235  }
1236  return no_kwargs;
1237 }
1238 
1239 /* A functor is a function object with one single object argument */
1240 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1241 
1242 /*
1243  Helper for static pointer initialization for both C and C++ code, for example
1244  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1245 */
1246 #ifdef __cplusplus
1247 #define SWIG_STATIC_POINTER(var) var
1248 #else
1249 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1250 #endif
1251 
1252 /* -----------------------------------------------------------------------------
1253  * Pointer declarations
1254  * ----------------------------------------------------------------------------- */
1255 
1256 /* Flags for new pointer objects */
1257 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1258 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1259 
1260 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1261 
1262 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1263 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1264 
1265 #ifdef __cplusplus
1266 extern "C" {
1267 #endif
1268 
1269 /* The python void return value */
1270 
1271 SWIGRUNTIMEINLINE PyObject *
1273 {
1274  PyObject *none = Py_None;
1275  Py_INCREF(none);
1276  return none;
1277 }
1278 
1279 /* SwigPyClientData */
1280 
1281 typedef struct {
1282  PyObject *klass;
1283  PyObject *newraw;
1284  PyObject *newargs;
1285  PyObject *destroy;
1286  int delargs;
1288  PyTypeObject *pytype;
1290 
1291 SWIGRUNTIMEINLINE int
1293 {
1295  int fail = data ? data->implicitconv : 0;
1296  if (fail)
1297  PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
1298  return fail;
1299 }
1300 
1301 SWIGRUNTIMEINLINE PyObject *
1303  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1304  PyObject *klass = data ? data->klass : 0;
1305  return (klass ? klass : PyExc_RuntimeError);
1306 }
1307 
1308 
1310 SwigPyClientData_New(PyObject* obj)
1311 {
1312  if (!obj) {
1313  return 0;
1314  } else {
1315  SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1316  /* the klass element */
1317  data->klass = obj;
1318  Py_INCREF(data->klass);
1319  /* the newraw method and newargs arguments used to create a new raw instance */
1320  if (PyClass_Check(obj)) {
1321  data->newraw = 0;
1322  data->newargs = obj;
1323  Py_INCREF(obj);
1324  } else {
1325  data->newraw = PyObject_GetAttrString(data->klass, "__new__");
1326  if (data->newraw) {
1327  Py_INCREF(data->newraw);
1328  data->newargs = PyTuple_New(1);
1329  PyTuple_SetItem(data->newargs, 0, obj);
1330  } else {
1331  data->newargs = obj;
1332  }
1333  Py_INCREF(data->newargs);
1334  }
1335  /* the destroy method, aka as the C++ delete method */
1336  data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
1337  if (PyErr_Occurred()) {
1338  PyErr_Clear();
1339  data->destroy = 0;
1340  }
1341  if (data->destroy) {
1342  int flags;
1343  Py_INCREF(data->destroy);
1344  flags = PyCFunction_GET_FLAGS(data->destroy);
1345  data->delargs = !(flags & (METH_O));
1346  } else {
1347  data->delargs = 0;
1348  }
1349  data->implicitconv = 0;
1350  data->pytype = 0;
1351  return data;
1352  }
1353 }
1354 
1355 SWIGRUNTIME void
1357  Py_XDECREF(data->newraw);
1358  Py_XDECREF(data->newargs);
1359  Py_XDECREF(data->destroy);
1360 }
1361 
1362 /* =============== SwigPyObject =====================*/
1363 
1364 typedef struct {
1365  PyObject_HEAD
1366  void *ptr;
1368  int own;
1369  PyObject *next;
1370 #ifdef SWIGPYTHON_BUILTIN
1371  PyObject *dict;
1372 #endif
1373 } SwigPyObject;
1374 
1375 
1376 #ifdef SWIGPYTHON_BUILTIN
1377 
1378 SWIGRUNTIME PyObject *
1379 SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1380 {
1381  SwigPyObject *sobj = (SwigPyObject *)v;
1382 
1383  if (!sobj->dict)
1384  sobj->dict = PyDict_New();
1385 
1386  Py_INCREF(sobj->dict);
1387  return sobj->dict;
1388 }
1389 
1390 #endif
1391 
1392 SWIGRUNTIME PyObject *
1394 {
1395  return PyLong_FromVoidPtr(v->ptr);
1396 }
1397 
1398 SWIGRUNTIME PyObject *
1399 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1400 {
1401  PyObject *res = NULL;
1402  PyObject *args = PyTuple_New(1);
1403  if (args) {
1404  if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1405  PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1406  if (ofmt) {
1407 #if PY_VERSION_HEX >= 0x03000000
1408  res = PyUnicode_Format(ofmt,args);
1409 #else
1410  res = PyString_Format(ofmt,args);
1411 #endif
1412  Py_DECREF(ofmt);
1413  }
1414  Py_DECREF(args);
1415  }
1416  }
1417  return res;
1418 }
1419 
1420 SWIGRUNTIME PyObject *
1422 {
1423  return SwigPyObject_format("%o",v);
1424 }
1425 
1426 SWIGRUNTIME PyObject *
1428 {
1429  return SwigPyObject_format("%x",v);
1430 }
1431 
1432 SWIGRUNTIME PyObject *
1434 {
1435  const char *name = SWIG_TypePrettyName(v->ty);
1436  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1437  if (v->next) {
1438  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1439 # if PY_VERSION_HEX >= 0x03000000
1440  PyObject *joined = PyUnicode_Concat(repr, nrep);
1441  Py_DecRef(repr);
1442  Py_DecRef(nrep);
1443  repr = joined;
1444 # else
1445  PyString_ConcatAndDel(&repr,nrep);
1446 # endif
1447  }
1448  return repr;
1449 }
1450 
1451 /* We need a version taking two PyObject* parameters so it's a valid
1452  * PyCFunction to use in swigobject_methods[]. */
1453 SWIGRUNTIME PyObject *
1454 SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1455 {
1456  return SwigPyObject_repr((SwigPyObject*)v);
1457 }
1458 
1459 SWIGRUNTIME int
1461 {
1462  void *i = v->ptr;
1463  void *j = w->ptr;
1464  return (i < j) ? -1 : ((i > j) ? 1 : 0);
1465 }
1466 
1467 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1468 SWIGRUNTIME PyObject*
1470 {
1471  PyObject* res;
1472  if( op != Py_EQ && op != Py_NE ) {
1473  Py_INCREF(Py_NotImplemented);
1474  return Py_NotImplemented;
1475  }
1476  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1477  return res;
1478 }
1479 
1480 
1481 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1482 
1483 #ifdef SWIGPYTHON_BUILTIN
1484 static swig_type_info *SwigPyObject_stype = 0;
1485 SWIGRUNTIME PyTypeObject*
1486 SwigPyObject_type(void) {
1487  SwigPyClientData *cd;
1488  assert(SwigPyObject_stype);
1489  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1490  assert(cd);
1491  assert(cd->pytype);
1492  return cd->pytype;
1493 }
1494 #else
1495 SWIGRUNTIME PyTypeObject*
1497  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1498  return type;
1499 }
1500 #endif
1501 
1503 SwigPyObject_Check(PyObject *op) {
1504 #ifdef SWIGPYTHON_BUILTIN
1505  PyTypeObject *target_tp = SwigPyObject_type();
1506  if (PyType_IsSubtype(op->ob_type, target_tp))
1507  return 1;
1508  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1509 #else
1510  return (Py_TYPE(op) == SwigPyObject_type())
1511  || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1512 #endif
1513 }
1514 
1515 SWIGRUNTIME PyObject *
1516 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1517 
1518 SWIGRUNTIME void
1520 {
1521  SwigPyObject *sobj = (SwigPyObject *) v;
1522  PyObject *next = sobj->next;
1523  if (sobj->own == SWIG_POINTER_OWN) {
1524  swig_type_info *ty = sobj->ty;
1525  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1526  PyObject *destroy = data ? data->destroy : 0;
1527  if (destroy) {
1528  /* destroy is always a VARARGS method */
1529  PyObject *res;
1530 
1531  /* PyObject_CallFunction() has the potential to silently drop
1532  the active exception. In cases of unnamed temporary
1533  variable or where we just finished iterating over a generator
1534  StopIteration will be active right now, and this needs to
1535  remain true upon return from SwigPyObject_dealloc. So save
1536  and restore. */
1537 
1538  PyObject *type = NULL, *value = NULL, *traceback = NULL;
1539  PyErr_Fetch(&type, &value, &traceback);
1540 
1541  if (data->delargs) {
1542  /* we need to create a temporary object to carry the destroy operation */
1543  PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1544  res = SWIG_Python_CallFunctor(destroy, tmp);
1545  Py_DECREF(tmp);
1546  } else {
1547  PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1548  PyObject *mself = PyCFunction_GET_SELF(destroy);
1549  res = ((*meth)(mself, v));
1550  }
1551  if (!res)
1552  PyErr_WriteUnraisable(destroy);
1553 
1554  PyErr_Restore(type, value, traceback);
1555 
1556  Py_XDECREF(res);
1557  }
1558 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1559  else {
1560  const char *name = SWIG_TypePrettyName(ty);
1561  printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1562  }
1563 #endif
1564  }
1565  Py_XDECREF(next);
1566  PyObject_DEL(v);
1567 }
1568 
1569 SWIGRUNTIME PyObject*
1570 SwigPyObject_append(PyObject* v, PyObject* next)
1571 {
1572  SwigPyObject *sobj = (SwigPyObject *) v;
1573  if (!SwigPyObject_Check(next)) {
1574  PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1575  return NULL;
1576  }
1577  sobj->next = next;
1578  Py_INCREF(next);
1579  return SWIG_Py_Void();
1580 }
1581 
1582 SWIGRUNTIME PyObject*
1583 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1584 {
1585  SwigPyObject *sobj = (SwigPyObject *) v;
1586  if (sobj->next) {
1587  Py_INCREF(sobj->next);
1588  return sobj->next;
1589  } else {
1590  return SWIG_Py_Void();
1591  }
1592 }
1593 
1594 SWIGINTERN PyObject*
1595 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1596 {
1597  SwigPyObject *sobj = (SwigPyObject *)v;
1598  sobj->own = 0;
1599  return SWIG_Py_Void();
1600 }
1601 
1602 SWIGINTERN PyObject*
1603 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1604 {
1605  SwigPyObject *sobj = (SwigPyObject *)v;
1606  sobj->own = SWIG_POINTER_OWN;
1607  return SWIG_Py_Void();
1608 }
1609 
1610 SWIGINTERN PyObject*
1611 SwigPyObject_own(PyObject *v, PyObject *args)
1612 {
1613  PyObject *val = 0;
1614  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
1615  return NULL;
1616  } else {
1617  SwigPyObject *sobj = (SwigPyObject *)v;
1618  PyObject *obj = PyBool_FromLong(sobj->own);
1619  if (val) {
1620  if (PyObject_IsTrue(val)) {
1621  SwigPyObject_acquire(v,args);
1622  } else {
1623  SwigPyObject_disown(v,args);
1624  }
1625  }
1626  return obj;
1627  }
1628 }
1629 
1630 static PyMethodDef
1632  {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
1633  {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
1634  {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
1635  {"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
1636  {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
1637  {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
1638  {0, 0, 0, 0}
1639 };
1640 
1641 SWIGRUNTIME PyTypeObject*
1643  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1644 
1645  static PyNumberMethods SwigPyObject_as_number = {
1646  (binaryfunc)0, /*nb_add*/
1647  (binaryfunc)0, /*nb_subtract*/
1648  (binaryfunc)0, /*nb_multiply*/
1649  /* nb_divide removed in Python 3 */
1650 #if PY_VERSION_HEX < 0x03000000
1651  (binaryfunc)0, /*nb_divide*/
1652 #endif
1653  (binaryfunc)0, /*nb_remainder*/
1654  (binaryfunc)0, /*nb_divmod*/
1655  (ternaryfunc)0,/*nb_power*/
1656  (unaryfunc)0, /*nb_negative*/
1657  (unaryfunc)0, /*nb_positive*/
1658  (unaryfunc)0, /*nb_absolute*/
1659  (inquiry)0, /*nb_nonzero*/
1660  0, /*nb_invert*/
1661  0, /*nb_lshift*/
1662  0, /*nb_rshift*/
1663  0, /*nb_and*/
1664  0, /*nb_xor*/
1665  0, /*nb_or*/
1666 #if PY_VERSION_HEX < 0x03000000
1667  0, /*nb_coerce*/
1668 #endif
1669  (unaryfunc)SwigPyObject_long, /*nb_int*/
1670 #if PY_VERSION_HEX < 0x03000000
1671  (unaryfunc)SwigPyObject_long, /*nb_long*/
1672 #else
1673  0, /*nb_reserved*/
1674 #endif
1675  (unaryfunc)0, /*nb_float*/
1676 #if PY_VERSION_HEX < 0x03000000
1677  (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1678  (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1679 #endif
1680 #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1681  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1682 #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1683  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1684 #else
1685  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1686 #endif
1687  };
1688 
1689  static PyTypeObject swigpyobject_type;
1690  static int type_init = 0;
1691  if (!type_init) {
1692  const PyTypeObject tmp = {
1693 #if PY_VERSION_HEX >= 0x03000000
1694  PyVarObject_HEAD_INIT(NULL, 0)
1695 #else
1696  PyObject_HEAD_INIT(NULL)
1697  0, /* ob_size */
1698 #endif
1699  "SwigPyObject", /* tp_name */
1700  sizeof(SwigPyObject), /* tp_basicsize */
1701  0, /* tp_itemsize */
1702  (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1703  0, /* tp_print */
1704  (getattrfunc)0, /* tp_getattr */
1705  (setattrfunc)0, /* tp_setattr */
1706 #if PY_VERSION_HEX >= 0x03000000
1707  0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1708 #else
1709  (cmpfunc)SwigPyObject_compare, /* tp_compare */
1710 #endif
1711  (reprfunc)SwigPyObject_repr, /* tp_repr */
1712  &SwigPyObject_as_number, /* tp_as_number */
1713  0, /* tp_as_sequence */
1714  0, /* tp_as_mapping */
1715  (hashfunc)0, /* tp_hash */
1716  (ternaryfunc)0, /* tp_call */
1717  0, /* tp_str */
1718  PyObject_GenericGetAttr, /* tp_getattro */
1719  0, /* tp_setattro */
1720  0, /* tp_as_buffer */
1721  Py_TPFLAGS_DEFAULT, /* tp_flags */
1722  swigobject_doc, /* tp_doc */
1723  0, /* tp_traverse */
1724  0, /* tp_clear */
1725  (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1726  0, /* tp_weaklistoffset */
1727  0, /* tp_iter */
1728  0, /* tp_iternext */
1729  swigobject_methods, /* tp_methods */
1730  0, /* tp_members */
1731  0, /* tp_getset */
1732  0, /* tp_base */
1733  0, /* tp_dict */
1734  0, /* tp_descr_get */
1735  0, /* tp_descr_set */
1736  0, /* tp_dictoffset */
1737  0, /* tp_init */
1738  0, /* tp_alloc */
1739  0, /* tp_new */
1740  0, /* tp_free */
1741  0, /* tp_is_gc */
1742  0, /* tp_bases */
1743  0, /* tp_mro */
1744  0, /* tp_cache */
1745  0, /* tp_subclasses */
1746  0, /* tp_weaklist */
1747  0, /* tp_del */
1748  0, /* tp_version_tag */
1749 #if PY_VERSION_HEX >= 0x03040000
1750  0, /* tp_finalize */
1751 #endif
1752 #if PY_VERSION_HEX >= 0x03080000
1753  0, /* tp_vectorcall */
1754 #endif
1755 #if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
1756  0, /* tp_print */
1757 #endif
1758 #ifdef COUNT_ALLOCS
1759  0, /* tp_allocs */
1760  0, /* tp_frees */
1761  0, /* tp_maxalloc */
1762  0, /* tp_prev */
1763  0 /* tp_next */
1764 #endif
1765  };
1766  swigpyobject_type = tmp;
1767  type_init = 1;
1768  if (PyType_Ready(&swigpyobject_type) < 0)
1769  return NULL;
1770  }
1771  return &swigpyobject_type;
1772 }
1773 
1774 SWIGRUNTIME PyObject *
1775 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1776 {
1777  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1778  if (sobj) {
1779  sobj->ptr = ptr;
1780  sobj->ty = ty;
1781  sobj->own = own;
1782  sobj->next = 0;
1783  }
1784  return (PyObject *)sobj;
1785 }
1786 
1787 /* -----------------------------------------------------------------------------
1788  * Implements a simple Swig Packed type, and use it instead of string
1789  * ----------------------------------------------------------------------------- */
1790 
1791 typedef struct {
1792  PyObject_HEAD
1793  void *pack;
1795  size_t size;
1796 } SwigPyPacked;
1797 
1798 SWIGRUNTIME PyObject *
1800 {
1801  char result[SWIG_BUFFER_SIZE];
1802  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1803  return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1804  } else {
1805  return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1806  }
1807 }
1808 
1809 SWIGRUNTIME PyObject *
1811 {
1812  char result[SWIG_BUFFER_SIZE];
1813  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1814  return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1815  } else {
1816  return SWIG_Python_str_FromChar(v->ty->name);
1817  }
1818 }
1819 
1820 SWIGRUNTIME int
1822 {
1823  size_t i = v->size;
1824  size_t j = w->size;
1825  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1826  return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
1827 }
1828 
1829 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
1830 
1831 SWIGRUNTIME PyTypeObject*
1833  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
1834  return type;
1835 }
1836 
1838 SwigPyPacked_Check(PyObject *op) {
1839  return ((op)->ob_type == SwigPyPacked_TypeOnce())
1840  || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
1841 }
1842 
1843 SWIGRUNTIME void
1845 {
1846  if (SwigPyPacked_Check(v)) {
1847  SwigPyPacked *sobj = (SwigPyPacked *) v;
1848  free(sobj->pack);
1849  }
1850  PyObject_DEL(v);
1851 }
1852 
1853 SWIGRUNTIME PyTypeObject*
1855  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1856  static PyTypeObject swigpypacked_type;
1857  static int type_init = 0;
1858  if (!type_init) {
1859  const PyTypeObject tmp = {
1860 #if PY_VERSION_HEX>=0x03000000
1861  PyVarObject_HEAD_INIT(NULL, 0)
1862 #else
1863  PyObject_HEAD_INIT(NULL)
1864  0, /* ob_size */
1865 #endif
1866  "SwigPyPacked", /* tp_name */
1867  sizeof(SwigPyPacked), /* tp_basicsize */
1868  0, /* tp_itemsize */
1869  (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
1870  0, /* tp_print */
1871  (getattrfunc)0, /* tp_getattr */
1872  (setattrfunc)0, /* tp_setattr */
1873 #if PY_VERSION_HEX>=0x03000000
1874  0, /* tp_reserved in 3.0.1 */
1875 #else
1876  (cmpfunc)SwigPyPacked_compare, /* tp_compare */
1877 #endif
1878  (reprfunc)SwigPyPacked_repr, /* tp_repr */
1879  0, /* tp_as_number */
1880  0, /* tp_as_sequence */
1881  0, /* tp_as_mapping */
1882  (hashfunc)0, /* tp_hash */
1883  (ternaryfunc)0, /* tp_call */
1884  (reprfunc)SwigPyPacked_str, /* tp_str */
1885  PyObject_GenericGetAttr, /* tp_getattro */
1886  0, /* tp_setattro */
1887  0, /* tp_as_buffer */
1888  Py_TPFLAGS_DEFAULT, /* tp_flags */
1889  swigpacked_doc, /* tp_doc */
1890  0, /* tp_traverse */
1891  0, /* tp_clear */
1892  0, /* tp_richcompare */
1893  0, /* tp_weaklistoffset */
1894  0, /* tp_iter */
1895  0, /* tp_iternext */
1896  0, /* tp_methods */
1897  0, /* tp_members */
1898  0, /* tp_getset */
1899  0, /* tp_base */
1900  0, /* tp_dict */
1901  0, /* tp_descr_get */
1902  0, /* tp_descr_set */
1903  0, /* tp_dictoffset */
1904  0, /* tp_init */
1905  0, /* tp_alloc */
1906  0, /* tp_new */
1907  0, /* tp_free */
1908  0, /* tp_is_gc */
1909  0, /* tp_bases */
1910  0, /* tp_mro */
1911  0, /* tp_cache */
1912  0, /* tp_subclasses */
1913  0, /* tp_weaklist */
1914  0, /* tp_del */
1915  0, /* tp_version_tag */
1916 #if PY_VERSION_HEX >= 0x03040000
1917  0, /* tp_finalize */
1918 #endif
1919 #if PY_VERSION_HEX >= 0x03080000
1920  0, /* tp_vectorcall */
1921 #endif
1922 #if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
1923  0, /* tp_print */
1924 #endif
1925 #ifdef COUNT_ALLOCS
1926  0, /* tp_allocs */
1927  0, /* tp_frees */
1928  0, /* tp_maxalloc */
1929  0, /* tp_prev */
1930  0 /* tp_next */
1931 #endif
1932  };
1933  swigpypacked_type = tmp;
1934  type_init = 1;
1935  if (PyType_Ready(&swigpypacked_type) < 0)
1936  return NULL;
1937  }
1938  return &swigpypacked_type;
1939 }
1940 
1941 SWIGRUNTIME PyObject *
1942 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
1943 {
1944  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
1945  if (sobj) {
1946  void *pack = malloc(size);
1947  if (pack) {
1948  memcpy(pack, ptr, size);
1949  sobj->pack = pack;
1950  sobj->ty = ty;
1951  sobj->size = size;
1952  } else {
1953  PyObject_DEL((PyObject *) sobj);
1954  sobj = 0;
1955  }
1956  }
1957  return (PyObject *) sobj;
1958 }
1959 
1961 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1962 {
1963  if (SwigPyPacked_Check(obj)) {
1964  SwigPyPacked *sobj = (SwigPyPacked *)obj;
1965  if (sobj->size != size) return 0;
1966  memcpy(ptr, sobj->pack, size);
1967  return sobj->ty;
1968  } else {
1969  return 0;
1970  }
1971 }
1972 
1973 /* -----------------------------------------------------------------------------
1974  * pointers/data manipulation
1975  * ----------------------------------------------------------------------------- */
1976 
1977 static PyObject *Swig_This_global = NULL;
1978 
1979 SWIGRUNTIME PyObject *
1981 {
1982  if (Swig_This_global == NULL)
1984  return Swig_This_global;
1985 }
1986 
1987 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1988 
1989 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
1990 #if PY_VERSION_HEX>=0x03000000
1991 #define SWIG_PYTHON_SLOW_GETSET_THIS
1992 #endif
1993 
1995 SWIG_Python_GetSwigThis(PyObject *pyobj)
1996 {
1997  PyObject *obj;
1998 
1999  if (SwigPyObject_Check(pyobj))
2000  return (SwigPyObject *) pyobj;
2001 
2002 #ifdef SWIGPYTHON_BUILTIN
2003  (void)obj;
2004 # ifdef PyWeakref_CheckProxy
2005  if (PyWeakref_CheckProxy(pyobj)) {
2006  pyobj = PyWeakref_GET_OBJECT(pyobj);
2007  if (pyobj && SwigPyObject_Check(pyobj))
2008  return (SwigPyObject*) pyobj;
2009  }
2010 # endif
2011  return NULL;
2012 #else
2013 
2014  obj = 0;
2015 
2016 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2017  if (PyInstance_Check(pyobj)) {
2018  obj = _PyInstance_Lookup(pyobj, SWIG_This());
2019  } else {
2020  PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2021  if (dictptr != NULL) {
2022  PyObject *dict = *dictptr;
2023  obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2024  } else {
2025 #ifdef PyWeakref_CheckProxy
2026  if (PyWeakref_CheckProxy(pyobj)) {
2027  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2028  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2029  }
2030 #endif
2031  obj = PyObject_GetAttr(pyobj,SWIG_This());
2032  if (obj) {
2033  Py_DECREF(obj);
2034  } else {
2035  if (PyErr_Occurred()) PyErr_Clear();
2036  return 0;
2037  }
2038  }
2039  }
2040 #else
2041  obj = PyObject_GetAttr(pyobj,SWIG_This());
2042  if (obj) {
2043  Py_DECREF(obj);
2044  } else {
2045  if (PyErr_Occurred()) PyErr_Clear();
2046  return 0;
2047  }
2048 #endif
2049  if (obj && !SwigPyObject_Check(obj)) {
2050  /* a PyObject is called 'this', try to get the 'real this'
2051  SwigPyObject from it */
2052  return SWIG_Python_GetSwigThis(obj);
2053  }
2054  return (SwigPyObject *)obj;
2055 #endif
2056 }
2057 
2058 /* Acquire a pointer value */
2059 
2060 SWIGRUNTIME int
2061 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2062  if (own == SWIG_POINTER_OWN) {
2064  if (sobj) {
2065  int oldown = sobj->own;
2066  sobj->own = own;
2067  return oldown;
2068  }
2069  }
2070  return 0;
2071 }
2072 
2073 /* Convert a pointer value */
2074 
2075 SWIGRUNTIME int
2076 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2077  int res;
2078  SwigPyObject *sobj;
2079  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2080 
2081  if (!obj)
2082  return SWIG_ERROR;
2083  if (obj == Py_None && !implicit_conv) {
2084  if (ptr)
2085  *ptr = 0;
2087  }
2088 
2089  res = SWIG_ERROR;
2090 
2091  sobj = SWIG_Python_GetSwigThis(obj);
2092  if (own)
2093  *own = 0;
2094  while (sobj) {
2095  void *vptr = sobj->ptr;
2096  if (ty) {
2097  swig_type_info *to = sobj->ty;
2098  if (to == ty) {
2099  /* no type cast needed */
2100  if (ptr) *ptr = vptr;
2101  break;
2102  } else {
2103  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2104  if (!tc) {
2105  sobj = (SwigPyObject *)sobj->next;
2106  } else {
2107  if (ptr) {
2108  int newmemory = 0;
2109  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2110  if (newmemory == SWIG_CAST_NEW_MEMORY) {
2111  assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2112  if (own)
2113  *own = *own | SWIG_CAST_NEW_MEMORY;
2114  }
2115  }
2116  break;
2117  }
2118  }
2119  } else {
2120  if (ptr) *ptr = vptr;
2121  break;
2122  }
2123  }
2124  if (sobj) {
2125  if (own)
2126  *own = *own | sobj->own;
2127  if (flags & SWIG_POINTER_DISOWN) {
2128  sobj->own = 0;
2129  }
2130  res = SWIG_OK;
2131  } else {
2132  if (implicit_conv) {
2133  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2134  if (data && !data->implicitconv) {
2135  PyObject *klass = data->klass;
2136  if (klass) {
2137  PyObject *impconv;
2138  data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2139  impconv = SWIG_Python_CallFunctor(klass, obj);
2140  data->implicitconv = 0;
2141  if (PyErr_Occurred()) {
2142  PyErr_Clear();
2143  impconv = 0;
2144  }
2145  if (impconv) {
2146  SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2147  if (iobj) {
2148  void *vptr;
2149  res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2150  if (SWIG_IsOK(res)) {
2151  if (ptr) {
2152  *ptr = vptr;
2153  /* transfer the ownership to 'ptr' */
2154  iobj->own = 0;
2155  res = SWIG_AddCast(res);
2156  res = SWIG_AddNewMask(res);
2157  } else {
2158  res = SWIG_AddCast(res);
2159  }
2160  }
2161  }
2162  Py_DECREF(impconv);
2163  }
2164  }
2165  }
2166  if (!SWIG_IsOK(res) && obj == Py_None) {
2167  if (ptr)
2168  *ptr = 0;
2169  if (PyErr_Occurred())
2170  PyErr_Clear();
2171  res = SWIG_OK;
2172  }
2173  }
2174  }
2175  return res;
2176 }
2177 
2178 /* Convert a function ptr value */
2179 
2180 SWIGRUNTIME int
2181 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2182  if (!PyCFunction_Check(obj)) {
2183  return SWIG_ConvertPtr(obj, ptr, ty, 0);
2184  } else {
2185  void *vptr = 0;
2186  swig_cast_info *tc;
2187 
2188  /* here we get the method pointer for callbacks */
2189  const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2190  const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2191  if (desc)
2192  desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2193  if (!desc)
2194  return SWIG_ERROR;
2195  tc = SWIG_TypeCheck(desc,ty);
2196  if (tc) {
2197  int newmemory = 0;
2198  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2199  assert(!newmemory); /* newmemory handling not yet implemented */
2200  } else {
2201  return SWIG_ERROR;
2202  }
2203  return SWIG_OK;
2204  }
2205 }
2206 
2207 /* Convert a packed pointer value */
2208 
2209 SWIGRUNTIME int
2210 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2211  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2212  if (!to) return SWIG_ERROR;
2213  if (ty) {
2214  if (to != ty) {
2215  /* check type cast? */
2216  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2217  if (!tc) return SWIG_ERROR;
2218  }
2219  }
2220  return SWIG_OK;
2221 }
2222 
2223 /* -----------------------------------------------------------------------------
2224  * Create a new pointer object
2225  * ----------------------------------------------------------------------------- */
2226 
2227 /*
2228  Create a new instance object, without calling __init__, and set the
2229  'this' attribute.
2230 */
2231 
2232 SWIGRUNTIME PyObject*
2234 {
2235  PyObject *inst = 0;
2236  PyObject *newraw = data->newraw;
2237  if (newraw) {
2238  inst = PyObject_Call(newraw, data->newargs, NULL);
2239  if (inst) {
2240 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2241  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2242  if (dictptr != NULL) {
2243  PyObject *dict = *dictptr;
2244  if (dict == NULL) {
2245  dict = PyDict_New();
2246  *dictptr = dict;
2247  PyDict_SetItem(dict, SWIG_This(), swig_this);
2248  }
2249  }
2250 #else
2251  if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2252  Py_DECREF(inst);
2253  inst = 0;
2254  }
2255 #endif
2256  }
2257  } else {
2258 #if PY_VERSION_HEX >= 0x03000000
2259  PyObject *empty_args = PyTuple_New(0);
2260  if (empty_args) {
2261  PyObject *empty_kwargs = PyDict_New();
2262  if (empty_kwargs) {
2263  inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
2264  Py_DECREF(empty_kwargs);
2265  if (inst) {
2266  if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2267  Py_DECREF(inst);
2268  inst = 0;
2269  } else {
2270  Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2271  }
2272  }
2273  }
2274  Py_DECREF(empty_args);
2275  }
2276 #else
2277  PyObject *dict = PyDict_New();
2278  if (dict) {
2279  PyDict_SetItem(dict, SWIG_This(), swig_this);
2280  inst = PyInstance_NewRaw(data->newargs, dict);
2281  Py_DECREF(dict);
2282  }
2283 #endif
2284  }
2285  return inst;
2286 }
2287 
2288 SWIGRUNTIME int
2289 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2290 {
2291 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2292  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2293  if (dictptr != NULL) {
2294  PyObject *dict = *dictptr;
2295  if (dict == NULL) {
2296  dict = PyDict_New();
2297  *dictptr = dict;
2298  }
2299  return PyDict_SetItem(dict, SWIG_This(), swig_this);
2300  }
2301 #endif
2302  return PyObject_SetAttr(inst, SWIG_This(), swig_this);
2303 }
2304 
2305 
2306 SWIGINTERN PyObject *
2308  PyObject *obj[2];
2309  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2310  return NULL;
2311  } else {
2312  SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2313  if (sthis) {
2314  SwigPyObject_append((PyObject*) sthis, obj[1]);
2315  } else {
2316  if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
2317  return NULL;
2318  }
2319  return SWIG_Py_Void();
2320  }
2321 }
2322 
2323 /* Create a new pointer object */
2324 
2325 SWIGRUNTIME PyObject *
2326 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2327  SwigPyClientData *clientdata;
2328  PyObject * robj;
2329  int own;
2330 
2331  if (!ptr)
2332  return SWIG_Py_Void();
2333 
2334  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2335  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2336  if (clientdata && clientdata->pytype) {
2337  SwigPyObject *newobj;
2338  if (flags & SWIG_BUILTIN_TP_INIT) {
2339  newobj = (SwigPyObject*) self;
2340  if (newobj->ptr) {
2341  PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2342  while (newobj->next)
2343  newobj = (SwigPyObject *) newobj->next;
2344  newobj->next = next_self;
2345  newobj = (SwigPyObject *)next_self;
2346 #ifdef SWIGPYTHON_BUILTIN
2347  newobj->dict = 0;
2348 #endif
2349  }
2350  } else {
2351  newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2352 #ifdef SWIGPYTHON_BUILTIN
2353  newobj->dict = 0;
2354 #endif
2355  }
2356  if (newobj) {
2357  newobj->ptr = ptr;
2358  newobj->ty = type;
2359  newobj->own = own;
2360  newobj->next = 0;
2361  return (PyObject*) newobj;
2362  }
2363  return SWIG_Py_Void();
2364  }
2365 
2366  assert(!(flags & SWIG_BUILTIN_TP_INIT));
2367 
2368  robj = SwigPyObject_New(ptr, type, own);
2369  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2370  PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2371  Py_DECREF(robj);
2372  robj = inst;
2373  }
2374  return robj;
2375 }
2376 
2377 /* Create a new packed object */
2378 
2379 SWIGRUNTIMEINLINE PyObject *
2380 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2381  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2382 }
2383 
2384 /* -----------------------------------------------------------------------------*
2385  * Get type list
2386  * -----------------------------------------------------------------------------*/
2387 
2388 #ifdef SWIG_LINK_RUNTIME
2389 void *SWIG_ReturnGlobalTypeList(void *);
2390 #endif
2391 
2394  static void *type_pointer = (void *)0;
2395  /* first check if module already created */
2396  if (!type_pointer) {
2397 #ifdef SWIG_LINK_RUNTIME
2398  type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2399 #else
2400  type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2401  if (PyErr_Occurred()) {
2402  PyErr_Clear();
2403  type_pointer = (void *)0;
2404  }
2405 #endif
2406  }
2407  return (swig_module_info *) type_pointer;
2408 }
2409 
2410 SWIGRUNTIME void
2412 {
2413  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2414  swig_type_info **types = swig_module->types;
2415  size_t i;
2416  for (i =0; i < swig_module->size; ++i) {
2417  swig_type_info *ty = types[i];
2418  if (ty->owndata) {
2420  if (data) SwigPyClientData_Del(data);
2421  }
2422  }
2423  Py_DECREF(SWIG_This());
2424  Swig_This_global = NULL;
2425 }
2426 
2427 SWIGRUNTIME void
2429 #if PY_VERSION_HEX >= 0x03000000
2430  /* Add a dummy module object into sys.modules */
2431  PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
2432 #else
2433  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2434  PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2435 #endif
2436  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2437  if (pointer && module) {
2438  PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2439  } else {
2440  Py_XDECREF(pointer);
2441  }
2442 }
2443 
2444 /* The python cached type query */
2445 SWIGRUNTIME PyObject *
2447  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2448  return cache;
2449 }
2450 
2452 SWIG_Python_TypeQuery(const char *type)
2453 {
2454  PyObject *cache = SWIG_Python_TypeCache();
2455  PyObject *key = SWIG_Python_str_FromChar(type);
2456  PyObject *obj = PyDict_GetItem(cache, key);
2457  swig_type_info *descriptor;
2458  if (obj) {
2459  descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2460  } else {
2462  descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2463  if (descriptor) {
2464  obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2465  PyDict_SetItem(cache, key, obj);
2466  Py_DECREF(obj);
2467  }
2468  }
2469  Py_DECREF(key);
2470  return descriptor;
2471 }
2472 
2473 /*
2474  For backward compatibility only
2475 */
2476 #define SWIG_POINTER_EXCEPTION 0
2477 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2478 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2479 
2480 SWIGRUNTIME int
2481 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2482 {
2483  if (PyErr_Occurred()) {
2484  PyObject *type = 0;
2485  PyObject *value = 0;
2486  PyObject *traceback = 0;
2487  PyErr_Fetch(&type, &value, &traceback);
2488  if (value) {
2489  PyObject *old_str = PyObject_Str(value);
2490  const char *tmp = SWIG_Python_str_AsChar(old_str);
2491  const char *errmesg = tmp ? tmp : "Invalid error message";
2492  Py_XINCREF(type);
2493  PyErr_Clear();
2494  if (infront) {
2495  PyErr_Format(type, "%s %s", mesg, errmesg);
2496  } else {
2497  PyErr_Format(type, "%s %s", errmesg, mesg);
2498  }
2500  Py_DECREF(old_str);
2501  }
2502  return 1;
2503  } else {
2504  return 0;
2505  }
2506 }
2507 
2508 SWIGRUNTIME int
2510 {
2511  if (PyErr_Occurred()) {
2512  /* add information about failing argument */
2513  char mesg[256];
2514  PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2515  return SWIG_Python_AddErrMesg(mesg, 1);
2516  } else {
2517  return 0;
2518  }
2519 }
2520 
2521 SWIGRUNTIMEINLINE const char *
2522 SwigPyObject_GetDesc(PyObject *self)
2523 {
2524  SwigPyObject *v = (SwigPyObject *)self;
2525  swig_type_info *ty = v ? v->ty : 0;
2526  return ty ? ty->str : "";
2527 }
2528 
2529 SWIGRUNTIME void
2530 SWIG_Python_TypeError(const char *type, PyObject *obj)
2531 {
2532  if (type) {
2533 #if defined(SWIG_COBJECT_TYPES)
2534  if (obj && SwigPyObject_Check(obj)) {
2535  const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2536  if (otype) {
2537  PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2538  type, otype);
2539  return;
2540  }
2541  } else
2542 #endif
2543  {
2544  const char *otype = (obj ? obj->ob_type->tp_name : 0);
2545  if (otype) {
2546  PyObject *str = PyObject_Str(obj);
2547  const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2548  if (cstr) {
2549  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2550  type, otype, cstr);
2552  } else {
2553  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2554  type, otype);
2555  }
2556  Py_XDECREF(str);
2557  return;
2558  }
2559  }
2560  PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2561  } else {
2562  PyErr_Format(PyExc_TypeError, "unexpected type is received");
2563  }
2564 }
2565 
2566 
2567 /* Convert a pointer value, signal an exception on a type mismatch */
2568 SWIGRUNTIME void *
2569 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2570  void *result;
2571  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2572  PyErr_Clear();
2573 #if SWIG_POINTER_EXCEPTION
2574  if (flags) {
2576  SWIG_Python_ArgFail(argnum);
2577  }
2578 #endif
2579  }
2580  return result;
2581 }
2582 
2583 #ifdef SWIGPYTHON_BUILTIN
2584 SWIGRUNTIME int
2585 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2586  PyTypeObject *tp = obj->ob_type;
2587  PyObject *descr;
2588  PyObject *encoded_name;
2589  descrsetfunc f;
2590  int res = -1;
2591 
2592 # ifdef Py_USING_UNICODE
2593  if (PyString_Check(name)) {
2594  name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2595  if (!name)
2596  return -1;
2597  } else if (!PyUnicode_Check(name))
2598 # else
2599  if (!PyString_Check(name))
2600 # endif
2601  {
2602  PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2603  return -1;
2604  } else {
2605  Py_INCREF(name);
2606  }
2607 
2608  if (!tp->tp_dict) {
2609  if (PyType_Ready(tp) < 0)
2610  goto done;
2611  }
2612 
2613  descr = _PyType_Lookup(tp, name);
2614  f = NULL;
2615  if (descr != NULL)
2616  f = descr->ob_type->tp_descr_set;
2617  if (!f) {
2618  if (PyString_Check(name)) {
2619  encoded_name = name;
2620  Py_INCREF(name);
2621  } else {
2622  encoded_name = PyUnicode_AsUTF8String(name);
2623  if (!encoded_name)
2624  return -1;
2625  }
2626  PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2627  Py_DECREF(encoded_name);
2628  } else {
2629  res = f(descr, obj, value);
2630  }
2631 
2632  done:
2633  Py_DECREF(name);
2634  return res;
2635 }
2636 #endif
2637 
2638 
2639 #ifdef __cplusplus
2640 }
2641 #endif
2642 
2643 
2644 
2645 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2646 
2647 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2648 
2649 
2650 
2651 #ifdef __cplusplus
2652 extern "C" {
2653 #endif
2654 
2655 /* Method creation and docstring support functions */
2656 
2657 SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name);
2658 SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
2659 SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
2660 
2661 #ifdef __cplusplus
2662 }
2663 #endif
2664 
2665 
2666 /* -------- TYPES TABLE (BEGIN) -------- */
2667 
2668 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2669 #define SWIGTYPE_p_PLcGrid swig_types[1]
2670 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
2671 #define SWIGTYPE_p_char swig_types[3]
2672 #define SWIGTYPE_p_double swig_types[4]
2673 #define SWIGTYPE_p_f_double_double__int swig_types[5]
2674 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
2675 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
2676 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
2677 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
2678 #define SWIGTYPE_p_int swig_types[10]
2679 #define SWIGTYPE_p_p_char swig_types[11]
2680 #define SWIGTYPE_p_p_double swig_types[12]
2681 #define SWIGTYPE_p_unsigned_int swig_types[13]
2683 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
2684 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2685 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2686 
2687 /* -------- TYPES TABLE (END) -------- */
2688 
2689 #ifdef SWIG_TypeQuery
2690 # undef SWIG_TypeQuery
2691 #endif
2692 #define SWIG_TypeQuery SWIG_Python_TypeQuery
2693 
2694 /*-----------------------------------------------
2695  @(target):= _plplotc.so
2696  ------------------------------------------------*/
2697 #if PY_VERSION_HEX >= 0x03000000
2698 # define SWIG_init PyInit__plplotc
2699 
2700 #else
2701 # define SWIG_init init_plplotc
2702 
2703 #endif
2704 #define SWIG_name "_plplotc"
2705 
2706 #define SWIGVERSION 0x040002
2707 #define SWIG_VERSION SWIGVERSION
2708 
2709 
2710 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2711 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2712 
2713 
2714 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
2715 #include <arrayobject.h>
2716 #include "plplot.h"
2717 #include "plplotP.h"
2718 
2719 #define NPY_PLINT NPY_INT32
2720 
2721 #ifdef PL_DOUBLE
2722 #define NPY_PLFLT NPY_FLOAT64
2723 #else
2724 #define NPY_PLFLT NPY_FLOAT32
2725 #endif
2726 
2727 // python-1.5 compatibility mode?
2728 #if !defined ( PySequence_Fast_GET_ITEM )
2729  #define PySequence_Fast_GET_ITEM PySequence_GetItem
2730 #endif
2731 #define PySequence_Size PySequence_Length
2732 
2733 
2734  static PLINT Alen = 0;
2735  static PLINT Xlen = 0, Ylen = 0;
2736 
2737 
2738 SWIGINTERN int
2739 SWIG_AsVal_double (PyObject *obj, double *val)
2740 {
2741  int res = SWIG_TypeError;
2742  if (PyFloat_Check(obj)) {
2743  if (val) *val = PyFloat_AsDouble(obj);
2744  return SWIG_OK;
2745 #if PY_VERSION_HEX < 0x03000000
2746  } else if (PyInt_Check(obj)) {
2747  if (val) *val = (double) PyInt_AsLong(obj);
2748  return SWIG_OK;
2749 #endif
2750  } else if (PyLong_Check(obj)) {
2751  double v = PyLong_AsDouble(obj);
2752  if (!PyErr_Occurred()) {
2753  if (val) *val = v;
2754  return SWIG_OK;
2755  } else {
2756  PyErr_Clear();
2757  }
2758  }
2759 #ifdef SWIG_PYTHON_CAST_MODE
2760  {
2761  int dispatch = 0;
2762  double d = PyFloat_AsDouble(obj);
2763  if (!PyErr_Occurred()) {
2764  if (val) *val = d;
2765  return SWIG_AddCast(SWIG_OK);
2766  } else {
2767  PyErr_Clear();
2768  }
2769  if (!dispatch) {
2770  long v = PyLong_AsLong(obj);
2771  if (!PyErr_Occurred()) {
2772  if (val) *val = v;
2774  } else {
2775  PyErr_Clear();
2776  }
2777  }
2778  }
2779 #endif
2780  return res;
2781 }
2782 
2783 
2784  #define SWIG_From_double PyFloat_FromDouble
2785 
2786 
2787  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2788  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2789  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2790  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2791  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2793  typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
2794 
2795 
2796 SWIGINTERNINLINE PyObject*
2798 {
2799  return PyInt_FromLong((long) value);
2800 }
2801 
2802 
2803 #include <limits.h>
2804 #if !defined(SWIG_NO_LLONG_MAX)
2805 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2806 # define LLONG_MAX __LONG_LONG_MAX__
2807 # define LLONG_MIN (-LLONG_MAX - 1LL)
2808 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2809 # endif
2810 #endif
2811 
2812 
2813 #include <float.h>
2814 
2815 
2816 #include <math.h>
2817 
2818 
2819 SWIGINTERNINLINE int
2820 SWIG_CanCastAsInteger(double *d, double min, double max) {
2821  double x = *d;
2822  if ((min <= x && x <= max)) {
2823  double fx = floor(x);
2824  double cx = ceil(x);
2825  double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2826  if ((errno == EDOM) || (errno == ERANGE)) {
2827  errno = 0;
2828  } else {
2829  double summ, reps, diff;
2830  if (rd < x) {
2831  diff = x - rd;
2832  } else if (rd > x) {
2833  diff = rd - x;
2834  } else {
2835  return 1;
2836  }
2837  summ = rd + x;
2838  reps = diff/summ;
2839  if (reps < 8*DBL_EPSILON) {
2840  *d = rd;
2841  return 1;
2842  }
2843  }
2844  }
2845  return 0;
2846 }
2847 
2848 
2849 SWIGINTERN int
2850 SWIG_AsVal_long (PyObject *obj, long* val)
2851 {
2852 #if PY_VERSION_HEX < 0x03000000
2853  if (PyInt_Check(obj)) {
2854  if (val) *val = PyInt_AsLong(obj);
2855  return SWIG_OK;
2856  } else
2857 #endif
2858  if (PyLong_Check(obj)) {
2859  long v = PyLong_AsLong(obj);
2860  if (!PyErr_Occurred()) {
2861  if (val) *val = v;
2862  return SWIG_OK;
2863  } else {
2864  PyErr_Clear();
2865  return SWIG_OverflowError;
2866  }
2867  }
2868 #ifdef SWIG_PYTHON_CAST_MODE
2869  {
2870  int dispatch = 0;
2871  long v = PyInt_AsLong(obj);
2872  if (!PyErr_Occurred()) {
2873  if (val) *val = v;
2874  return SWIG_AddCast(SWIG_OK);
2875  } else {
2876  PyErr_Clear();
2877  }
2878  if (!dispatch) {
2879  double d;
2880  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2881  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2882  if (val) *val = (long)(d);
2883  return res;
2884  }
2885  }
2886  }
2887 #endif
2888  return SWIG_TypeError;
2889 }
2890 
2891 
2892 SWIGINTERN int
2893 SWIG_AsVal_int (PyObject * obj, int *val)
2894 {
2895  long v;
2896  int res = SWIG_AsVal_long (obj, &v);
2897  if (SWIG_IsOK(res)) {
2898  if ((v < INT_MIN || v > INT_MAX)) {
2899  return SWIG_OverflowError;
2900  } else {
2901  if (val) *val = (int)(v);
2902  }
2903  }
2904  return res;
2905 }
2906 
2907 
2908 SWIGINTERN int
2909 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
2910 {
2911 #if PY_VERSION_HEX < 0x03000000
2912  if (PyInt_Check(obj)) {
2913  long v = PyInt_AsLong(obj);
2914  if (v >= 0) {
2915  if (val) *val = v;
2916  return SWIG_OK;
2917  } else {
2918  return SWIG_OverflowError;
2919  }
2920  } else
2921 #endif
2922  if (PyLong_Check(obj)) {
2923  unsigned long v = PyLong_AsUnsignedLong(obj);
2924  if (!PyErr_Occurred()) {
2925  if (val) *val = v;
2926  return SWIG_OK;
2927  } else {
2928  PyErr_Clear();
2929  return SWIG_OverflowError;
2930  }
2931  }
2932 #ifdef SWIG_PYTHON_CAST_MODE
2933  {
2934  int dispatch = 0;
2935  unsigned long v = PyLong_AsUnsignedLong(obj);
2936  if (!PyErr_Occurred()) {
2937  if (val) *val = v;
2938  return SWIG_AddCast(SWIG_OK);
2939  } else {
2940  PyErr_Clear();
2941  }
2942  if (!dispatch) {
2943  double d;
2944  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2945  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2946  if (val) *val = (unsigned long)(d);
2947  return res;
2948  }
2949  }
2950  }
2951 #endif
2952  return SWIG_TypeError;
2953 }
2954 
2955 
2956 SWIGINTERN int
2957 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
2958 {
2959  unsigned long v;
2960  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2961  if (SWIG_IsOK(res)) {
2962  if ((v > UINT_MAX)) {
2963  return SWIG_OverflowError;
2964  } else {
2965  if (val) *val = (unsigned int)(v);
2966  }
2967  }
2968  return res;
2969 }
2970 
2971 
2972 SWIGINTERNINLINE PyObject*
2974 {
2975  return PyInt_FromSize_t((size_t) value);
2976 }
2977 
2978 
2981 {
2982  static int init = 0;
2983  static swig_type_info* info = 0;
2984  if (!init) {
2985  info = SWIG_TypeQuery("_p_char");
2986  init = 1;
2987  }
2988  return info;
2989 }
2990 
2991 
2992 SWIGINTERN int
2993 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
2994 {
2995 #if PY_VERSION_HEX>=0x03000000
2996 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
2997  if (PyBytes_Check(obj))
2998 #else
2999  if (PyUnicode_Check(obj))
3000 #endif
3001 #else
3002  if (PyString_Check(obj))
3003 #endif
3004  {
3005  char *cstr; Py_ssize_t len;
3006  int ret = SWIG_OK;
3007 #if PY_VERSION_HEX>=0x03000000
3008 #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3009  if (!alloc && cptr) {
3010  /* We can't allow converting without allocation, since the internal
3011  representation of string in Python 3 is UCS-2/UCS-4 but we require
3012  a UTF-8 representation.
3013  TODO(bhy) More detailed explanation */
3014  return SWIG_RuntimeError;
3015  }
3016  obj = PyUnicode_AsUTF8String(obj);
3017  if (!obj)
3018  return SWIG_TypeError;
3019  if (alloc)
3020  *alloc = SWIG_NEWOBJ;
3021 #endif
3022  if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
3023  return SWIG_TypeError;
3024 #else
3025  if (PyString_AsStringAndSize(obj, &cstr, &len) == -1)
3026  return SWIG_TypeError;
3027 #endif
3028  if (cptr) {
3029  if (alloc) {
3030  if (*alloc == SWIG_NEWOBJ) {
3031  *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3032  *alloc = SWIG_NEWOBJ;
3033  } else {
3034  *cptr = cstr;
3035  *alloc = SWIG_OLDOBJ;
3036  }
3037  } else {
3038 #if PY_VERSION_HEX>=0x03000000
3039 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3040  *cptr = PyBytes_AsString(obj);
3041 #else
3042  assert(0); /* Should never reach here with Unicode strings in Python 3 */
3043 #endif
3044 #else
3045  *cptr = SWIG_Python_str_AsChar(obj);
3046  if (!*cptr)
3047  ret = SWIG_TypeError;
3048 #endif
3049  }
3050  }
3051  if (psize) *psize = len + 1;
3052 #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3053  Py_XDECREF(obj);
3054 #endif
3055  return ret;
3056  } else {
3057 #if defined(SWIG_PYTHON_2_UNICODE)
3058 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3059 #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3060 #endif
3061 #if PY_VERSION_HEX<0x03000000
3062  if (PyUnicode_Check(obj)) {
3063  char *cstr; Py_ssize_t len;
3064  if (!alloc && cptr) {
3065  return SWIG_RuntimeError;
3066  }
3067  obj = PyUnicode_AsUTF8String(obj);
3068  if (!obj)
3069  return SWIG_TypeError;
3070  if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3071  if (cptr) {
3072  if (alloc) *alloc = SWIG_NEWOBJ;
3073  *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3074  }
3075  if (psize) *psize = len + 1;
3076 
3077  Py_XDECREF(obj);
3078  return SWIG_OK;
3079  } else {
3080  Py_XDECREF(obj);
3081  }
3082  }
3083 #endif
3084 #endif
3085 
3086  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3087  if (pchar_descriptor) {
3088  void* vptr = 0;
3089  if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3090  if (cptr) *cptr = (char *) vptr;
3091  if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3092  if (alloc) *alloc = SWIG_OLDOBJ;
3093  return SWIG_OK;
3094  }
3095  }
3096  }
3097  return SWIG_TypeError;
3098 }
3099 
3100 
3101 SWIGINTERN int
3102 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3103 {
3104  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3105  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3106  if (SWIG_IsOK(res)) {
3107  /* special case of single char conversion when we don't need space for NUL */
3108  if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3109  if (csize <= size) {
3110  if (val) {
3111  if (csize) memcpy(val, cptr, csize*sizeof(char));
3112  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3113  }
3114  if (alloc == SWIG_NEWOBJ) {
3115  free((char*)cptr);
3116  res = SWIG_DelNewMask(res);
3117  }
3118  return res;
3119  }
3120  if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3121  }
3122  return SWIG_TypeError;
3123 }
3124 
3125 
3126 SWIGINTERNINLINE PyObject *
3127 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3128 {
3129  if (carray) {
3130  if (size > INT_MAX) {
3131  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3132  return pchar_descriptor ?
3133  SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3134  } else {
3135 #if PY_VERSION_HEX >= 0x03000000
3136 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3137  return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3138 #else
3139  return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3140 #endif
3141 #else
3142  return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3143 #endif
3144  }
3145  } else {
3146  return SWIG_Py_Void();
3147  }
3148 }
3149 
3150 
3151 SWIGINTERN size_t
3152 SWIG_strnlen(const char* s, size_t maxlen)
3153 {
3154  const char *p;
3155  for (p = s; maxlen-- && *p; p++)
3156  ;
3157  return p - s;
3158 }
3159 
3160 
3161 
3162 
3163 
3164 #define t_output_helper SWIG_Python_AppendOutput
3165 
3166 
3167 SWIGINTERN int
3168 SWIG_AsVal_char (PyObject * obj, char *val)
3169 {
3170  int res = SWIG_AsCharArray(obj, val, 1);
3171  if (!SWIG_IsOK(res)) {
3172  long v;
3173  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3174  if (SWIG_IsOK(res)) {
3175  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3176  if (val) *val = (char)(v);
3177  } else {
3178  res = SWIG_OverflowError;
3179  }
3180  }
3181  }
3182  return res;
3183 }
3184 
3185 #ifdef __cplusplus
3186 extern "C" {
3187 #endif
3188 
3189  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3190 
3191 // some really twisted stuff to allow calling a single precision library from python
3192  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3193  {
3194  PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3195  mindims, maxdims );
3196  if ( !tmp )
3197  {
3198  // could be an incoming long array which can't be "safely" converted, do it anyway
3199  if ( PyArray_Check( in ) )
3200  {
3201  PyErr_Clear();
3202  tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3203  }
3204  }
3205  return tmp;
3206  }
3207 
3208 
3209 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3210 
3211 SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3212  PyObject *resultobj = 0;
3213  PLFLT arg1 ;
3214  PLFLT arg2 ;
3215  PLFLT *arg3 = (PLFLT *) 0 ;
3216  PLFLT *arg4 = (PLFLT *) 0 ;
3217  PLPointer arg5 = (PLPointer) 0 ;
3218  double val1 ;
3219  int ecode1 = 0 ;
3220  double val2 ;
3221  int ecode2 = 0 ;
3222  PLFLT temp3 ;
3223  int res3 = SWIG_TMPOBJ ;
3224  PLFLT temp4 ;
3225  int res4 = SWIG_TMPOBJ ;
3226  PyObject *swig_obj[2] ;
3227 
3228  arg3 = &temp3;
3229  arg4 = &temp4;
3230  {
3231  arg5 = NULL;
3232  }
3233  if (!SWIG_Python_UnpackTuple(args, "pltr0", 2, 2, swig_obj)) SWIG_fail;
3234  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3235  if (!SWIG_IsOK(ecode1)) {
3236  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3237  }
3238  arg1 = (PLFLT)(val1);
3239  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3240  if (!SWIG_IsOK(ecode2)) {
3241  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3242  }
3243  arg2 = (PLFLT)(val2);
3244  pltr0(arg1,arg2,arg3,arg4,arg5);
3245  resultobj = SWIG_Py_Void();
3246  if (SWIG_IsTmpObj(res3)) {
3247  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3248  } else {
3249  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3250  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3251  }
3252  if (SWIG_IsTmpObj(res4)) {
3253  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3254  } else {
3255  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3256  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3257  }
3258  return resultobj;
3259 fail:
3260  return NULL;
3261 }
3262 
3263 
3264 
3265  PyArrayObject *pltr_xg, *pltr_yg;
3268 
3269  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3270  void cleanup_PLcGrid1( void );
3271  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3272  void cleanup_PLcGrid2( void );
3273 
3274  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3275  {
3276  // fprintf(stderr, "marshal PLcGrid1\n");
3277  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3278  {
3279  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3280  return NULL;
3281  }
3282  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3283  NPY_PLFLT, 1, 1 );
3284  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3285  NPY_PLFLT, 1, 1 );
3286  if ( pltr_xg == 0 || pltr_yg == 0 )
3287  {
3288  PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3289  return NULL;
3290  }
3291  tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3292  tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3293  if ( isimg == 0 )
3294  {
3295  if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3296  {
3297  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3298  return NULL;
3299  }
3300  }
3301  else
3302  {
3303  if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3304  {
3305  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3306  return NULL;
3307  }
3308  }
3309  tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3310  tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3311  return &tmpGrid1;
3312  }
3313 
3314  void cleanup_PLcGrid1( void )
3315  {
3316  // fprintf(stderr, "cleanup PLcGrid1\n");
3317  Py_CLEAR( pltr_xg );
3318  Py_CLEAR( pltr_yg );
3319  }
3320 
3321  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3322  {
3323  int i, size;
3324  // fprintf(stderr, "marshal PLcGrid2\n");
3325  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3326  {
3327  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3328  return NULL;
3329  }
3330  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3331  NPY_PLFLT, 2, 2 );
3332  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3333  NPY_PLFLT, 2, 2 );
3334  if ( pltr_xg == 0 || pltr_yg == 0 )
3335  {
3336  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3337  return NULL;
3338  }
3339  if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3340  PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3341  {
3342  PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3343  return NULL;
3344  }
3345  tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3346  tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3347  if ( isimg == 0 )
3348  {
3349  if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3350  {
3351  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3352  return NULL;
3353  }
3354  }
3355  else
3356  {
3357  if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3358  {
3359  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3360  return NULL;
3361  }
3362  }
3363  size = tmpGrid2.ny;
3364  tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3365  for ( i = 0; i < tmpGrid2.nx; i++ )
3366  tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3367  tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3368  for ( i = 0; i < tmpGrid2.nx; i++ )
3369  tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3370  return &tmpGrid2;
3371  }
3372 
3373  void cleanup_PLcGrid2( void )
3374  {
3375  // fprintf(stderr, "cleanup PLcGrid2\n");
3376  free( tmpGrid2.xg );
3377  free( tmpGrid2.yg );
3378  Py_CLEAR( pltr_xg );
3379  Py_CLEAR( pltr_yg );
3380  }
3381 
3382 SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3383  PyObject *resultobj = 0;
3384  PLFLT arg1 ;
3385  PLFLT arg2 ;
3386  PLFLT *arg3 = (PLFLT *) 0 ;
3387  PLFLT *arg4 = (PLFLT *) 0 ;
3388  PLcGrid *arg5 = (PLcGrid *) 0 ;
3389  double val1 ;
3390  int ecode1 = 0 ;
3391  double val2 ;
3392  int ecode2 = 0 ;
3393  PLFLT temp3 ;
3394  int res3 = SWIG_TMPOBJ ;
3395  PLFLT temp4 ;
3396  int res4 = SWIG_TMPOBJ ;
3397  PyObject *swig_obj[3] ;
3398 
3399  arg3 = &temp3;
3400  arg4 = &temp4;
3401  if (!SWIG_Python_UnpackTuple(args, "pltr1", 3, 3, swig_obj)) SWIG_fail;
3402  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3403  if (!SWIG_IsOK(ecode1)) {
3404  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3405  }
3406  arg1 = (PLFLT)(val1);
3407  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3408  if (!SWIG_IsOK(ecode2)) {
3409  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3410  }
3411  arg2 = (PLFLT)(val2);
3412  {
3413  arg5 = marshal_PLcGrid1( swig_obj[2], 0 );
3414  if ( !arg5 )
3415  return NULL;
3416  }
3417  pltr1(arg1,arg2,arg3,arg4,arg5);
3418  resultobj = SWIG_Py_Void();
3419  if (SWIG_IsTmpObj(res3)) {
3420  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3421  } else {
3422  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3423  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3424  }
3425  if (SWIG_IsTmpObj(res4)) {
3426  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3427  } else {
3428  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3429  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3430  }
3431  {
3432  cleanup_PLcGrid1();
3433  }
3434  return resultobj;
3435 fail:
3436  {
3437  cleanup_PLcGrid1();
3438  }
3439  return NULL;
3440 }
3441 
3442 
3443 SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3444  PyObject *resultobj = 0;
3445  PLFLT arg1 ;
3446  PLFLT arg2 ;
3447  PLFLT *arg3 = (PLFLT *) 0 ;
3448  PLFLT *arg4 = (PLFLT *) 0 ;
3449  PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3450  double val1 ;
3451  int ecode1 = 0 ;
3452  double val2 ;
3453  int ecode2 = 0 ;
3454  PLFLT temp3 ;
3455  int res3 = SWIG_TMPOBJ ;
3456  PLFLT temp4 ;
3457  int res4 = SWIG_TMPOBJ ;
3458  PyObject *swig_obj[3] ;
3459 
3460  arg3 = &temp3;
3461  arg4 = &temp4;
3462  if (!SWIG_Python_UnpackTuple(args, "pltr2", 3, 3, swig_obj)) SWIG_fail;
3463  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3464  if (!SWIG_IsOK(ecode1)) {
3465  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3466  }
3467  arg1 = (PLFLT)(val1);
3468  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3469  if (!SWIG_IsOK(ecode2)) {
3470  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3471  }
3472  arg2 = (PLFLT)(val2);
3473  {
3474  arg5 = marshal_PLcGrid2( swig_obj[2], 0 );
3475  if ( !arg5 )
3476  return NULL;
3477  }
3478  pltr2(arg1,arg2,arg3,arg4,arg5);
3479  resultobj = SWIG_Py_Void();
3480  if (SWIG_IsTmpObj(res3)) {
3481  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3482  } else {
3483  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3484  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3485  }
3486  if (SWIG_IsTmpObj(res4)) {
3487  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3488  } else {
3489  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3490  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3491  }
3492  {
3493  cleanup_PLcGrid2();
3494  }
3495  return resultobj;
3496 fail:
3497  {
3498  cleanup_PLcGrid2();
3499  }
3500  return NULL;
3501 }
3502 
3503 
3504 
3505  // helper code for handling the callback
3506 #if 0
3507  static PyInterpreterState *save_interp = NULL;
3508 #endif
3510  PyObject* python_pltr = NULL;
3511  PyObject* python_f2eval = NULL;
3512  PyObject* python_ct = NULL;
3513  PyObject* python_mapform = NULL;
3514  PyObject* python_label = NULL;
3515 
3516 #if 0
3517 #define MY_BLOCK_THREADS { \
3518  PyThreadState *prev_state, *new_state; \
3519  /* need to have started a thread at some stage */ \
3520  /* for the following to work */ \
3521  PyEval_AcquireLock(); \
3522  new_state = PyThreadState_New( save_interp ); \
3523  prev_state = PyThreadState_Swap( new_state );
3524 #define MY_UNBLOCK_THREADS \
3525  new_state = PyThreadState_Swap( prev_state ); \
3526  PyThreadState_Clear( new_state ); \
3527  PyEval_ReleaseLock(); \
3528  PyThreadState_Delete( new_state ); \
3529  }
3530 #else
3531 #define MY_BLOCK_THREADS
3532 #define MY_UNBLOCK_THREADS
3533 #endif
3534 
3535 // Function prototypes
3536  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
3538  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
3539  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
3540  void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
3541  pltr_func marshal_pltr( PyObject* input );
3542  void cleanup_pltr( void );
3543  ct_func marshal_ct( PyObject* input );
3544  void cleanup_ct( void );
3545  mapform_func marshal_mapform( PyObject* input );
3546  void cleanup_mapform( void );
3547  PLPointer marshal_PLPointer( PyObject* input, int isimg );
3548  void cleanup_PLPointer( void );
3549 
3550 
3551 // This is the callback that gets handed to the C code. It, in turn, calls the Python callback
3552 
3553  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
3554  {
3555  PyObject *pdata, *arglist, *result;
3556  PyArrayObject *tmp;
3557 
3558  // the data argument is acutally a pointer to a python object
3559  pdata = (PyObject *) data;
3560  if ( data == NULL )
3561  {
3562  pdata = Py_None;
3563  }
3564  if ( python_pltr ) // if not something is terribly wrong
3565  { // hold a reference to the data object
3566  Py_XINCREF( pdata );
3567  // grab the Global Interpreter Lock to be sure threads don't mess us up
3569  // build the argument list
3570 #ifdef PL_DOUBLE
3571  arglist = Py_BuildValue( "(ddO)", x, y, pdata );
3572 #else
3573  arglist = Py_BuildValue( "(ffO)", x, y, pdata );
3574 #endif
3575  if ( arglist == NULL )
3576  {
3577  fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
3578  *tx = *ty = 0;
3579  return;
3580  }
3581  // call the python function
3582  result = PyEval_CallObject( python_pltr, arglist );
3583  // release the argument list
3584  Py_CLEAR( arglist );
3585  // check and unpack the result
3586  if ( result == NULL )
3587  {
3588  fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
3589  PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 arguments." );
3590  *tx = *ty = 0;
3591  }
3592  else
3593  {
3594  tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
3595  if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3596  {
3597  fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
3598  PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
3599  *tx = *ty = 0;
3600  }
3601  else
3602  {
3603  PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3604  *tx = t[0];
3605  *ty = t[1];
3606  Py_CLEAR( tmp );
3607  }
3608  }
3609  // release the result
3610  Py_CLEAR( result );
3611  // release the global interpreter lock
3613  }
3614  }
3615 
3617  {
3618  PyObject *pdata, *arglist, *result;
3619  PLFLT fresult = 0.0;
3620 
3621  // the data argument is acutally a pointer to a python object
3622  pdata = (PyObject *) data;
3623  if ( python_f2eval ) // if not something is terribly wrong
3624  { // hold a reference to the data object
3625  Py_XINCREF( pdata );
3626  // grab the Global Interpreter Lock to be sure threads don't mess us up
3628  // build the argument list
3629  arglist = Py_BuildValue( "(iiO)", x, y, pdata );
3630  // call the python function
3631  result = PyEval_CallObject( python_f2eval, arglist );
3632  // release the argument list
3633  Py_CLEAR( arglist );
3634  // check and unpack the result
3635  if ( !PyFloat_Check( result ) )
3636  {
3637  fprintf( stderr, "f2eval callback must return a float\n" );
3638  PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
3639  }
3640  else
3641  {
3642  // should I test the type here?
3643  fresult = (PLFLT) PyFloat_AsDouble( result );
3644  }
3645  // release the result
3646  Py_CLEAR( result );
3647  // release the global interpreter lock
3649  }
3650  return fresult;
3651  }
3652 
3653  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
3654  {
3655  PyObject *pdata, *arglist, *result, *unicode_string;
3656  char *pystring;
3657 
3658  // the data argument is acutally a pointer to a python object
3659  if ( data )
3660  pdata = (PyObject *) data;
3661  else
3662  pdata = Py_None;
3663  if ( python_label ) // if not something is terribly wrong
3664  { // hold a reference to the data object
3665  Py_XINCREF( pdata );
3666  // grab the Global Interpreter Lock to be sure threads don't mess us up
3668  // build the argument list
3669 #ifdef PL_DOUBLE
3670  arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
3671 #else
3672  arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
3673 #endif
3674  // call the python function
3675  result = PyEval_CallObject( python_label, arglist );
3676  // release the argument list
3677  //Py_CLEAR(arglist);
3678  // check and unpack the result
3679  if ( result == NULL )
3680  {
3681  fprintf( stderr, "label callback failed with 3 arguments\n" );
3682  PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
3683  }
3684  else if ( PyString_Check( result ) )
3685  {
3686  // should I test the type here?
3687  pystring = PyString_AsString( result );
3688  strncpy( string, pystring, len );
3689  }
3690  else if ( PyUnicode_Check( result ) )
3691  {
3692  // unicode_string is never freed? memory leak here?
3693  unicode_string = PyUnicode_AsEncodedString( result, "utf-8", "Error ~" );
3694  pystring = PyBytes_AS_STRING( unicode_string );
3695  // len may be different then the byte string length w/ unicode?
3696  strncpy( string, pystring, len );
3697  }
3698  else
3699  {
3700  fprintf( stderr, "label callback must return a string\n" );
3701  PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
3702  }
3703  // release the result
3704  Py_CLEAR( result );
3705  // release the global interpreter lock
3707  }
3708  }
3709 
3710  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
3711  {
3712  PyObject *px, *py, *pdata, *arglist, *result;
3713  npy_intp n;
3714  n = 1;
3715 
3716  // the data argument is acutally a pointer to a python object
3717  pdata = (PyObject *) data;
3718  if ( data == NULL )
3719  {
3720  pdata = Py_None;
3721  }
3722  if ( python_ct ) // if not something is terribly wrong
3723  { // hold a reference to the data object
3724  Py_XINCREF( pdata );
3725  // grab the Global Interpreter Lock to be sure threads don't mess us up
3727  // build the argument list
3728  px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
3729  py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
3730  arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
3731  // call the python function
3732  result = PyEval_CallObject( python_ct, arglist );
3733  // release the argument list
3734  Py_CLEAR( arglist );
3735  Py_CLEAR( px );
3736  Py_CLEAR( py );
3737  Py_CLEAR( pdata );
3738  // check and unpack the result
3739  if ( result == NULL )
3740  {
3741  fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
3742  PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
3743  }
3744  // release the result
3745  Py_CLEAR( result );
3746  // release the global interpreter lock
3748  }
3749  }
3750 
3752  {
3753  PyObject *px, *py, *arglist, *result;
3754  // PyArrayObject *tmpx, *tmpy;
3755 // PLFLT *xx, *yy;
3756 // PLINT i;
3757  npy_intp nn;
3758  nn = n;
3759 
3760  if ( python_mapform ) // if not something is terribly wrong
3761  { // grab the Global Interpreter Lock to be sure threads don't mess us up
3763  // build the argument list
3764 #ifdef PL_HAVE_PTHREAD
3765  px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
3766  py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
3767 #else
3768  px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
3769  py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
3770 #endif
3771  arglist = Py_BuildValue( "(iOO)", n, px, py );
3772  // call the python function
3773  result = PyEval_CallObject( python_mapform, arglist );
3774  // release the argument list
3775  Py_CLEAR( arglist );
3776  Py_CLEAR( px );
3777  Py_CLEAR( py );
3778  // check and unpack the result
3779  if ( result == NULL )
3780  {
3781  fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
3782  PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
3783  }
3784  // release the result
3785  Py_CLEAR( result );
3786  // release the global interpreter lock
3788  }
3789  }
3790 
3791 // marshal the pltr function pointer argument
3792  pltr_func marshal_pltr( PyObject* input )
3793  {
3794  pltr_func result = do_pltr_callback;
3795  PyObject * rep = PyObject_Repr( input );
3796  if ( rep )
3797  {
3798  // Memory leaks here? str and uni_str are not freed?
3799  char* str;
3800  if ( PyUnicode_Check( rep ) )
3801  {
3802  PyObject *uni_str = PyUnicode_AsEncodedString( rep, "utf-8", "Error ~" );
3803  str = PyBytes_AS_STRING( uni_str );
3804  }
3805  else
3806  {
3807  str = PyString_AsString( rep );
3808  }
3809  if ( strstr( str, "function pltr0" ) != 0 )
3810  {
3811  result = pltr0;
3812  pltr_type = CB_0;
3813  python_pltr = NULL;
3814  }
3815  else if ( strstr( str, "function pltr1" ) != 0 )
3816  {
3817  result = pltr1;
3818  pltr_type = CB_1;
3819  python_pltr = NULL;
3820  }
3821  else if ( strstr( str, "function pltr2" ) != 0 )
3822  {
3823  result = pltr2;
3824  pltr_type = CB_2;
3825  python_pltr = NULL;
3826  }
3827  else
3828  {
3829  python_pltr = input;
3830  pltr_type = CB_Python;
3831  Py_XINCREF( input );
3832  }
3833  Py_CLEAR( rep );
3834  }
3835  else
3836  {
3837  python_pltr = input;
3838  pltr_type = CB_Python;
3839  Py_XINCREF( input );
3840  }
3841  return result;
3842  }
3843 
3844  void cleanup_pltr( void )
3845  {
3846  Py_CLEAR( python_pltr );
3847  python_pltr = 0;
3848  }
3849 
3850 // marshal the ct function pointer argument
3851  ct_func marshal_ct( PyObject* input )
3852  {
3853  ct_func result = do_ct_callback;
3854  python_ct = input;
3855  Py_XINCREF( input );
3856  return result;
3857  }
3858 
3859  void cleanup_ct( void )
3860  {
3861  Py_CLEAR( python_ct );
3862  python_ct = 0;
3863  }
3864 
3865 // marshal the mapform function pointer argument
3866  mapform_func marshal_mapform( PyObject* input )
3867  {
3869  python_mapform = input;
3870  Py_XINCREF( input );
3871  return result;
3872  }
3873 
3874  void cleanup_mapform( void )
3875  {
3876  Py_CLEAR( python_mapform );
3877  python_mapform = 0;
3878  }
3879 
3880  PLPointer marshal_PLPointer( PyObject* input, int isimg )
3881  {
3882  PLPointer result = NULL;
3883  switch ( pltr_type )
3884  {
3885  case CB_0:
3886  break;
3887  case CB_1:
3888  if ( input != Py_None )
3889  result = marshal_PLcGrid1( input, isimg );
3890  break;
3891  case CB_2:
3892  if ( input != Py_None )
3893  result = marshal_PLcGrid2( input, isimg );
3894  break;
3895  case CB_Python:
3896  Py_XINCREF( input );
3897  result = (PLPointer *) input;
3898  break;
3899  default:
3900  fprintf( stderr, "pltr_type is invalid\n" );
3901  }
3902  return result;
3903  }
3904 
3905  void cleanup_PLPointer( void )
3906  {
3907  switch ( pltr_type )
3908  {
3909  case CB_0:
3910  break;
3911  case CB_1:
3912  cleanup_PLcGrid1();
3913  break;
3914  case CB_2:
3915  cleanup_PLcGrid2();
3916  break;
3917  case CB_Python:
3918  Py_CLEAR( python_pltr );
3919  break;
3920  default:
3921  fprintf( stderr, "pltr_type is invalid\n" );
3922  }
3923  python_pltr = 0;
3924  pltr_type = CB_0;
3925  }
3926 
3927 
3928 
3929 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3930  PyObject *resultobj = 0;
3931  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3932  int arg2 ;
3933  void *argp1 = 0 ;
3934  int res1 = 0 ;
3935  int val2 ;
3936  int ecode2 = 0 ;
3937  PyObject *swig_obj[2] ;
3938 
3939  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_type_set", 2, 2, swig_obj)) SWIG_fail;
3940  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
3941  if (!SWIG_IsOK(res1)) {
3942  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
3943  }
3944  arg1 = (PLGraphicsIn *)(argp1);
3945  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
3946  if (!SWIG_IsOK(ecode2)) {
3947  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
3948  }
3949  arg2 = (int)(val2);
3950  if (arg1) (arg1)->type = arg2;
3951  resultobj = SWIG_Py_Void();
3952  return resultobj;
3953 fail:
3954  return NULL;
3955 }
3956 
3957 
3958 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3959  PyObject *resultobj = 0;
3960  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3961  void *argp1 = 0 ;
3962  int res1 = 0 ;
3963  PyObject *swig_obj[1] ;
3964  int result;
3965 
3966  if (!args) SWIG_fail;
3967  swig_obj[0] = args;
3968  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
3969  if (!SWIG_IsOK(res1)) {
3970  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
3971  }
3972  arg1 = (PLGraphicsIn *)(argp1);
3973  result = (int) ((arg1)->type);
3974  resultobj = SWIG_From_int((int)(result));
3975  return resultobj;
3976 fail:
3977  return NULL;
3978 }
3979 
3980 
3981 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3982  PyObject *resultobj = 0;
3983  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3984  unsigned int arg2 ;
3985  void *argp1 = 0 ;
3986  int res1 = 0 ;
3987  unsigned int val2 ;
3988  int ecode2 = 0 ;
3989  PyObject *swig_obj[2] ;
3990 
3991  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_state_set", 2, 2, swig_obj)) SWIG_fail;
3992  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
3993  if (!SWIG_IsOK(res1)) {
3994  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
3995  }
3996  arg1 = (PLGraphicsIn *)(argp1);
3997  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
3998  if (!SWIG_IsOK(ecode2)) {
3999  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4000  }
4001  arg2 = (unsigned int)(val2);
4002  if (arg1) (arg1)->state = arg2;
4003  resultobj = SWIG_Py_Void();
4004  return resultobj;
4005 fail:
4006  return NULL;
4007 }
4008 
4009 
4010 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4011  PyObject *resultobj = 0;
4012  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4013  void *argp1 = 0 ;
4014  int res1 = 0 ;
4015  PyObject *swig_obj[1] ;
4016  unsigned int result;
4017 
4018  if (!args) SWIG_fail;
4019  swig_obj[0] = args;
4020  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4021  if (!SWIG_IsOK(res1)) {
4022  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4023  }
4024  arg1 = (PLGraphicsIn *)(argp1);
4025  result = (unsigned int) ((arg1)->state);
4026  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4027  return resultobj;
4028 fail:
4029  return NULL;
4030 }
4031 
4032 
4033 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4034  PyObject *resultobj = 0;
4035  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4036  unsigned int arg2 ;
4037  void *argp1 = 0 ;
4038  int res1 = 0 ;
4039  unsigned int val2 ;
4040  int ecode2 = 0 ;
4041  PyObject *swig_obj[2] ;
4042 
4043  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_keysym_set", 2, 2, swig_obj)) SWIG_fail;
4044  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4045  if (!SWIG_IsOK(res1)) {
4046  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4047  }
4048  arg1 = (PLGraphicsIn *)(argp1);
4049  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4050  if (!SWIG_IsOK(ecode2)) {
4051  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4052  }
4053  arg2 = (unsigned int)(val2);
4054  if (arg1) (arg1)->keysym = arg2;
4055  resultobj = SWIG_Py_Void();
4056  return resultobj;
4057 fail:
4058  return NULL;
4059 }
4060 
4061 
4062 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4063  PyObject *resultobj = 0;
4064  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4065  void *argp1 = 0 ;
4066  int res1 = 0 ;
4067  PyObject *swig_obj[1] ;
4068  unsigned int result;
4069 
4070  if (!args) SWIG_fail;
4071  swig_obj[0] = args;
4072  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4073  if (!SWIG_IsOK(res1)) {
4074  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4075  }
4076  arg1 = (PLGraphicsIn *)(argp1);
4077  result = (unsigned int) ((arg1)->keysym);
4078  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4079  return resultobj;
4080 fail:
4081  return NULL;
4082 }
4083 
4084 
4085 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4086  PyObject *resultobj = 0;
4087  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4088  unsigned int arg2 ;
4089  void *argp1 = 0 ;
4090  int res1 = 0 ;
4091  unsigned int val2 ;
4092  int ecode2 = 0 ;
4093  PyObject *swig_obj[2] ;
4094 
4095  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_button_set", 2, 2, swig_obj)) SWIG_fail;
4096  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4097  if (!SWIG_IsOK(res1)) {
4098  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4099  }
4100  arg1 = (PLGraphicsIn *)(argp1);
4101  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4102  if (!SWIG_IsOK(ecode2)) {
4103  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4104  }
4105  arg2 = (unsigned int)(val2);
4106  if (arg1) (arg1)->button = arg2;
4107  resultobj = SWIG_Py_Void();
4108  return resultobj;
4109 fail:
4110  return NULL;
4111 }
4112 
4113 
4114 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4115  PyObject *resultobj = 0;
4116  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4117  void *argp1 = 0 ;
4118  int res1 = 0 ;
4119  PyObject *swig_obj[1] ;
4120  unsigned int result;
4121 
4122  if (!args) SWIG_fail;
4123  swig_obj[0] = args;
4124  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4125  if (!SWIG_IsOK(res1)) {
4126  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4127  }
4128  arg1 = (PLGraphicsIn *)(argp1);
4129  result = (unsigned int) ((arg1)->button);
4130  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4131  return resultobj;
4132 fail:
4133  return NULL;
4134 }
4135 
4136 
4137 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4138  PyObject *resultobj = 0;
4139  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4140  PLINT arg2 ;
4141  void *argp1 = 0 ;
4142  int res1 = 0 ;
4143  int val2 ;
4144  int ecode2 = 0 ;
4145  PyObject *swig_obj[2] ;
4146 
4147  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_subwindow_set", 2, 2, swig_obj)) SWIG_fail;
4148  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4149  if (!SWIG_IsOK(res1)) {
4150  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4151  }
4152  arg1 = (PLGraphicsIn *)(argp1);
4153  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4154  if (!SWIG_IsOK(ecode2)) {
4155  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4156  }
4157  arg2 = (PLINT)(val2);
4158  if (arg1) (arg1)->subwindow = arg2;
4159  resultobj = SWIG_Py_Void();
4160  return resultobj;
4161 fail:
4162  return NULL;
4163 }
4164 
4165 
4166 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4167  PyObject *resultobj = 0;
4168  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4169  void *argp1 = 0 ;
4170  int res1 = 0 ;
4171  PyObject *swig_obj[1] ;
4172  PLINT result;
4173 
4174  if (!args) SWIG_fail;
4175  swig_obj[0] = args;
4176  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4177  if (!SWIG_IsOK(res1)) {
4178  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4179  }
4180  arg1 = (PLGraphicsIn *)(argp1);
4181  result = (PLINT) ((arg1)->subwindow);
4182  resultobj = SWIG_From_int((int)(result));
4183  return resultobj;
4184 fail:
4185  return NULL;
4186 }
4187 
4188 
4189 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4190  PyObject *resultobj = 0;
4191  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4192  char *arg2 ;
4193  void *argp1 = 0 ;
4194  int res1 = 0 ;
4195  char temp2[16] ;
4196  int res2 ;
4197  PyObject *swig_obj[2] ;
4198 
4199  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_string_set", 2, 2, swig_obj)) SWIG_fail;
4200  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4201  if (!SWIG_IsOK(res1)) {
4202  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4203  }
4204  arg1 = (PLGraphicsIn *)(argp1);
4205  res2 = SWIG_AsCharArray(swig_obj[1], temp2, 16);
4206  if (!SWIG_IsOK(res2)) {
4207  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4208  }
4209  arg2 = (char *)(temp2);
4210  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4211  else memset(arg1->string,0,16*sizeof(char));
4212  resultobj = SWIG_Py_Void();
4213  return resultobj;
4214 fail:
4215  return NULL;
4216 }
4217 
4218 
4219 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4220  PyObject *resultobj = 0;
4221  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4222  void *argp1 = 0 ;
4223  int res1 = 0 ;
4224  PyObject *swig_obj[1] ;
4225  char *result = 0 ;
4226 
4227  if (!args) SWIG_fail;
4228  swig_obj[0] = args;
4229  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4230  if (!SWIG_IsOK(res1)) {
4231  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4232  }
4233  arg1 = (PLGraphicsIn *)(argp1);
4234  result = (char *)(char *) ((arg1)->string);
4235  {
4236  size_t size = SWIG_strnlen(result, 16);
4237 
4238 
4239 
4240  resultobj = SWIG_FromCharPtrAndSize(result, size);
4241  }
4242  return resultobj;
4243 fail:
4244  return NULL;
4245 }
4246 
4247 
4248 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4249  PyObject *resultobj = 0;
4250  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4251  int arg2 ;
4252  void *argp1 = 0 ;
4253  int res1 = 0 ;
4254  int val2 ;
4255  int ecode2 = 0 ;
4256  PyObject *swig_obj[2] ;
4257 
4258  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pX_set", 2, 2, swig_obj)) SWIG_fail;
4259  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4260  if (!SWIG_IsOK(res1)) {
4261  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4262  }
4263  arg1 = (PLGraphicsIn *)(argp1);
4264  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4265  if (!SWIG_IsOK(ecode2)) {
4266  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4267  }
4268  arg2 = (int)(val2);
4269  if (arg1) (arg1)->pX = arg2;
4270  resultobj = SWIG_Py_Void();
4271  return resultobj;
4272 fail:
4273  return NULL;
4274 }
4275 
4276 
4277 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4278  PyObject *resultobj = 0;
4279  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4280  void *argp1 = 0 ;
4281  int res1 = 0 ;
4282  PyObject *swig_obj[1] ;
4283  int result;
4284 
4285  if (!args) SWIG_fail;
4286  swig_obj[0] = args;
4287  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4288  if (!SWIG_IsOK(res1)) {
4289  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4290  }
4291  arg1 = (PLGraphicsIn *)(argp1);
4292  result = (int) ((arg1)->pX);
4293  resultobj = SWIG_From_int((int)(result));
4294  return resultobj;
4295 fail:
4296  return NULL;
4297 }
4298 
4299 
4300 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4301  PyObject *resultobj = 0;
4302  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4303  int arg2 ;
4304  void *argp1 = 0 ;
4305  int res1 = 0 ;
4306  int val2 ;
4307  int ecode2 = 0 ;
4308  PyObject *swig_obj[2] ;
4309 
4310  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pY_set", 2, 2, swig_obj)) SWIG_fail;
4311  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4312  if (!SWIG_IsOK(res1)) {
4313  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4314  }
4315  arg1 = (PLGraphicsIn *)(argp1);
4316  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4317  if (!SWIG_IsOK(ecode2)) {
4318  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4319  }
4320  arg2 = (int)(val2);
4321  if (arg1) (arg1)->pY = arg2;
4322  resultobj = SWIG_Py_Void();
4323  return resultobj;
4324 fail:
4325  return NULL;
4326 }
4327 
4328 
4329 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4330  PyObject *resultobj = 0;
4331  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4332  void *argp1 = 0 ;
4333  int res1 = 0 ;
4334  PyObject *swig_obj[1] ;
4335  int result;
4336 
4337  if (!args) SWIG_fail;
4338  swig_obj[0] = args;
4339  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4340  if (!SWIG_IsOK(res1)) {
4341  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4342  }
4343  arg1 = (PLGraphicsIn *)(argp1);
4344  result = (int) ((arg1)->pY);
4345  resultobj = SWIG_From_int((int)(result));
4346  return resultobj;
4347 fail:
4348  return NULL;
4349 }
4350 
4351 
4352 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4353  PyObject *resultobj = 0;
4354  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4355  PLFLT arg2 ;
4356  void *argp1 = 0 ;
4357  int res1 = 0 ;
4358  double val2 ;
4359  int ecode2 = 0 ;
4360  PyObject *swig_obj[2] ;
4361 
4362  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dX_set", 2, 2, swig_obj)) SWIG_fail;
4363  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4364  if (!SWIG_IsOK(res1)) {
4365  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4366  }
4367  arg1 = (PLGraphicsIn *)(argp1);
4368  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4369  if (!SWIG_IsOK(ecode2)) {
4370  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4371  }
4372  arg2 = (PLFLT)(val2);
4373  if (arg1) (arg1)->dX = arg2;
4374  resultobj = SWIG_Py_Void();
4375  return resultobj;
4376 fail:
4377  return NULL;
4378 }
4379 
4380 
4381 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4382  PyObject *resultobj = 0;
4383  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4384  void *argp1 = 0 ;
4385  int res1 = 0 ;
4386  PyObject *swig_obj[1] ;
4387  PLFLT result;
4388 
4389  if (!args) SWIG_fail;
4390  swig_obj[0] = args;
4391  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4392  if (!SWIG_IsOK(res1)) {
4393  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4394  }
4395  arg1 = (PLGraphicsIn *)(argp1);
4396  result = (PLFLT) ((arg1)->dX);
4397  resultobj = SWIG_From_double((double)(result));
4398  return resultobj;
4399 fail:
4400  return NULL;
4401 }
4402 
4403 
4404 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4405  PyObject *resultobj = 0;
4406  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4407  PLFLT arg2 ;
4408  void *argp1 = 0 ;
4409  int res1 = 0 ;
4410  double val2 ;
4411  int ecode2 = 0 ;
4412  PyObject *swig_obj[2] ;
4413 
4414  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dY_set", 2, 2, swig_obj)) SWIG_fail;
4415  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4416  if (!SWIG_IsOK(res1)) {
4417  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4418  }
4419  arg1 = (PLGraphicsIn *)(argp1);
4420  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4421  if (!SWIG_IsOK(ecode2)) {
4422  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4423  }
4424  arg2 = (PLFLT)(val2);
4425  if (arg1) (arg1)->dY = arg2;
4426  resultobj = SWIG_Py_Void();
4427  return resultobj;
4428 fail:
4429  return NULL;
4430 }
4431 
4432 
4433 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4434  PyObject *resultobj = 0;
4435  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4436  void *argp1 = 0 ;
4437  int res1 = 0 ;
4438  PyObject *swig_obj[1] ;
4439  PLFLT result;
4440 
4441  if (!args) SWIG_fail;
4442  swig_obj[0] = args;
4443  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4444  if (!SWIG_IsOK(res1)) {
4445  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4446  }
4447  arg1 = (PLGraphicsIn *)(argp1);
4448  result = (PLFLT) ((arg1)->dY);
4449  resultobj = SWIG_From_double((double)(result));
4450  return resultobj;
4451 fail:
4452  return NULL;
4453 }
4454 
4455 
4456 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4457  PyObject *resultobj = 0;
4458  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4459  PLFLT arg2 ;
4460  void *argp1 = 0 ;
4461  int res1 = 0 ;
4462  double val2 ;
4463  int ecode2 = 0 ;
4464  PyObject *swig_obj[2] ;
4465 
4466  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wX_set", 2, 2, swig_obj)) SWIG_fail;
4467  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4468  if (!SWIG_IsOK(res1)) {
4469  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4470  }
4471  arg1 = (PLGraphicsIn *)(argp1);
4472  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4473  if (!SWIG_IsOK(ecode2)) {
4474  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4475  }
4476  arg2 = (PLFLT)(val2);
4477  if (arg1) (arg1)->wX = arg2;
4478  resultobj = SWIG_Py_Void();
4479  return resultobj;
4480 fail:
4481  return NULL;
4482 }
4483 
4484 
4485 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4486  PyObject *resultobj = 0;
4487  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4488  void *argp1 = 0 ;
4489  int res1 = 0 ;
4490  PyObject *swig_obj[1] ;
4491  PLFLT result;
4492 
4493  if (!args) SWIG_fail;
4494  swig_obj[0] = args;
4495  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4496  if (!SWIG_IsOK(res1)) {
4497  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4498  }
4499  arg1 = (PLGraphicsIn *)(argp1);
4500  result = (PLFLT) ((arg1)->wX);
4501  resultobj = SWIG_From_double((double)(result));
4502  return resultobj;
4503 fail:
4504  return NULL;
4505 }
4506 
4507 
4508 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4509  PyObject *resultobj = 0;
4510  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4511  PLFLT arg2 ;
4512  void *argp1 = 0 ;
4513  int res1 = 0 ;
4514  double val2 ;
4515  int ecode2 = 0 ;
4516  PyObject *swig_obj[2] ;
4517 
4518  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wY_set", 2, 2, swig_obj)) SWIG_fail;
4519  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4520  if (!SWIG_IsOK(res1)) {
4521  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4522  }
4523  arg1 = (PLGraphicsIn *)(argp1);
4524  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4525  if (!SWIG_IsOK(ecode2)) {
4526  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
4527  }
4528  arg2 = (PLFLT)(val2);
4529  if (arg1) (arg1)->wY = arg2;
4530  resultobj = SWIG_Py_Void();
4531  return resultobj;
4532 fail:
4533  return NULL;
4534 }
4535 
4536 
4537 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4538  PyObject *resultobj = 0;
4539  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4540  void *argp1 = 0 ;
4541  int res1 = 0 ;
4542  PyObject *swig_obj[1] ;
4543  PLFLT result;
4544 
4545  if (!args) SWIG_fail;
4546  swig_obj[0] = args;
4547  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4548  if (!SWIG_IsOK(res1)) {
4549  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4550  }
4551  arg1 = (PLGraphicsIn *)(argp1);
4552  result = (PLFLT) ((arg1)->wY);
4553  resultobj = SWIG_From_double((double)(result));
4554  return resultobj;
4555 fail:
4556  return NULL;
4557 }
4558 
4559 
4560 SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4561  PyObject *resultobj = 0;
4562  PLGraphicsIn *result = 0 ;
4563 
4564  if (!SWIG_Python_UnpackTuple(args, "new_PLGraphicsIn", 0, 0, 0)) SWIG_fail;
4565  result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
4567  return resultobj;
4568 fail:
4569  return NULL;
4570 }
4571 
4572 
4573 SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4574  PyObject *resultobj = 0;
4575  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4576  void *argp1 = 0 ;
4577  int res1 = 0 ;
4578  PyObject *swig_obj[1] ;
4579 
4580  if (!args) SWIG_fail;
4581  swig_obj[0] = args;
4582  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
4583  if (!SWIG_IsOK(res1)) {
4584  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4585  }
4586  arg1 = (PLGraphicsIn *)(argp1);
4587  free((char *) arg1);
4588  resultobj = SWIG_Py_Void();
4589  return resultobj;
4590 fail:
4591  return NULL;
4592 }
4593 
4594 
4595 SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4596  PyObject *obj;
4597  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
4599  return SWIG_Py_Void();
4600 }
4601 
4602 SWIGINTERN PyObject *PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4603  return SWIG_Python_InitShadowInstance(args);
4604 }
4605 
4606 SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4607  PyObject *resultobj = 0;
4608  PLINT arg1 ;
4609  int val1 ;
4610  int ecode1 = 0 ;
4611  PyObject *swig_obj[1] ;
4612 
4613  if (!args) SWIG_fail;
4614  swig_obj[0] = args;
4615  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
4616  if (!SWIG_IsOK(ecode1)) {
4617  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
4618  }
4619  arg1 = (PLINT)(val1);
4620  plsxwin(arg1);
4621  resultobj = SWIG_Py_Void();
4622  return resultobj;
4623 fail:
4624  return NULL;
4625 }
4626 
4627 
4628 SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4629  PyObject *resultobj = 0;
4630  PLINT arg1 ;
4631  PLINT arg2 ;
4632  int val1 ;
4633  int ecode1 = 0 ;
4634  int val2 ;
4635  int ecode2 = 0 ;
4636  PyObject *swig_obj[2] ;
4637 
4638  if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelformat", 2, 2, swig_obj)) SWIG_fail;
4639  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
4640  if (!SWIG_IsOK(ecode1)) {
4641  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
4642  }
4643  arg1 = (PLINT)(val1);
4644  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4645  if (!SWIG_IsOK(ecode2)) {
4646  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
4647  }
4648  arg2 = (PLINT)(val2);
4649  pl_setcontlabelformat(arg1,arg2);
4650  resultobj = SWIG_Py_Void();
4651  return resultobj;
4652 fail:
4653  return NULL;
4654 }
4655 
4656 
4657 SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4658  PyObject *resultobj = 0;
4659  PLFLT arg1 ;
4660  PLFLT arg2 ;
4661  PLFLT arg3 ;
4662  PLINT arg4 ;
4663  double val1 ;
4664  int ecode1 = 0 ;
4665  double val2 ;
4666  int ecode2 = 0 ;
4667  double val3 ;
4668  int ecode3 = 0 ;
4669  int val4 ;
4670  int ecode4 = 0 ;
4671  PyObject *swig_obj[4] ;
4672 
4673  if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelparam", 4, 4, swig_obj)) SWIG_fail;
4674  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
4675  if (!SWIG_IsOK(ecode1)) {
4676  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
4677  }
4678  arg1 = (PLFLT)(val1);
4679  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4680  if (!SWIG_IsOK(ecode2)) {
4681  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
4682  }
4683  arg2 = (PLFLT)(val2);
4684  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
4685  if (!SWIG_IsOK(ecode3)) {
4686  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
4687  }
4688  arg3 = (PLFLT)(val3);
4689  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
4690  if (!SWIG_IsOK(ecode4)) {
4691  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
4692  }
4693  arg4 = (PLINT)(val4);
4694  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
4695  resultobj = SWIG_Py_Void();
4696  return resultobj;
4697 fail:
4698  return NULL;
4699 }
4700 
4701 
4702 SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4703  PyObject *resultobj = 0;
4704  PLINT arg1 ;
4705  int val1 ;
4706  int ecode1 = 0 ;
4707  PyObject *swig_obj[1] ;
4708 
4709  if (!args) SWIG_fail;
4710  swig_obj[0] = args;
4711  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
4712  if (!SWIG_IsOK(ecode1)) {
4713  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
4714  }
4715  arg1 = (PLINT)(val1);
4716  pladv(arg1);
4717  resultobj = SWIG_Py_Void();
4718  return resultobj;
4719 fail:
4720  return NULL;
4721 }
4722 
4723 
4724 SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4725  PyObject *resultobj = 0;
4726  PLFLT arg1 ;
4727  PLFLT arg2 ;
4728  PLFLT arg3 ;
4729  PLFLT arg4 ;
4730  PLFLT arg5 ;
4731  PLFLT arg6 ;
4732  PLFLT arg7 ;
4733  PLBOOL arg8 ;
4734  double val1 ;
4735  int ecode1 = 0 ;
4736  double val2 ;
4737  int ecode2 = 0 ;
4738  double val3 ;
4739  int ecode3 = 0 ;
4740  double val4 ;
4741  int ecode4 = 0 ;
4742  double val5 ;
4743  int ecode5 = 0 ;
4744  double val6 ;
4745  int ecode6 = 0 ;
4746  double val7 ;
4747  int ecode7 = 0 ;
4748  int val8 ;
4749  int ecode8 = 0 ;
4750  PyObject *swig_obj[8] ;
4751 
4752  if (!SWIG_Python_UnpackTuple(args, "plarc", 8, 8, swig_obj)) SWIG_fail;
4753  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
4754  if (!SWIG_IsOK(ecode1)) {
4755  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
4756  }
4757  arg1 = (PLFLT)(val1);
4758  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4759  if (!SWIG_IsOK(ecode2)) {
4760  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
4761  }
4762  arg2 = (PLFLT)(val2);
4763  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
4764  if (!SWIG_IsOK(ecode3)) {
4765  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
4766  }
4767  arg3 = (PLFLT)(val3);
4768  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
4769  if (!SWIG_IsOK(ecode4)) {
4770  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
4771  }
4772  arg4 = (PLFLT)(val4);
4773  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
4774  if (!SWIG_IsOK(ecode5)) {
4775  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
4776  }
4777  arg5 = (PLFLT)(val5);
4778  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
4779  if (!SWIG_IsOK(ecode6)) {
4780  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
4781  }
4782  arg6 = (PLFLT)(val6);
4783  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
4784  if (!SWIG_IsOK(ecode7)) {
4785  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
4786  }
4787  arg7 = (PLFLT)(val7);
4788  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
4789  if (!SWIG_IsOK(ecode8)) {
4790  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
4791  }
4792  arg8 = (PLBOOL)(val8);
4793  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4794  resultobj = SWIG_Py_Void();
4795  return resultobj;
4796 fail:
4797  return NULL;
4798 }
4799 
4800 
4801 SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4802  PyObject *resultobj = 0;
4803  PLFLT arg1 ;
4804  PLFLT arg2 ;
4805  char *arg3 = (char *) 0 ;
4806  PLFLT arg4 ;
4807  PLINT arg5 ;
4808  char *arg6 = (char *) 0 ;
4809  PLFLT arg7 ;
4810  PLINT arg8 ;
4811  double val1 ;
4812  int ecode1 = 0 ;
4813  double val2 ;
4814  int ecode2 = 0 ;
4815  int res3 ;
4816  char *buf3 = 0 ;
4817  int alloc3 = 0 ;
4818  double val4 ;
4819  int ecode4 = 0 ;
4820  int val5 ;
4821  int ecode5 = 0 ;
4822  int res6 ;
4823  char *buf6 = 0 ;
4824  int alloc6 = 0 ;
4825  double val7 ;
4826  int ecode7 = 0 ;
4827  int val8 ;
4828  int ecode8 = 0 ;
4829  PyObject *swig_obj[8] ;
4830 
4831  if (!SWIG_Python_UnpackTuple(args, "plaxes", 8, 8, swig_obj)) SWIG_fail;
4832  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
4833  if (!SWIG_IsOK(ecode1)) {
4834  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
4835  }
4836  arg1 = (PLFLT)(val1);
4837  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4838  if (!SWIG_IsOK(ecode2)) {
4839  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
4840  }
4841  arg2 = (PLFLT)(val2);
4842  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
4843  if (!SWIG_IsOK(res3)) {
4844  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
4845  }
4846  arg3 = (char *)(buf3);
4847  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
4848  if (!SWIG_IsOK(ecode4)) {
4849  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
4850  }
4851  arg4 = (PLFLT)(val4);
4852  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
4853  if (!SWIG_IsOK(ecode5)) {
4854  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
4855  }
4856  arg5 = (PLINT)(val5);
4857  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
4858  if (!SWIG_IsOK(res6)) {
4859  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
4860  }
4861  arg6 = (char *)(buf6);
4862  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
4863  if (!SWIG_IsOK(ecode7)) {
4864  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
4865  }
4866  arg7 = (PLFLT)(val7);
4867  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
4868  if (!SWIG_IsOK(ecode8)) {
4869  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
4870  }
4871  arg8 = (PLINT)(val8);
4872  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
4873  resultobj = SWIG_Py_Void();
4874  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4875  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
4876  return resultobj;
4877 fail:
4878  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4879  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
4880  return NULL;
4881 }
4882 
4883 
4884 SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4885  PyObject *resultobj = 0;
4886  PLINT arg1 ;
4887  PLFLT *arg2 = (PLFLT *) 0 ;
4888  PLFLT *arg3 = (PLFLT *) 0 ;
4889  PLINT arg4 ;
4890  PyArrayObject *tmp1 = NULL ;
4891  PyArrayObject *tmp3 = NULL ;
4892  int val4 ;
4893  int ecode4 = 0 ;
4894  PyObject *swig_obj[3] ;
4895 
4896  if (!SWIG_Python_UnpackTuple(args, "plbin", 3, 3, swig_obj)) SWIG_fail;
4897  {
4898  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
4899  if ( tmp1 == NULL )
4900  return NULL;
4901  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
4902  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
4903  }
4904  {
4905  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
4906  if ( tmp3 == NULL )
4907  return NULL;
4908  if ( PyArray_DIMS( tmp3 )[0] != Alen )
4909  {
4910  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
4911  return NULL;
4912  }
4913  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
4914  }
4915  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
4916  if (!SWIG_IsOK(ecode4)) {
4917  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
4918  }
4919  arg4 = (PLINT)(val4);
4920  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
4921  resultobj = SWIG_Py_Void();
4922  {
4923  Py_CLEAR( tmp1 );
4924  }
4925  {
4926  Py_CLEAR( tmp3 );
4927  }
4928  return resultobj;
4929 fail:
4930  {
4931  Py_CLEAR( tmp1 );
4932  }
4933  {
4934  Py_CLEAR( tmp3 );
4935  }
4936  return NULL;
4937 }
4938 
4939 
4940 SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4941  PyObject *resultobj = 0;
4942  PLINT *arg1 = (PLINT *) 0 ;
4943  PLINT *arg2 = (PLINT *) 0 ;
4944  PLINT *arg3 = (PLINT *) 0 ;
4945  PLINT *arg4 = (PLINT *) 0 ;
4946  PLINT *arg5 = (PLINT *) 0 ;
4947  PLFLT *arg6 = (PLFLT *) 0 ;
4948  PLFLT arg7 ;
4949  PLINT temp1 ;
4950  int res1 = SWIG_TMPOBJ ;
4951  PLINT temp2 ;
4952  int res2 = SWIG_TMPOBJ ;
4953  PLINT temp3 ;
4954  int res3 = SWIG_TMPOBJ ;
4955  PLINT temp4 ;
4956  int res4 = SWIG_TMPOBJ ;
4957  PLINT temp5 ;
4958  int res5 = SWIG_TMPOBJ ;
4959  PLFLT temp6 ;
4960  int res6 = SWIG_TMPOBJ ;
4961  double val7 ;
4962  int ecode7 = 0 ;
4963  PyObject *swig_obj[1] ;
4964 
4965  arg1 = &temp1;
4966  arg2 = &temp2;
4967  arg3 = &temp3;
4968  arg4 = &temp4;
4969  arg5 = &temp5;
4970  arg6 = &temp6;
4971  if (!args) SWIG_fail;
4972  swig_obj[0] = args;
4973  ecode7 = SWIG_AsVal_double(swig_obj[0], &val7);
4974  if (!SWIG_IsOK(ecode7)) {
4975  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
4976  }
4977  arg7 = (PLFLT)(val7);
4978  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
4979  resultobj = SWIG_Py_Void();
4980  if (SWIG_IsTmpObj(res1)) {
4981  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
4982  } else {
4983  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4984  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
4985  }
4986  if (SWIG_IsTmpObj(res2)) {
4987  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
4988  } else {
4989  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4990  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
4991  }
4992  if (SWIG_IsTmpObj(res3)) {
4993  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
4994  } else {
4995  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4996  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
4997  }
4998  if (SWIG_IsTmpObj(res4)) {
4999  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
5000  } else {
5001  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5002  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
5003  }
5004  if (SWIG_IsTmpObj(res5)) {
5005  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5006  } else {
5007  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5008  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5009  }
5010  if (SWIG_IsTmpObj(res6)) {
5011  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
5012  } else {
5013  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5014  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
5015  }
5016  return resultobj;
5017 fail:
5018  return NULL;
5019 }
5020 
5021 
5022 SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5023  PyObject *resultobj = 0;
5024 
5025  if (!SWIG_Python_UnpackTuple(args, "plbop", 0, 0, 0)) SWIG_fail;
5026  plbop();
5027  resultobj = SWIG_Py_Void();
5028  return resultobj;
5029 fail:
5030  return NULL;
5031 }
5032 
5033 
5034 SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5035  PyObject *resultobj = 0;
5036  char *arg1 = (char *) 0 ;
5037  PLFLT arg2 ;
5038  PLINT arg3 ;
5039  char *arg4 = (char *) 0 ;
5040  PLFLT arg5 ;
5041  PLINT arg6 ;
5042  int res1 ;
5043  char *buf1 = 0 ;
5044  int alloc1 = 0 ;
5045  double val2 ;
5046  int ecode2 = 0 ;
5047  int val3 ;
5048  int ecode3 = 0 ;
5049  int res4 ;
5050  char *buf4 = 0 ;
5051  int alloc4 = 0 ;
5052  double val5 ;
5053  int ecode5 = 0 ;
5054  int val6 ;
5055  int ecode6 = 0 ;
5056  PyObject *swig_obj[6] ;
5057 
5058  if (!SWIG_Python_UnpackTuple(args, "plbox", 6, 6, swig_obj)) SWIG_fail;
5059  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5060  if (!SWIG_IsOK(res1)) {
5061  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5062  }
5063  arg1 = (char *)(buf1);
5064  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5065  if (!SWIG_IsOK(ecode2)) {
5066  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5067  }
5068  arg2 = (PLFLT)(val2);
5069  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5070  if (!SWIG_IsOK(ecode3)) {
5071  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5072  }
5073  arg3 = (PLINT)(val3);
5074  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
5075  if (!SWIG_IsOK(res4)) {
5076  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5077  }
5078  arg4 = (char *)(buf4);
5079  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5080  if (!SWIG_IsOK(ecode5)) {
5081  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5082  }
5083  arg5 = (PLFLT)(val5);
5084  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5085  if (!SWIG_IsOK(ecode6)) {
5086  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5087  }
5088  arg6 = (PLINT)(val6);
5089  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5090  resultobj = SWIG_Py_Void();
5091  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5092  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5093  return resultobj;
5094 fail:
5095  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5096  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5097  return NULL;
5098 }
5099 
5100 
5101 SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5102  PyObject *resultobj = 0;
5103  char *arg1 = (char *) 0 ;
5104  char *arg2 = (char *) 0 ;
5105  PLFLT arg3 ;
5106  PLINT arg4 ;
5107  char *arg5 = (char *) 0 ;
5108  char *arg6 = (char *) 0 ;
5109  PLFLT arg7 ;
5110  PLINT arg8 ;
5111  char *arg9 = (char *) 0 ;
5112  char *arg10 = (char *) 0 ;
5113  PLFLT arg11 ;
5114  PLINT arg12 ;
5115  int res1 ;
5116  char *buf1 = 0 ;
5117  int alloc1 = 0 ;
5118  int res2 ;
5119  char *buf2 = 0 ;
5120  int alloc2 = 0 ;
5121  double val3 ;
5122  int ecode3 = 0 ;
5123  int val4 ;
5124  int ecode4 = 0 ;
5125  int res5 ;
5126  char *buf5 = 0 ;
5127  int alloc5 = 0 ;
5128  int res6 ;
5129  char *buf6 = 0 ;
5130  int alloc6 = 0 ;
5131  double val7 ;
5132  int ecode7 = 0 ;
5133  int val8 ;
5134  int ecode8 = 0 ;
5135  int res9 ;
5136  char *buf9 = 0 ;
5137  int alloc9 = 0 ;
5138  int res10 ;
5139  char *buf10 = 0 ;
5140  int alloc10 = 0 ;
5141  double val11 ;
5142  int ecode11 = 0 ;
5143  int val12 ;
5144  int ecode12 = 0 ;
5145  PyObject *swig_obj[12] ;
5146 
5147  if (!SWIG_Python_UnpackTuple(args, "plbox3", 12, 12, swig_obj)) SWIG_fail;
5148  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5149  if (!SWIG_IsOK(res1)) {
5150  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5151  }
5152  arg1 = (char *)(buf1);
5153  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
5154  if (!SWIG_IsOK(res2)) {
5155  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5156  }
5157  arg2 = (char *)(buf2);
5158  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5159  if (!SWIG_IsOK(ecode3)) {
5160  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5161  }
5162  arg3 = (PLFLT)(val3);
5163  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5164  if (!SWIG_IsOK(ecode4)) {
5165  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5166  }
5167  arg4 = (PLINT)(val4);
5168  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
5169  if (!SWIG_IsOK(res5)) {
5170  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5171  }
5172  arg5 = (char *)(buf5);
5173  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5174  if (!SWIG_IsOK(res6)) {
5175  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5176  }
5177  arg6 = (char *)(buf6);
5178  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5179  if (!SWIG_IsOK(ecode7)) {
5180  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5181  }
5182  arg7 = (PLFLT)(val7);
5183  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5184  if (!SWIG_IsOK(ecode8)) {
5185  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5186  }
5187  arg8 = (PLINT)(val8);
5188  res9 = SWIG_AsCharPtrAndSize(swig_obj[8], &buf9, NULL, &alloc9);
5189  if (!SWIG_IsOK(res9)) {
5190  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5191  }
5192  arg9 = (char *)(buf9);
5193  res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
5194  if (!SWIG_IsOK(res10)) {
5195  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5196  }
5197  arg10 = (char *)(buf10);
5198  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5199  if (!SWIG_IsOK(ecode11)) {
5200  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5201  }
5202  arg11 = (PLFLT)(val11);
5203  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
5204  if (!SWIG_IsOK(ecode12)) {
5205  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5206  }
5207  arg12 = (PLINT)(val12);
5208  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);
5209  resultobj = SWIG_Py_Void();
5210  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5211  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5212  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5213  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5214  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5215  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5216  return resultobj;
5217 fail:
5218  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5219  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5220  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5221  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5222  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5223  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5224  return NULL;
5225 }
5226 
5227 
5228 SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5229  PyObject *resultobj = 0;
5230  PLFLT arg1 ;
5231  PLFLT arg2 ;
5232  PLFLT *arg3 = (PLFLT *) 0 ;
5233  PLFLT *arg4 = (PLFLT *) 0 ;
5234  PLINT *arg5 = (PLINT *) 0 ;
5235  double val1 ;
5236  int ecode1 = 0 ;
5237  double val2 ;
5238  int ecode2 = 0 ;
5239  PLFLT temp3 ;
5240  int res3 = SWIG_TMPOBJ ;
5241  PLFLT temp4 ;
5242  int res4 = SWIG_TMPOBJ ;
5243  PLINT temp5 ;
5244  int res5 = SWIG_TMPOBJ ;
5245  PyObject *swig_obj[2] ;
5246 
5247  arg3 = &temp3;
5248  arg4 = &temp4;
5249  arg5 = &temp5;
5250  if (!SWIG_Python_UnpackTuple(args, "plcalc_world", 2, 2, swig_obj)) SWIG_fail;
5251  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5252  if (!SWIG_IsOK(ecode1)) {
5253  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5254  }
5255  arg1 = (PLFLT)(val1);
5256  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5257  if (!SWIG_IsOK(ecode2)) {
5258  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5259  }
5260  arg2 = (PLFLT)(val2);
5261  plcalc_world(arg1,arg2,arg3,arg4,arg5);
5262  resultobj = SWIG_Py_Void();
5263  if (SWIG_IsTmpObj(res3)) {
5264  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5265  } else {
5266  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5267  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5268  }
5269  if (SWIG_IsTmpObj(res4)) {
5270  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5271  } else {
5272  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5273  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5274  }
5275  if (SWIG_IsTmpObj(res5)) {
5276  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5277  } else {
5278  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5279  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5280  }
5281  return resultobj;
5282 fail:
5283  return NULL;
5284 }
5285 
5286 
5287 SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5288  PyObject *resultobj = 0;
5289 
5290  if (!SWIG_Python_UnpackTuple(args, "plclear", 0, 0, 0)) SWIG_fail;
5291  plclear();
5292  resultobj = SWIG_Py_Void();
5293  return resultobj;
5294 fail:
5295  return NULL;
5296 }
5297 
5298 
5299 SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5300  PyObject *resultobj = 0;
5301  PLINT arg1 ;
5302  int val1 ;
5303  int ecode1 = 0 ;
5304  PyObject *swig_obj[1] ;
5305 
5306  if (!args) SWIG_fail;
5307  swig_obj[0] = args;
5308  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5309  if (!SWIG_IsOK(ecode1)) {
5310  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5311  }
5312  arg1 = (PLINT)(val1);
5313  plcol0(arg1);
5314  resultobj = SWIG_Py_Void();
5315  return resultobj;
5316 fail:
5317  return NULL;
5318 }
5319 
5320 
5321 SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5322  PyObject *resultobj = 0;
5323  PLFLT arg1 ;
5324  double val1 ;
5325  int ecode1 = 0 ;
5326  PyObject *swig_obj[1] ;
5327 
5328  if (!args) SWIG_fail;
5329  swig_obj[0] = args;
5330  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5331  if (!SWIG_IsOK(ecode1)) {
5332  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5333  }
5334  arg1 = (PLFLT)(val1);
5335  plcol1(arg1);
5336  resultobj = SWIG_Py_Void();
5337  return resultobj;
5338 fail:
5339  return NULL;
5340 }
5341 
5342 
5343 SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5344  PyObject *resultobj = 0;
5345  PLFLT arg1 ;
5346  PLFLT arg2 ;
5347  PLFLT arg3 ;
5348  PLINT arg4 ;
5349  PLBOOL arg5 ;
5350  PLINT arg6 ;
5351  PLINT arg7 ;
5352  PLINT arg8 ;
5353  PLINT arg9 ;
5354  PLINT arg10 ;
5355  PLFLT arg11 ;
5356  double val1 ;
5357  int ecode1 = 0 ;
5358  double val2 ;
5359  int ecode2 = 0 ;
5360  double val3 ;
5361  int ecode3 = 0 ;
5362  int val4 ;
5363  int ecode4 = 0 ;
5364  int val5 ;
5365  int ecode5 = 0 ;
5366  int val6 ;
5367  int ecode6 = 0 ;
5368  int val7 ;
5369  int ecode7 = 0 ;
5370  int val8 ;
5371  int ecode8 = 0 ;
5372  int val9 ;
5373  int ecode9 = 0 ;
5374  int val10 ;
5375  int ecode10 = 0 ;
5376  double val11 ;
5377  int ecode11 = 0 ;
5378  PyObject *swig_obj[11] ;
5379 
5380  if (!SWIG_Python_UnpackTuple(args, "plconfigtime", 11, 11, swig_obj)) SWIG_fail;
5381  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5382  if (!SWIG_IsOK(ecode1)) {
5383  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5384  }
5385  arg1 = (PLFLT)(val1);
5386  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5387  if (!SWIG_IsOK(ecode2)) {
5388  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5389  }
5390  arg2 = (PLFLT)(val2);
5391  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5392  if (!SWIG_IsOK(ecode3)) {
5393  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5394  }
5395  arg3 = (PLFLT)(val3);
5396  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5397  if (!SWIG_IsOK(ecode4)) {
5398  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5399  }
5400  arg4 = (PLINT)(val4);
5401  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5402  if (!SWIG_IsOK(ecode5)) {
5403  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5404  }
5405  arg5 = (PLBOOL)(val5);
5406  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5407  if (!SWIG_IsOK(ecode6)) {
5408  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5409  }
5410  arg6 = (PLINT)(val6);
5411  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
5412  if (!SWIG_IsOK(ecode7)) {
5413  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5414  }
5415  arg7 = (PLINT)(val7);
5416  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5417  if (!SWIG_IsOK(ecode8)) {
5418  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5419  }
5420  arg8 = (PLINT)(val8);
5421  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
5422  if (!SWIG_IsOK(ecode9)) {
5423  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5424  }
5425  arg9 = (PLINT)(val9);
5426  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
5427  if (!SWIG_IsOK(ecode10)) {
5428  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5429  }
5430  arg10 = (PLINT)(val10);
5431  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5432  if (!SWIG_IsOK(ecode11)) {
5433  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5434  }
5435  arg11 = (PLFLT)(val11);
5436  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5437  resultobj = SWIG_Py_Void();
5438  return resultobj;
5439 fail:
5440  return NULL;
5441 }
5442 
5443 
5444 SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5445  PyObject *resultobj = 0;
5446  PLFLT **arg1 = (PLFLT **) 0 ;
5447  PLINT arg2 ;
5448  PLINT arg3 ;
5449  PLINT arg4 ;
5450  PLINT arg5 ;
5451  PLINT arg6 ;
5452  PLINT arg7 ;
5453  PLFLT *arg8 = (PLFLT *) 0 ;
5454  PLINT arg9 ;
5455  pltr_func arg10 = (pltr_func) 0 ;
5456  PLPointer arg11 = (PLPointer) 0 ;
5457  PyArrayObject *tmp1 = NULL ;
5458  int val4 ;
5459  int ecode4 = 0 ;
5460  int val5 ;
5461  int ecode5 = 0 ;
5462  int val6 ;
5463  int ecode6 = 0 ;
5464  int val7 ;
5465  int ecode7 = 0 ;
5466  PyArrayObject *tmp8 = NULL ;
5467  PyObject *swig_obj[8] ;
5468 
5469  {
5470  python_pltr = 0;
5471  arg10 = NULL;
5472  }
5473  {
5474  arg11 = NULL;
5475  }
5476  if (!SWIG_Python_UnpackTuple(args, "plcont", 6, 8, swig_obj)) SWIG_fail;
5477  {
5478  int i, size;
5479  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
5480  if ( tmp1 == NULL )
5481  return NULL;
5482  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5483  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5484  size = arg3;
5485  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
5486  for ( i = 0; i < arg2; i++ )
5487  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
5488  }
5489  ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
5490  if (!SWIG_IsOK(ecode4)) {
5491  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
5492  }
5493  arg4 = (PLINT)(val4);
5494  ecode5 = SWIG_AsVal_int(swig_obj[2], &val5);
5495  if (!SWIG_IsOK(ecode5)) {
5496  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
5497  }
5498  arg5 = (PLINT)(val5);
5499  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
5500  if (!SWIG_IsOK(ecode6)) {
5501  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
5502  }
5503  arg6 = (PLINT)(val6);
5504  ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
5505  if (!SWIG_IsOK(ecode7)) {
5506  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
5507  }
5508  arg7 = (PLINT)(val7);
5509  {
5510  tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
5511  if ( tmp8 == NULL )
5512  return NULL;
5513  arg9 = PyArray_DIMS( tmp8 )[0];
5514  arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5515  }
5516  if (swig_obj[6]) {
5517  {
5518  // it must be a callable or None
5519  if ( swig_obj[6] == Py_None )
5520  {
5521  arg10 = NULL;
5522  }
5523  else
5524  {
5525  if ( !PyCallable_Check( (PyObject *) swig_obj[6] ) )
5526  {
5527  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
5528  return NULL;
5529  }
5530  arg10 = marshal_pltr( swig_obj[6] );
5531  }
5532  }
5533  }
5534  if (swig_obj[7]) {
5535  {
5536  if ( swig_obj[7] == Py_None )
5537  arg11 = NULL;
5538  else
5539  {
5540  arg11 = marshal_PLPointer( swig_obj[7], 0 );
5541  }
5542  }
5543  }
5544  plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
5545  resultobj = SWIG_Py_Void();
5546  {
5547  Py_CLEAR( tmp1 );
5548  free( arg1 );
5549  }
5550  {
5551  Py_CLEAR( tmp8 );
5552  }
5553  {
5554  cleanup_pltr();
5555  }
5556  {
5558  }
5559  return resultobj;
5560 fail:
5561  {
5562  Py_CLEAR( tmp1 );
5563  free( arg1 );
5564  }
5565  {
5566  Py_CLEAR( tmp8 );
5567  }
5568  {
5569  cleanup_pltr();
5570  }
5571  {
5573  }
5574  return NULL;
5575 }
5576 
5577 
5578 SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5579  PyObject *resultobj = 0;
5580  PLINT arg1 ;
5581  PLINT arg2 ;
5582  PLINT arg3 ;
5583  PLINT arg4 ;
5584  PLINT arg5 ;
5585  PLFLT arg6 ;
5586  PLFLT *arg7 = (PLFLT *) 0 ;
5587  int val1 ;
5588  int ecode1 = 0 ;
5589  int val2 ;
5590  int ecode2 = 0 ;
5591  int val3 ;
5592  int ecode3 = 0 ;
5593  int val4 ;
5594  int ecode4 = 0 ;
5595  int val5 ;
5596  int ecode5 = 0 ;
5597  double val6 ;
5598  int ecode6 = 0 ;
5599  PLFLT temp7 ;
5600  int res7 = SWIG_TMPOBJ ;
5601  PyObject *swig_obj[6] ;
5602 
5603  arg7 = &temp7;
5604  if (!SWIG_Python_UnpackTuple(args, "plctime", 6, 6, swig_obj)) SWIG_fail;
5605  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5606  if (!SWIG_IsOK(ecode1)) {
5607  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
5608  }
5609  arg1 = (PLINT)(val1);
5610  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5611  if (!SWIG_IsOK(ecode2)) {
5612  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
5613  }
5614  arg2 = (PLINT)(val2);
5615  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5616  if (!SWIG_IsOK(ecode3)) {
5617  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
5618  }
5619  arg3 = (PLINT)(val3);
5620  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5621  if (!SWIG_IsOK(ecode4)) {
5622  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
5623  }
5624  arg4 = (PLINT)(val4);
5625  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5626  if (!SWIG_IsOK(ecode5)) {
5627  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
5628  }
5629  arg5 = (PLINT)(val5);
5630  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
5631  if (!SWIG_IsOK(ecode6)) {
5632  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
5633  }
5634  arg6 = (PLFLT)(val6);
5635  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5636  resultobj = SWIG_Py_Void();
5637  if (SWIG_IsTmpObj(res7)) {
5638  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
5639  } else {
5640  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5641  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
5642  }
5643  return resultobj;
5644 fail:
5645  return NULL;
5646 }
5647 
5648 
5649 SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5650  PyObject *resultobj = 0;
5651  PLINT arg1 ;
5652  PLBOOL arg2 ;
5653  int val1 ;
5654  int ecode1 = 0 ;
5655  int val2 ;
5656  int ecode2 = 0 ;
5657  PyObject *swig_obj[2] ;
5658 
5659  if (!SWIG_Python_UnpackTuple(args, "plcpstrm", 2, 2, swig_obj)) SWIG_fail;
5660  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5661  if (!SWIG_IsOK(ecode1)) {
5662  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
5663  }
5664  arg1 = (PLINT)(val1);
5665  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5666  if (!SWIG_IsOK(ecode2)) {
5667  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
5668  }
5669  arg2 = (PLBOOL)(val2);
5670  plcpstrm(arg1,arg2);
5671  resultobj = SWIG_Py_Void();
5672  return resultobj;
5673 fail:
5674  return NULL;
5675 }
5676 
5677 
5678 SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5679  PyObject *resultobj = 0;
5680 
5681  if (!SWIG_Python_UnpackTuple(args, "plend", 0, 0, 0)) SWIG_fail;
5682  plend();
5683  resultobj = SWIG_Py_Void();
5684  return resultobj;
5685 fail:
5686  return NULL;
5687 }
5688 
5689 
5690 SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5691  PyObject *resultobj = 0;
5692 
5693  if (!SWIG_Python_UnpackTuple(args, "plend1", 0, 0, 0)) SWIG_fail;
5694  plend1();
5695  resultobj = SWIG_Py_Void();
5696  return resultobj;
5697 fail:
5698  return NULL;
5699 }
5700 
5701 
5702 SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5703  PyObject *resultobj = 0;
5704  PLFLT arg1 ;
5705  PLFLT arg2 ;
5706  PLFLT arg3 ;
5707  PLFLT arg4 ;
5708  PLINT arg5 ;
5709  PLINT arg6 ;
5710  double val1 ;
5711  int ecode1 = 0 ;
5712  double val2 ;
5713  int ecode2 = 0 ;
5714  double val3 ;
5715  int ecode3 = 0 ;
5716  double val4 ;
5717  int ecode4 = 0 ;
5718  int val5 ;
5719  int ecode5 = 0 ;
5720  int val6 ;
5721  int ecode6 = 0 ;
5722  PyObject *swig_obj[6] ;
5723 
5724  if (!SWIG_Python_UnpackTuple(args, "plenv", 6, 6, swig_obj)) SWIG_fail;
5725  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5726  if (!SWIG_IsOK(ecode1)) {
5727  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
5728  }
5729  arg1 = (PLFLT)(val1);
5730  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5731  if (!SWIG_IsOK(ecode2)) {
5732  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
5733  }
5734  arg2 = (PLFLT)(val2);
5735  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5736  if (!SWIG_IsOK(ecode3)) {
5737  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
5738  }
5739  arg3 = (PLFLT)(val3);
5740  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5741  if (!SWIG_IsOK(ecode4)) {
5742  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
5743  }
5744  arg4 = (PLFLT)(val4);
5745  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5746  if (!SWIG_IsOK(ecode5)) {
5747  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
5748  }
5749  arg5 = (PLINT)(val5);
5750  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5751  if (!SWIG_IsOK(ecode6)) {
5752  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
5753  }
5754  arg6 = (PLINT)(val6);
5755  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
5756  resultobj = SWIG_Py_Void();
5757  return resultobj;
5758 fail:
5759  return NULL;
5760 }
5761 
5762 
5763 SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5764  PyObject *resultobj = 0;
5765  PLFLT arg1 ;
5766  PLFLT arg2 ;
5767  PLFLT arg3 ;
5768  PLFLT arg4 ;
5769  PLINT arg5 ;
5770  PLINT arg6 ;
5771  double val1 ;
5772  int ecode1 = 0 ;
5773  double val2 ;
5774  int ecode2 = 0 ;
5775  double val3 ;
5776  int ecode3 = 0 ;
5777  double val4 ;
5778  int ecode4 = 0 ;
5779  int val5 ;
5780  int ecode5 = 0 ;
5781  int val6 ;
5782  int ecode6 = 0 ;
5783  PyObject *swig_obj[6] ;
5784 
5785  if (!SWIG_Python_UnpackTuple(args, "plenv0", 6, 6, swig_obj)) SWIG_fail;
5786  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5787  if (!SWIG_IsOK(ecode1)) {
5788  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
5789  }
5790  arg1 = (PLFLT)(val1);
5791  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5792  if (!SWIG_IsOK(ecode2)) {
5793  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
5794  }
5795  arg2 = (PLFLT)(val2);
5796  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5797  if (!SWIG_IsOK(ecode3)) {
5798  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
5799  }
5800  arg3 = (PLFLT)(val3);
5801  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5802  if (!SWIG_IsOK(ecode4)) {
5803  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
5804  }
5805  arg4 = (PLFLT)(val4);
5806  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5807  if (!SWIG_IsOK(ecode5)) {
5808  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
5809  }
5810  arg5 = (PLINT)(val5);
5811  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5812  if (!SWIG_IsOK(ecode6)) {
5813  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
5814  }
5815  arg6 = (PLINT)(val6);
5816  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
5817  resultobj = SWIG_Py_Void();
5818  return resultobj;
5819 fail:
5820  return NULL;
5821 }
5822 
5823 
5824 SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5825  PyObject *resultobj = 0;
5826 
5827  if (!SWIG_Python_UnpackTuple(args, "pleop", 0, 0, 0)) SWIG_fail;
5828  pleop();
5829  resultobj = SWIG_Py_Void();
5830  return resultobj;
5831 fail:
5832  return NULL;
5833 }
5834 
5835 
5836 SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5837  PyObject *resultobj = 0;
5838  PLINT arg1 ;
5839  PLFLT *arg2 = (PLFLT *) 0 ;
5840  PLFLT *arg3 = (PLFLT *) 0 ;
5841  PLFLT *arg4 = (PLFLT *) 0 ;
5842  PyArrayObject *tmp1 = NULL ;
5843  PyArrayObject *tmp3 = NULL ;
5844  PyArrayObject *tmp4 = NULL ;
5845  PyObject *swig_obj[3] ;
5846 
5847  if (!SWIG_Python_UnpackTuple(args, "plerrx", 3, 3, swig_obj)) SWIG_fail;
5848  {
5849  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5850  if ( tmp1 == NULL )
5851  return NULL;
5852  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5853  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5854  }
5855  {
5856  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5857  if ( tmp3 == NULL )
5858  return NULL;
5859  if ( PyArray_DIMS( tmp3 )[0] != Alen )
5860  {
5861  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5862  return NULL;
5863  }
5864  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5865  }
5866  {
5867  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
5868  if ( tmp4 == NULL )
5869  return NULL;
5870  if ( PyArray_DIMS( tmp4 )[0] != Alen )
5871  {
5872  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5873  return NULL;
5874  }
5875  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
5876  }
5877  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
5878  resultobj = SWIG_Py_Void();
5879  {
5880  Py_CLEAR( tmp1 );
5881  }
5882  {
5883  Py_CLEAR( tmp3 );
5884  }
5885  {
5886  Py_CLEAR( tmp4 );
5887  }
5888  return resultobj;
5889 fail:
5890  {
5891  Py_CLEAR( tmp1 );
5892  }
5893  {
5894  Py_CLEAR( tmp3 );
5895  }
5896  {
5897  Py_CLEAR( tmp4 );
5898  }
5899  return NULL;
5900 }
5901 
5902 
5903 SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5904  PyObject *resultobj = 0;
5905  PLINT arg1 ;
5906  PLFLT *arg2 = (PLFLT *) 0 ;
5907  PLFLT *arg3 = (PLFLT *) 0 ;
5908  PLFLT *arg4 = (PLFLT *) 0 ;
5909  PyArrayObject *tmp1 = NULL ;
5910  PyArrayObject *tmp3 = NULL ;
5911  PyArrayObject *tmp4 = NULL ;
5912  PyObject *swig_obj[3] ;
5913 
5914  if (!SWIG_Python_UnpackTuple(args, "plerry", 3, 3, swig_obj)) SWIG_fail;
5915  {
5916  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5917  if ( tmp1 == NULL )
5918  return NULL;
5919  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5920  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5921  }
5922  {
5923  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5924  if ( tmp3 == NULL )
5925  return NULL;
5926  if ( PyArray_DIMS( tmp3 )[0] != Alen )
5927  {
5928  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5929  return NULL;
5930  }
5931  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5932  }
5933  {
5934  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
5935  if ( tmp4 == NULL )
5936  return NULL;
5937  if ( PyArray_DIMS( tmp4 )[0] != Alen )
5938  {
5939  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5940  return NULL;
5941  }
5942  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
5943  }
5944  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
5945  resultobj = SWIG_Py_Void();
5946  {
5947  Py_CLEAR( tmp1 );
5948  }
5949  {
5950  Py_CLEAR( tmp3 );
5951  }
5952  {
5953  Py_CLEAR( tmp4 );
5954  }
5955  return resultobj;
5956 fail:
5957  {
5958  Py_CLEAR( tmp1 );
5959  }
5960  {
5961  Py_CLEAR( tmp3 );
5962  }
5963  {
5964  Py_CLEAR( tmp4 );
5965  }
5966  return NULL;
5967 }
5968 
5969 
5970 SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5971  PyObject *resultobj = 0;
5972 
5973  if (!SWIG_Python_UnpackTuple(args, "plfamadv", 0, 0, 0)) SWIG_fail;
5974  plfamadv();
5975  resultobj = SWIG_Py_Void();
5976  return resultobj;
5977 fail:
5978  return NULL;
5979 }
5980 
5981 
5982 SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5983  PyObject *resultobj = 0;
5984  PLINT arg1 ;
5985  PLFLT *arg2 = (PLFLT *) 0 ;
5986  PLFLT *arg3 = (PLFLT *) 0 ;
5987  PyArrayObject *tmp1 = NULL ;
5988  PyArrayObject *tmp3 = NULL ;
5989  PyObject *swig_obj[2] ;
5990 
5991  if (!SWIG_Python_UnpackTuple(args, "plfill", 2, 2, swig_obj)) SWIG_fail;
5992  {
5993  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5994  if ( tmp1 == NULL )
5995  return NULL;
5996  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5997  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5998  }
5999  {
6000  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6001  if ( tmp3 == NULL )
6002  return NULL;
6003  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6004  {
6005  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6006  return NULL;
6007  }
6008  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6009  }
6010  plfill(arg1,(double const *)arg2,(double const *)arg3);
6011  resultobj = SWIG_Py_Void();
6012  {
6013  Py_CLEAR( tmp1 );
6014  }
6015  {
6016  Py_CLEAR( tmp3 );
6017  }
6018  return resultobj;
6019 fail:
6020  {
6021  Py_CLEAR( tmp1 );
6022  }
6023  {
6024  Py_CLEAR( tmp3 );
6025  }
6026  return NULL;
6027 }
6028 
6029 
6030 SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6031  PyObject *resultobj = 0;
6032  PLINT arg1 ;
6033  PLFLT *arg2 = (PLFLT *) 0 ;
6034  PLFLT *arg3 = (PLFLT *) 0 ;
6035  PLFLT *arg4 = (PLFLT *) 0 ;
6036  PyArrayObject *tmp1 = NULL ;
6037  PyArrayObject *tmp3 = NULL ;
6038  PyArrayObject *tmp4 = NULL ;
6039  PyObject *swig_obj[3] ;
6040 
6041  if (!SWIG_Python_UnpackTuple(args, "plfill3", 3, 3, swig_obj)) SWIG_fail;
6042  {
6043  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6044  if ( tmp1 == NULL )
6045  return NULL;
6046  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6047  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6048  }
6049  {
6050  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6051  if ( tmp3 == NULL )
6052  return NULL;
6053  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6054  {
6055  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6056  return NULL;
6057  }
6058  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6059  }
6060  {
6061  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6062  if ( tmp4 == NULL )
6063  return NULL;
6064  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6065  {
6066  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6067  return NULL;
6068  }
6069  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6070  }
6071  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6072  resultobj = SWIG_Py_Void();
6073  {
6074  Py_CLEAR( tmp1 );
6075  }
6076  {
6077  Py_CLEAR( tmp3 );
6078  }
6079  {
6080  Py_CLEAR( tmp4 );
6081  }
6082  return resultobj;
6083 fail:
6084  {
6085  Py_CLEAR( tmp1 );
6086  }
6087  {
6088  Py_CLEAR( tmp3 );
6089  }
6090  {
6091  Py_CLEAR( tmp4 );
6092  }
6093  return NULL;
6094 }
6095 
6096 
6097 SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6098  PyObject *resultobj = 0;
6099  PLINT arg1 ;
6100  PLFLT *arg2 = (PLFLT *) 0 ;
6101  PLFLT *arg3 = (PLFLT *) 0 ;
6102  PLFLT arg4 ;
6103  PyArrayObject *tmp1 = NULL ;
6104  PyArrayObject *tmp3 = NULL ;
6105  double val4 ;
6106  int ecode4 = 0 ;
6107  PyObject *swig_obj[3] ;
6108 
6109  if (!SWIG_Python_UnpackTuple(args, "plgradient", 3, 3, swig_obj)) SWIG_fail;
6110  {
6111  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6112  if ( tmp1 == NULL )
6113  return NULL;
6114  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6115  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6116  }
6117  {
6118  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6119  if ( tmp3 == NULL )
6120  return NULL;
6121  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6122  {
6123  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6124  return NULL;
6125  }
6126  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6127  }
6128  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
6129  if (!SWIG_IsOK(ecode4)) {
6130  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6131  }
6132  arg4 = (PLFLT)(val4);
6133  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6134  resultobj = SWIG_Py_Void();
6135  {
6136  Py_CLEAR( tmp1 );
6137  }
6138  {
6139  Py_CLEAR( tmp3 );
6140  }
6141  return resultobj;
6142 fail:
6143  {
6144  Py_CLEAR( tmp1 );
6145  }
6146  {
6147  Py_CLEAR( tmp3 );
6148  }
6149  return NULL;
6150 }
6151 
6152 
6153 SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6154  PyObject *resultobj = 0;
6155 
6156  if (!SWIG_Python_UnpackTuple(args, "plflush", 0, 0, 0)) SWIG_fail;
6157  plflush();
6158  resultobj = SWIG_Py_Void();
6159  return resultobj;
6160 fail:
6161  return NULL;
6162 }
6163 
6164 
6165 SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6166  PyObject *resultobj = 0;
6167  PLINT arg1 ;
6168  int val1 ;
6169  int ecode1 = 0 ;
6170  PyObject *swig_obj[1] ;
6171 
6172  if (!args) SWIG_fail;
6173  swig_obj[0] = args;
6174  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6175  if (!SWIG_IsOK(ecode1)) {
6176  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6177  }
6178  arg1 = (PLINT)(val1);
6179  plfont(arg1);
6180  resultobj = SWIG_Py_Void();
6181  return resultobj;
6182 fail:
6183  return NULL;
6184 }
6185 
6186 
6187 SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6188  PyObject *resultobj = 0;
6189  PLINT arg1 ;
6190  int val1 ;
6191  int ecode1 = 0 ;
6192  PyObject *swig_obj[1] ;
6193 
6194  if (!args) SWIG_fail;
6195  swig_obj[0] = args;
6196  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6197  if (!SWIG_IsOK(ecode1)) {
6198  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6199  }
6200  arg1 = (PLINT)(val1);
6201  plfontld(arg1);
6202  resultobj = SWIG_Py_Void();
6203  return resultobj;
6204 fail:
6205  return NULL;
6206 }
6207 
6208 
6209 SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6210  PyObject *resultobj = 0;
6211  PLFLT *arg1 = (PLFLT *) 0 ;
6212  PLFLT *arg2 = (PLFLT *) 0 ;
6213  PLFLT temp1 ;
6214  int res1 = SWIG_TMPOBJ ;
6215  PLFLT temp2 ;
6216  int res2 = SWIG_TMPOBJ ;
6217 
6218  arg1 = &temp1;
6219  arg2 = &temp2;
6220  if (!SWIG_Python_UnpackTuple(args, "plgchr", 0, 0, 0)) SWIG_fail;
6221  plgchr(arg1,arg2);
6222  resultobj = SWIG_Py_Void();
6223  if (SWIG_IsTmpObj(res1)) {
6224  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6225  } else {
6226  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6227  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6228  }
6229  if (SWIG_IsTmpObj(res2)) {
6230  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6231  } else {
6232  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6233  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6234  }
6235  return resultobj;
6236 fail:
6237  return NULL;
6238 }
6239 
6240 
6241 SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6242  PyObject *resultobj = 0;
6243  PLINT arg1 ;
6244  PLINT *arg2 = (PLINT *) 0 ;
6245  PLINT *arg3 = (PLINT *) 0 ;
6246  PLINT *arg4 = (PLINT *) 0 ;
6247  int val1 ;
6248  int ecode1 = 0 ;
6249  PLINT temp2 ;
6250  int res2 = SWIG_TMPOBJ ;
6251  PLINT temp3 ;
6252  int res3 = SWIG_TMPOBJ ;
6253  PLINT temp4 ;
6254  int res4 = SWIG_TMPOBJ ;
6255  PyObject *swig_obj[1] ;
6256 
6257  arg2 = &temp2;
6258  arg3 = &temp3;
6259  arg4 = &temp4;
6260  if (!args) SWIG_fail;
6261  swig_obj[0] = args;
6262  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6263  if (!SWIG_IsOK(ecode1)) {
6264  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6265  }
6266  arg1 = (PLINT)(val1);
6267  plgcol0(arg1,arg2,arg3,arg4);
6268  resultobj = SWIG_Py_Void();
6269  if (SWIG_IsTmpObj(res2)) {
6270  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6271  } else {
6272  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6273  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6274  }
6275  if (SWIG_IsTmpObj(res3)) {
6276  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6277  } else {
6278  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6279  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6280  }
6281  if (SWIG_IsTmpObj(res4)) {
6282  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6283  } else {
6284  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6285  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6286  }
6287  return resultobj;
6288 fail:
6289  return NULL;
6290 }
6291 
6292 
6293 SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6294  PyObject *resultobj = 0;
6295  PLINT arg1 ;
6296  PLINT *arg2 = (PLINT *) 0 ;
6297  PLINT *arg3 = (PLINT *) 0 ;
6298  PLINT *arg4 = (PLINT *) 0 ;
6299  PLFLT *arg5 = (PLFLT *) 0 ;
6300  int val1 ;
6301  int ecode1 = 0 ;
6302  PLINT temp2 ;
6303  int res2 = SWIG_TMPOBJ ;
6304  PLINT temp3 ;
6305  int res3 = SWIG_TMPOBJ ;
6306  PLINT temp4 ;
6307  int res4 = SWIG_TMPOBJ ;
6308  PLFLT temp5 ;
6309  int res5 = SWIG_TMPOBJ ;
6310  PyObject *swig_obj[1] ;
6311 
6312  arg2 = &temp2;
6313  arg3 = &temp3;
6314  arg4 = &temp4;
6315  arg5 = &temp5;
6316  if (!args) SWIG_fail;
6317  swig_obj[0] = args;
6318  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6319  if (!SWIG_IsOK(ecode1)) {
6320  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6321  }
6322  arg1 = (PLINT)(val1);
6323  plgcol0a(arg1,arg2,arg3,arg4,arg5);
6324  resultobj = SWIG_Py_Void();
6325  if (SWIG_IsTmpObj(res2)) {
6326  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6327  } else {
6328  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6329  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6330  }
6331  if (SWIG_IsTmpObj(res3)) {
6332  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6333  } else {
6334  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6335  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6336  }
6337  if (SWIG_IsTmpObj(res4)) {
6338  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6339  } else {
6340  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6341  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6342  }
6343  if (SWIG_IsTmpObj(res5)) {
6344  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6345  } else {
6346  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6347  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6348  }
6349  return resultobj;
6350 fail:
6351  return NULL;
6352 }
6353 
6354 
6355 SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6356  PyObject *resultobj = 0;
6357  PLINT *arg1 = (PLINT *) 0 ;
6358  PLINT *arg2 = (PLINT *) 0 ;
6359  PLINT *arg3 = (PLINT *) 0 ;
6360  PLINT temp1 ;
6361  int res1 = SWIG_TMPOBJ ;
6362  PLINT temp2 ;
6363  int res2 = SWIG_TMPOBJ ;
6364  PLINT temp3 ;
6365  int res3 = SWIG_TMPOBJ ;
6366 
6367  arg1 = &temp1;
6368  arg2 = &temp2;
6369  arg3 = &temp3;
6370  if (!SWIG_Python_UnpackTuple(args, "plgcolbg", 0, 0, 0)) SWIG_fail;
6371  plgcolbg(arg1,arg2,arg3);
6372  resultobj = SWIG_Py_Void();
6373  if (SWIG_IsTmpObj(res1)) {
6374  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6375  } else {
6376  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6377  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6378  }
6379  if (SWIG_IsTmpObj(res2)) {
6380  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6381  } else {
6382  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6383  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6384  }
6385  if (SWIG_IsTmpObj(res3)) {
6386  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6387  } else {
6388  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6389  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6390  }
6391  return resultobj;
6392 fail:
6393  return NULL;
6394 }
6395 
6396 
6397 SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6398  PyObject *resultobj = 0;
6399  PLINT *arg1 = (PLINT *) 0 ;
6400  PLINT *arg2 = (PLINT *) 0 ;
6401  PLINT *arg3 = (PLINT *) 0 ;
6402  PLFLT *arg4 = (PLFLT *) 0 ;
6403  PLINT temp1 ;
6404  int res1 = SWIG_TMPOBJ ;
6405  PLINT temp2 ;
6406  int res2 = SWIG_TMPOBJ ;
6407  PLINT temp3 ;
6408  int res3 = SWIG_TMPOBJ ;
6409  PLFLT temp4 ;
6410  int res4 = SWIG_TMPOBJ ;
6411 
6412  arg1 = &temp1;
6413  arg2 = &temp2;
6414  arg3 = &temp3;
6415  arg4 = &temp4;
6416  if (!SWIG_Python_UnpackTuple(args, "plgcolbga", 0, 0, 0)) SWIG_fail;
6417  plgcolbga(arg1,arg2,arg3,arg4);
6418  resultobj = SWIG_Py_Void();
6419  if (SWIG_IsTmpObj(res1)) {
6420  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6421  } else {
6422  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6423  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6424  }
6425  if (SWIG_IsTmpObj(res2)) {
6426  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6427  } else {
6428  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6429  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6430  }
6431  if (SWIG_IsTmpObj(res3)) {
6432  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6433  } else {
6434  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6435  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6436  }
6437  if (SWIG_IsTmpObj(res4)) {
6438  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6439  } else {
6440  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6441  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6442  }
6443  return resultobj;
6444 fail:
6445  return NULL;
6446 }
6447 
6448 
6449 SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6450  PyObject *resultobj = 0;
6451  PLINT *arg1 = (PLINT *) 0 ;
6452  PLINT temp1 ;
6453  int res1 = SWIG_TMPOBJ ;
6454 
6455  arg1 = &temp1;
6456  if (!SWIG_Python_UnpackTuple(args, "plgcompression", 0, 0, 0)) SWIG_fail;
6457  plgcompression(arg1);
6458  resultobj = SWIG_Py_Void();
6459  if (SWIG_IsTmpObj(res1)) {
6460  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6461  } else {
6462  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6463  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6464  }
6465  return resultobj;
6466 fail:
6467  return NULL;
6468 }
6469 
6470 
6471 SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6472  PyObject *resultobj = 0;
6473  char *arg1 = (char *) 0 ;
6474  char buff1[1000] ;
6475 
6476  {
6477  arg1 = buff1;
6478  }
6479  if (!SWIG_Python_UnpackTuple(args, "plgdev", 0, 0, 0)) SWIG_fail;
6480  plgdev(arg1);
6481  resultobj = SWIG_Py_Void();
6482  {
6483  PyObject *o = PyString_FromString( arg1 );
6484  resultobj = t_output_helper( resultobj, o );
6485  }
6486  return resultobj;
6487 fail:
6488  return NULL;
6489 }
6490 
6491 
6492 SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6493  PyObject *resultobj = 0;
6494  PLFLT *arg1 = (PLFLT *) 0 ;
6495  PLFLT *arg2 = (PLFLT *) 0 ;
6496  PLFLT *arg3 = (PLFLT *) 0 ;
6497  PLFLT *arg4 = (PLFLT *) 0 ;
6498  PLFLT temp1 ;
6499  int res1 = SWIG_TMPOBJ ;
6500  PLFLT temp2 ;
6501  int res2 = SWIG_TMPOBJ ;
6502  PLFLT temp3 ;
6503  int res3 = SWIG_TMPOBJ ;
6504  PLFLT temp4 ;
6505  int res4 = SWIG_TMPOBJ ;
6506 
6507  arg1 = &temp1;
6508  arg2 = &temp2;
6509  arg3 = &temp3;
6510  arg4 = &temp4;
6511  if (!SWIG_Python_UnpackTuple(args, "plgdidev", 0, 0, 0)) SWIG_fail;
6512  plgdidev(arg1,arg2,arg3,arg4);
6513  resultobj = SWIG_Py_Void();
6514  if (SWIG_IsTmpObj(res1)) {
6515  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6516  } else {
6517  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6518  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6519  }
6520  if (SWIG_IsTmpObj(res2)) {
6521  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6522  } else {
6523  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6524  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6525  }
6526  if (SWIG_IsTmpObj(res3)) {
6527  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6528  } else {
6529  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6530  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6531  }
6532  if (SWIG_IsTmpObj(res4)) {
6533  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6534  } else {
6535  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6536  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6537  }
6538  return resultobj;
6539 fail:
6540  return NULL;
6541 }
6542 
6543 
6544 SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6545  PyObject *resultobj = 0;
6546  PLFLT *arg1 = (PLFLT *) 0 ;
6547  PLFLT temp1 ;
6548  int res1 = SWIG_TMPOBJ ;
6549 
6550  arg1 = &temp1;
6551  if (!SWIG_Python_UnpackTuple(args, "plgdiori", 0, 0, 0)) SWIG_fail;
6552  plgdiori(arg1);
6553  resultobj = SWIG_Py_Void();
6554  if (SWIG_IsTmpObj(res1)) {
6555  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6556  } else {
6557  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6558  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6559  }
6560  return resultobj;
6561 fail:
6562  return NULL;
6563 }
6564 
6565 
6566 SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6567  PyObject *resultobj = 0;
6568  PLFLT *arg1 = (PLFLT *) 0 ;
6569  PLFLT *arg2 = (PLFLT *) 0 ;
6570  PLFLT *arg3 = (PLFLT *) 0 ;
6571  PLFLT *arg4 = (PLFLT *) 0 ;
6572  PLFLT temp1 ;
6573  int res1 = SWIG_TMPOBJ ;
6574  PLFLT temp2 ;
6575  int res2 = SWIG_TMPOBJ ;
6576  PLFLT temp3 ;
6577  int res3 = SWIG_TMPOBJ ;
6578  PLFLT temp4 ;
6579  int res4 = SWIG_TMPOBJ ;
6580 
6581  arg1 = &temp1;
6582  arg2 = &temp2;
6583  arg3 = &temp3;
6584  arg4 = &temp4;
6585  if (!SWIG_Python_UnpackTuple(args, "plgdiplt", 0, 0, 0)) SWIG_fail;
6586  plgdiplt(arg1,arg2,arg3,arg4);
6587  resultobj = SWIG_Py_Void();
6588  if (SWIG_IsTmpObj(res1)) {
6589  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6590  } else {
6591  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6592  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6593  }
6594  if (SWIG_IsTmpObj(res2)) {
6595  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6596  } else {
6597  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6598  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6599  }
6600  if (SWIG_IsTmpObj(res3)) {
6601  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6602  } else {
6603  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6604  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6605  }
6606  if (SWIG_IsTmpObj(res4)) {
6607  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6608  } else {
6609  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6610  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6611  }
6612  return resultobj;
6613 fail:
6614  return NULL;
6615 }
6616 
6617 
6618 SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6619  PyObject *resultobj = 0;
6620  PLINT *arg1 = (PLINT *) 0 ;
6621  PLINT *arg2 = (PLINT *) 0 ;
6622  PLINT *arg3 = (PLINT *) 0 ;
6623  PLINT temp1 ;
6624  int res1 = SWIG_TMPOBJ ;
6625  PLINT temp2 ;
6626  int res2 = SWIG_TMPOBJ ;
6627  PLINT temp3 ;
6628  int res3 = SWIG_TMPOBJ ;
6629 
6630  arg1 = &temp1;
6631  arg2 = &temp2;
6632  arg3 = &temp3;
6633  if (!SWIG_Python_UnpackTuple(args, "plgfam", 0, 0, 0)) SWIG_fail;
6634  plgfam(arg1,arg2,arg3);
6635  resultobj = SWIG_Py_Void();
6636  if (SWIG_IsTmpObj(res1)) {
6637  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6638  } else {
6639  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6640  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6641  }
6642  if (SWIG_IsTmpObj(res2)) {
6643  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6644  } else {
6645  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6646  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6647  }
6648  if (SWIG_IsTmpObj(res3)) {
6649  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6650  } else {
6651  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6652  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6653  }
6654  return resultobj;
6655 fail:
6656  return NULL;
6657 }
6658 
6659 
6660 SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6661  PyObject *resultobj = 0;
6662  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
6663  PLUNICODE temp1 ;
6664  int res1 = SWIG_TMPOBJ ;
6665 
6666  arg1 = &temp1;
6667  if (!SWIG_Python_UnpackTuple(args, "plgfci", 0, 0, 0)) SWIG_fail;
6668  plgfci(arg1);
6669  resultobj = SWIG_Py_Void();
6670  if (SWIG_IsTmpObj(res1)) {
6671  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
6672  } else {
6673  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6674  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
6675  }
6676  return resultobj;
6677 fail:
6678  return NULL;
6679 }
6680 
6681 
6682 SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6683  PyObject *resultobj = 0;
6684  char *arg1 = (char *) 0 ;
6685  char buff1[1000] ;
6686 
6687  {
6688  arg1 = buff1;
6689  }
6690  if (!SWIG_Python_UnpackTuple(args, "plgfnam", 0, 0, 0)) SWIG_fail;
6691  plgfnam(arg1);
6692  resultobj = SWIG_Py_Void();
6693  {
6694  PyObject *o = PyString_FromString( arg1 );
6695  resultobj = t_output_helper( resultobj, o );
6696  }
6697  return resultobj;
6698 fail:
6699  return NULL;
6700 }
6701 
6702 
6703 SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6704  PyObject *resultobj = 0;
6705  PLINT *arg1 = (PLINT *) 0 ;
6706  PLINT *arg2 = (PLINT *) 0 ;
6707  PLINT *arg3 = (PLINT *) 0 ;
6708  PLINT temp1 ;
6709  int res1 = SWIG_TMPOBJ ;
6710  PLINT temp2 ;
6711  int res2 = SWIG_TMPOBJ ;
6712  PLINT temp3 ;
6713  int res3 = SWIG_TMPOBJ ;
6714 
6715  arg1 = &temp1;
6716  arg2 = &temp2;
6717  arg3 = &temp3;
6718  if (!SWIG_Python_UnpackTuple(args, "plgfont", 0, 0, 0)) SWIG_fail;
6719  plgfont(arg1,arg2,arg3);
6720  resultobj = SWIG_Py_Void();
6721  if (SWIG_IsTmpObj(res1)) {
6722  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6723  } else {
6724  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6725  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6726  }
6727  if (SWIG_IsTmpObj(res2)) {
6728  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6729  } else {
6730  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6731  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6732  }
6733  if (SWIG_IsTmpObj(res3)) {
6734  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6735  } else {
6736  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6737  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6738  }
6739  return resultobj;
6740 fail:
6741  return NULL;
6742 }
6743 
6744 
6745 SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6746  PyObject *resultobj = 0;
6747  PLINT *arg1 = (PLINT *) 0 ;
6748  PLINT temp1 ;
6749  int res1 = SWIG_TMPOBJ ;
6750 
6751  arg1 = &temp1;
6752  if (!SWIG_Python_UnpackTuple(args, "plglevel", 0, 0, 0)) SWIG_fail;
6753  plglevel(arg1);
6754  resultobj = SWIG_Py_Void();
6755  if (SWIG_IsTmpObj(res1)) {
6756  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6757  } else {
6758  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6759  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6760  }
6761  return resultobj;
6762 fail:
6763  return NULL;
6764 }
6765 
6766 
6767 SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6768  PyObject *resultobj = 0;
6769  PLFLT *arg1 = (PLFLT *) 0 ;
6770  PLFLT *arg2 = (PLFLT *) 0 ;
6771  PLINT *arg3 = (PLINT *) 0 ;
6772  PLINT *arg4 = (PLINT *) 0 ;
6773  PLINT *arg5 = (PLINT *) 0 ;
6774  PLINT *arg6 = (PLINT *) 0 ;
6775  PLFLT temp1 ;
6776  int res1 = SWIG_TMPOBJ ;
6777  PLFLT temp2 ;
6778  int res2 = SWIG_TMPOBJ ;
6779  PLINT temp3 ;
6780  int res3 = SWIG_TMPOBJ ;
6781  PLINT temp4 ;
6782  int res4 = SWIG_TMPOBJ ;
6783  PLINT temp5 ;
6784  int res5 = SWIG_TMPOBJ ;
6785  PLINT temp6 ;
6786  int res6 = SWIG_TMPOBJ ;
6787 
6788  arg1 = &temp1;
6789  arg2 = &temp2;
6790  arg3 = &temp3;
6791  arg4 = &temp4;
6792  arg5 = &temp5;
6793  arg6 = &temp6;
6794  if (!SWIG_Python_UnpackTuple(args, "plgpage", 0, 0, 0)) SWIG_fail;
6795  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
6796  resultobj = SWIG_Py_Void();
6797  if (SWIG_IsTmpObj(res1)) {
6798  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6799  } else {
6800  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6801  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6802  }
6803  if (SWIG_IsTmpObj(res2)) {
6804  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6805  } else {
6806  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6807  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6808  }
6809  if (SWIG_IsTmpObj(res3)) {
6810  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6811  } else {
6812  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6813  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6814  }
6815  if (SWIG_IsTmpObj(res4)) {
6816  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6817  } else {
6818  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6819  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6820  }
6821  if (SWIG_IsTmpObj(res5)) {
6822  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
6823  } else {
6824  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6825  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
6826  }
6827  if (SWIG_IsTmpObj(res6)) {
6828  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
6829  } else {
6830  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6831  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
6832  }
6833  return resultobj;
6834 fail:
6835  return NULL;
6836 }
6837 
6838 
6839 SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6840  PyObject *resultobj = 0;
6841 
6842  if (!SWIG_Python_UnpackTuple(args, "plgra", 0, 0, 0)) SWIG_fail;
6843  plgra();
6844  resultobj = SWIG_Py_Void();
6845  return resultobj;
6846 fail:
6847  return NULL;
6848 }
6849 
6850 
6851 SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6852  PyObject *resultobj = 0;
6853  PLFLT *arg1 = (PLFLT *) 0 ;
6854  PLFLT *arg2 = (PLFLT *) 0 ;
6855  PLFLT *arg3 = (PLFLT *) 0 ;
6856  PLINT arg4 ;
6857  PLFLT *arg5 = (PLFLT *) 0 ;
6858  PLINT arg6 ;
6859  PLFLT *arg7 = (PLFLT *) 0 ;
6860  PLINT arg8 ;
6861  PLFLT **arg9 = (PLFLT **) 0 ;
6862  PLINT arg10 ;
6863  PLFLT arg11 ;
6864  PyArrayObject *tmp1 = NULL ;
6865  PyArrayObject *tmp2 = NULL ;
6866  PyArrayObject *tmp3 = NULL ;
6867  PyArrayObject *tmp5 = NULL ;
6868  PyArrayObject *tmp7 = NULL ;
6869  PyObject *array7 = NULL ;
6870  int val10 ;
6871  int ecode10 = 0 ;
6872  double val11 ;
6873  int ecode11 = 0 ;
6874  PyObject *swig_obj[7] ;
6875 
6876  if (!SWIG_Python_UnpackTuple(args, "plgriddata", 7, 7, swig_obj)) SWIG_fail;
6877  {
6878  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6879  if ( tmp1 == NULL )
6880  return NULL;
6881  Alen = PyArray_DIMS( tmp1 )[0];
6882  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
6883  }
6884  {
6885  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6886  if ( tmp2 == NULL )
6887  return NULL;
6888  if ( PyArray_DIMS( tmp2 )[0] != Alen )
6889  {
6890  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6891  return NULL;
6892  }
6893  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
6894  }
6895  {
6896  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6897  if ( tmp3 == NULL )
6898  return NULL;
6899  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6900  {
6901  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6902  return NULL;
6903  }
6904  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6905  arg4 = PyArray_DIMS( tmp3 )[0];
6906  }
6907  {
6908  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
6909  if ( tmp5 == NULL )
6910  return NULL;
6911  Xlen = PyArray_DIMS( tmp5 )[0];
6912  arg6 = Xlen;
6913  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
6914  }
6915  {
6916  int i, size;
6917  npy_intp dims[2];
6918  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
6919  if ( tmp7 == NULL )
6920  return NULL;
6921  Ylen = PyArray_DIMS( tmp7 )[0];
6922  arg8 = Ylen;
6923  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
6924  // Make created 2D array7 have dimensions from prior ArrayX in the argument
6925  // list and this ArrayY.
6926  dims[0] = Xlen;
6927  dims[1] = Ylen;
6928  array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
6929  if ( !array7 )
6930  return NULL;
6931  size = Ylen;
6932  arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
6933  for ( i = 0; i < Xlen; i++ )
6934  arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
6935  }
6936  ecode10 = SWIG_AsVal_int(swig_obj[5], &val10);
6937  if (!SWIG_IsOK(ecode10)) {
6938  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
6939  }
6940  arg10 = (PLINT)(val10);
6941  ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
6942  if (!SWIG_IsOK(ecode11)) {
6943  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
6944  }
6945  arg11 = (PLFLT)(val11);
6946  plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
6947  resultobj = SWIG_Py_Void();
6948  {
6949  resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
6950  }
6951  {
6952  Py_CLEAR( tmp1 );
6953  }
6954  {
6955  Py_CLEAR( tmp2 );
6956  }
6957  {
6958  Py_CLEAR( tmp3 );
6959  }
6960  {
6961  Py_CLEAR( tmp5 );
6962  }
6963  {
6964  Py_CLEAR( tmp7 );
6965  free( arg9 );
6966  }
6967  return resultobj;
6968 fail:
6969  {
6970  Py_CLEAR( tmp1 );
6971  }
6972  {
6973  Py_CLEAR( tmp2 );
6974  }
6975  {
6976  Py_CLEAR( tmp3 );
6977  }
6978  {
6979  Py_CLEAR( tmp5 );
6980  }
6981  {
6982  Py_CLEAR( tmp7 );
6983  free( arg9 );
6984  }
6985  return NULL;
6986 }
6987 
6988 
6989 SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6990  PyObject *resultobj = 0;
6991  PLFLT *arg1 = (PLFLT *) 0 ;
6992  PLFLT *arg2 = (PLFLT *) 0 ;
6993  PLFLT *arg3 = (PLFLT *) 0 ;
6994  PLFLT *arg4 = (PLFLT *) 0 ;
6995  PLFLT temp1 ;
6996  int res1 = SWIG_TMPOBJ ;
6997  PLFLT temp2 ;
6998  int res2 = SWIG_TMPOBJ ;
6999  PLFLT temp3 ;
7000  int res3 = SWIG_TMPOBJ ;
7001  PLFLT temp4 ;
7002  int res4 = SWIG_TMPOBJ ;
7003 
7004  arg1 = &temp1;
7005  arg2 = &temp2;
7006  arg3 = &temp3;
7007  arg4 = &temp4;
7008  if (!SWIG_Python_UnpackTuple(args, "plgspa", 0, 0, 0)) SWIG_fail;
7009  plgspa(arg1,arg2,arg3,arg4);
7010  resultobj = SWIG_Py_Void();
7011  if (SWIG_IsTmpObj(res1)) {
7012  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7013  } else {
7014  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7015  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7016  }
7017  if (SWIG_IsTmpObj(res2)) {
7018  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7019  } else {
7020  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7021  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7022  }
7023  if (SWIG_IsTmpObj(res3)) {
7024  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7025  } else {
7026  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7027  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7028  }
7029  if (SWIG_IsTmpObj(res4)) {
7030  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7031  } else {
7032  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7033  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7034  }
7035  return resultobj;
7036 fail:
7037  return NULL;
7038 }
7039 
7040 
7041 SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7042  PyObject *resultobj = 0;
7043  PLINT *arg1 = (PLINT *) 0 ;
7044  PLINT temp1 ;
7045  int res1 = SWIG_TMPOBJ ;
7046 
7047  arg1 = &temp1;
7048  if (!SWIG_Python_UnpackTuple(args, "plgstrm", 0, 0, 0)) SWIG_fail;
7049  plgstrm(arg1);
7050  resultobj = SWIG_Py_Void();
7051  if (SWIG_IsTmpObj(res1)) {
7052  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7053  } else {
7054  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7055  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7056  }
7057  return resultobj;
7058 fail:
7059  return NULL;
7060 }
7061 
7062 
7063 SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7064  PyObject *resultobj = 0;
7065  char *arg1 = (char *) 0 ;
7066  char buff1[1000] ;
7067 
7068  {
7069  arg1 = buff1;
7070  }
7071  if (!SWIG_Python_UnpackTuple(args, "plgver", 0, 0, 0)) SWIG_fail;
7072  plgver(arg1);
7073  resultobj = SWIG_Py_Void();
7074  {
7075  PyObject *o = PyString_FromString( arg1 );
7076  resultobj = t_output_helper( resultobj, o );
7077  }
7078  return resultobj;
7079 fail:
7080  return NULL;
7081 }
7082 
7083 
7084 SWIGINTERN PyObject *_wrap_plgvpd(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  PLFLT *arg4 = (PLFLT *) 0 ;
7090  PLFLT temp1 ;
7091  int res1 = SWIG_TMPOBJ ;
7092  PLFLT temp2 ;
7093  int res2 = SWIG_TMPOBJ ;
7094  PLFLT temp3 ;
7095  int res3 = SWIG_TMPOBJ ;
7096  PLFLT temp4 ;
7097  int res4 = SWIG_TMPOBJ ;
7098 
7099  arg1 = &temp1;
7100  arg2 = &temp2;
7101  arg3 = &temp3;
7102  arg4 = &temp4;
7103  if (!SWIG_Python_UnpackTuple(args, "plgvpd", 0, 0, 0)) SWIG_fail;
7104  plgvpd(arg1,arg2,arg3,arg4);
7105  resultobj = SWIG_Py_Void();
7106  if (SWIG_IsTmpObj(res1)) {
7107  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7108  } else {
7109  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7110  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7111  }
7112  if (SWIG_IsTmpObj(res2)) {
7113  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7114  } else {
7115  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7116  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7117  }
7118  if (SWIG_IsTmpObj(res3)) {
7119  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7120  } else {
7121  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7122  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7123  }
7124  if (SWIG_IsTmpObj(res4)) {
7125  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7126  } else {
7127  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7128  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7129  }
7130  return resultobj;
7131 fail:
7132  return NULL;
7133 }
7134 
7135 
7136 SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7137  PyObject *resultobj = 0;
7138  PLFLT *arg1 = (PLFLT *) 0 ;
7139  PLFLT *arg2 = (PLFLT *) 0 ;
7140  PLFLT *arg3 = (PLFLT *) 0 ;
7141  PLFLT *arg4 = (PLFLT *) 0 ;
7142  PLFLT temp1 ;
7143  int res1 = SWIG_TMPOBJ ;
7144  PLFLT temp2 ;
7145  int res2 = SWIG_TMPOBJ ;
7146  PLFLT temp3 ;
7147  int res3 = SWIG_TMPOBJ ;
7148  PLFLT temp4 ;
7149  int res4 = SWIG_TMPOBJ ;
7150 
7151  arg1 = &temp1;
7152  arg2 = &temp2;
7153  arg3 = &temp3;
7154  arg4 = &temp4;
7155  if (!SWIG_Python_UnpackTuple(args, "plgvpw", 0, 0, 0)) SWIG_fail;
7156  plgvpw(arg1,arg2,arg3,arg4);
7157  resultobj = SWIG_Py_Void();
7158  if (SWIG_IsTmpObj(res1)) {
7159  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7160  } else {
7161  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7162  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7163  }
7164  if (SWIG_IsTmpObj(res2)) {
7165  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7166  } else {
7167  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7168  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7169  }
7170  if (SWIG_IsTmpObj(res3)) {
7171  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7172  } else {
7173  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7174  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7175  }
7176  if (SWIG_IsTmpObj(res4)) {
7177  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7178  } else {
7179  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7180  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7181  }
7182  return resultobj;
7183 fail:
7184  return NULL;
7185 }
7186 
7187 
7188 SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7189  PyObject *resultobj = 0;
7190  PLINT *arg1 = (PLINT *) 0 ;
7191  PLINT *arg2 = (PLINT *) 0 ;
7192  PLINT temp1 ;
7193  int res1 = SWIG_TMPOBJ ;
7194  PLINT temp2 ;
7195  int res2 = SWIG_TMPOBJ ;
7196 
7197  arg1 = &temp1;
7198  arg2 = &temp2;
7199  if (!SWIG_Python_UnpackTuple(args, "plgxax", 0, 0, 0)) SWIG_fail;
7200  plgxax(arg1,arg2);
7201  resultobj = SWIG_Py_Void();
7202  if (SWIG_IsTmpObj(res1)) {
7203  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7204  } else {
7205  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7206  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7207  }
7208  if (SWIG_IsTmpObj(res2)) {
7209  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7210  } else {
7211  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7212  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7213  }
7214  return resultobj;
7215 fail:
7216  return NULL;
7217 }
7218 
7219 
7220 SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7221  PyObject *resultobj = 0;
7222  PLINT *arg1 = (PLINT *) 0 ;
7223  PLINT *arg2 = (PLINT *) 0 ;
7224  PLINT temp1 ;
7225  int res1 = SWIG_TMPOBJ ;
7226  PLINT temp2 ;
7227  int res2 = SWIG_TMPOBJ ;
7228 
7229  arg1 = &temp1;
7230  arg2 = &temp2;
7231  if (!SWIG_Python_UnpackTuple(args, "plgyax", 0, 0, 0)) SWIG_fail;
7232  plgyax(arg1,arg2);
7233  resultobj = SWIG_Py_Void();
7234  if (SWIG_IsTmpObj(res1)) {
7235  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7236  } else {
7237  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7238  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7239  }
7240  if (SWIG_IsTmpObj(res2)) {
7241  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7242  } else {
7243  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7244  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7245  }
7246  return resultobj;
7247 fail:
7248  return NULL;
7249 }
7250 
7251 
7252 SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7253  PyObject *resultobj = 0;
7254  PLINT *arg1 = (PLINT *) 0 ;
7255  PLINT *arg2 = (PLINT *) 0 ;
7256  PLINT temp1 ;
7257  int res1 = SWIG_TMPOBJ ;
7258  PLINT temp2 ;
7259  int res2 = SWIG_TMPOBJ ;
7260 
7261  arg1 = &temp1;
7262  arg2 = &temp2;
7263  if (!SWIG_Python_UnpackTuple(args, "plgzax", 0, 0, 0)) SWIG_fail;
7264  plgzax(arg1,arg2);
7265  resultobj = SWIG_Py_Void();
7266  if (SWIG_IsTmpObj(res1)) {
7267  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7268  } else {
7269  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7270  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7271  }
7272  if (SWIG_IsTmpObj(res2)) {
7273  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7274  } else {
7275  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7276  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7277  }
7278  return resultobj;
7279 fail:
7280  return NULL;
7281 }
7282 
7283 
7284 SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7285  PyObject *resultobj = 0;
7286  PLINT arg1 ;
7287  PLFLT *arg2 = (PLFLT *) 0 ;
7288  PLFLT arg3 ;
7289  PLFLT arg4 ;
7290  PLINT arg5 ;
7291  PLINT arg6 ;
7292  PyArrayObject *tmp1 = NULL ;
7293  double val3 ;
7294  int ecode3 = 0 ;
7295  double val4 ;
7296  int ecode4 = 0 ;
7297  int val5 ;
7298  int ecode5 = 0 ;
7299  int val6 ;
7300  int ecode6 = 0 ;
7301  PyObject *swig_obj[5] ;
7302 
7303  if (!SWIG_Python_UnpackTuple(args, "plhist", 5, 5, swig_obj)) SWIG_fail;
7304  {
7305  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7306  if ( tmp1 == NULL )
7307  return NULL;
7308  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7309  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7310  }
7311  ecode3 = SWIG_AsVal_double(swig_obj[1], &val3);
7312  if (!SWIG_IsOK(ecode3)) {
7313  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7314  }
7315  arg3 = (PLFLT)(val3);
7316  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
7317  if (!SWIG_IsOK(ecode4)) {
7318  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7319  }
7320  arg4 = (PLFLT)(val4);
7321  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
7322  if (!SWIG_IsOK(ecode5)) {
7323  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7324  }
7325  arg5 = (PLINT)(val5);
7326  ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
7327  if (!SWIG_IsOK(ecode6)) {
7328  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7329  }
7330  arg6 = (PLINT)(val6);
7331  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7332  resultobj = SWIG_Py_Void();
7333  {
7334  Py_CLEAR( tmp1 );
7335  }
7336  return resultobj;
7337 fail:
7338  {
7339  Py_CLEAR( tmp1 );
7340  }
7341  return NULL;
7342 }
7343 
7344 
7345 SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7346  PyObject *resultobj = 0;
7347  PLFLT arg1 ;
7348  PLFLT arg2 ;
7349  PLFLT arg3 ;
7350  PLFLT *arg4 = (PLFLT *) 0 ;
7351  PLFLT *arg5 = (PLFLT *) 0 ;
7352  PLFLT *arg6 = (PLFLT *) 0 ;
7353  double val1 ;
7354  int ecode1 = 0 ;
7355  double val2 ;
7356  int ecode2 = 0 ;
7357  double val3 ;
7358  int ecode3 = 0 ;
7359  PLFLT temp4 ;
7360  int res4 = SWIG_TMPOBJ ;
7361  PLFLT temp5 ;
7362  int res5 = SWIG_TMPOBJ ;
7363  PLFLT temp6 ;
7364  int res6 = SWIG_TMPOBJ ;
7365  PyObject *swig_obj[3] ;
7366 
7367  arg4 = &temp4;
7368  arg5 = &temp5;
7369  arg6 = &temp6;
7370  if (!SWIG_Python_UnpackTuple(args, "plhlsrgb", 3, 3, swig_obj)) SWIG_fail;
7371  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7372  if (!SWIG_IsOK(ecode1)) {
7373  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7374  }
7375  arg1 = (PLFLT)(val1);
7376  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7377  if (!SWIG_IsOK(ecode2)) {
7378  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7379  }
7380  arg2 = (PLFLT)(val2);
7381  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7382  if (!SWIG_IsOK(ecode3)) {
7383  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7384  }
7385  arg3 = (PLFLT)(val3);
7386  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7387  resultobj = SWIG_Py_Void();
7388  if (SWIG_IsTmpObj(res4)) {
7389  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7390  } else {
7391  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7392  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7393  }
7394  if (SWIG_IsTmpObj(res5)) {
7395  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7396  } else {
7397  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7398  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7399  }
7400  if (SWIG_IsTmpObj(res6)) {
7401  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7402  } else {
7403  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7404  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7405  }
7406  return resultobj;
7407 fail:
7408  return NULL;
7409 }
7410 
7411 
7412 SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7413  PyObject *resultobj = 0;
7414 
7415  if (!SWIG_Python_UnpackTuple(args, "plinit", 0, 0, 0)) SWIG_fail;
7416  plinit();
7417  resultobj = SWIG_Py_Void();
7418  return resultobj;
7419 fail:
7420  return NULL;
7421 }
7422 
7423 
7424 SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7425  PyObject *resultobj = 0;
7426  PLFLT arg1 ;
7427  PLFLT arg2 ;
7428  PLFLT arg3 ;
7429  PLFLT arg4 ;
7430  double val1 ;
7431  int ecode1 = 0 ;
7432  double val2 ;
7433  int ecode2 = 0 ;
7434  double val3 ;
7435  int ecode3 = 0 ;
7436  double val4 ;
7437  int ecode4 = 0 ;
7438  PyObject *swig_obj[4] ;
7439 
7440  if (!SWIG_Python_UnpackTuple(args, "pljoin", 4, 4, swig_obj)) SWIG_fail;
7441  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7442  if (!SWIG_IsOK(ecode1)) {
7443  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
7444  }
7445  arg1 = (PLFLT)(val1);
7446  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7447  if (!SWIG_IsOK(ecode2)) {
7448  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
7449  }
7450  arg2 = (PLFLT)(val2);
7451  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7452  if (!SWIG_IsOK(ecode3)) {
7453  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
7454  }
7455  arg3 = (PLFLT)(val3);
7456  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
7457  if (!SWIG_IsOK(ecode4)) {
7458  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
7459  }
7460  arg4 = (PLFLT)(val4);
7461  pljoin(arg1,arg2,arg3,arg4);
7462  resultobj = SWIG_Py_Void();
7463  return resultobj;
7464 fail:
7465  return NULL;
7466 }
7467 
7468 
7469 SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7470  PyObject *resultobj = 0;
7471  char *arg1 = (char *) 0 ;
7472  char *arg2 = (char *) 0 ;
7473  char *arg3 = (char *) 0 ;
7474  int res1 ;
7475  char *buf1 = 0 ;
7476  int alloc1 = 0 ;
7477  int res2 ;
7478  char *buf2 = 0 ;
7479  int alloc2 = 0 ;
7480  int res3 ;
7481  char *buf3 = 0 ;
7482  int alloc3 = 0 ;
7483  PyObject *swig_obj[3] ;
7484 
7485  if (!SWIG_Python_UnpackTuple(args, "pllab", 3, 3, swig_obj)) SWIG_fail;
7486  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
7487  if (!SWIG_IsOK(res1)) {
7488  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
7489  }
7490  arg1 = (char *)(buf1);
7491  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
7492  if (!SWIG_IsOK(res2)) {
7493  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
7494  }
7495  arg2 = (char *)(buf2);
7496  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
7497  if (!SWIG_IsOK(res3)) {
7498  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
7499  }
7500  arg3 = (char *)(buf3);
7501  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
7502  resultobj = SWIG_Py_Void();
7503  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7504  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7505  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7506  return resultobj;
7507 fail:
7508  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7509  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7510  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7511  return NULL;
7512 }
7513 
7514 
7515 SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7516  PyObject *resultobj = 0;
7517  PLFLT *arg1 = (PLFLT *) 0 ;
7518  PLFLT *arg2 = (PLFLT *) 0 ;
7519  PLINT arg3 ;
7520  PLINT arg4 ;
7521  PLFLT arg5 ;
7522  PLFLT arg6 ;
7523  PLFLT arg7 ;
7524  PLINT arg8 ;
7525  PLINT arg9 ;
7526  PLINT arg10 ;
7527  PLINT arg11 ;
7528  PLINT arg12 ;
7529  PLINT arg13 ;
7530  PLINT *arg14 = (PLINT *) 0 ;
7531  PLFLT arg15 ;
7532  PLFLT arg16 ;
7533  PLFLT arg17 ;
7534  PLFLT arg18 ;
7535  PLINT *arg19 = (PLINT *) 0 ;
7536  char **arg20 = (char **) 0 ;
7537  PLINT *arg21 = (PLINT *) 0 ;
7538  PLINT *arg22 = (PLINT *) 0 ;
7539  PLFLT *arg23 = (PLFLT *) 0 ;
7540  PLFLT *arg24 = (PLFLT *) 0 ;
7541  PLINT *arg25 = (PLINT *) 0 ;
7542  PLINT *arg26 = (PLINT *) 0 ;
7543  PLFLT *arg27 = (PLFLT *) 0 ;
7544  PLINT *arg28 = (PLINT *) 0 ;
7545  PLFLT *arg29 = (PLFLT *) 0 ;
7546  PLINT *arg30 = (PLINT *) 0 ;
7547  char **arg31 = (char **) 0 ;
7548  PLFLT temp1 ;
7549  int res1 = SWIG_TMPOBJ ;
7550  PLFLT temp2 ;
7551  int res2 = SWIG_TMPOBJ ;
7552  int val3 ;
7553  int ecode3 = 0 ;
7554  int val4 ;
7555  int ecode4 = 0 ;
7556  double val5 ;
7557  int ecode5 = 0 ;
7558  double val6 ;
7559  int ecode6 = 0 ;
7560  double val7 ;
7561  int ecode7 = 0 ;
7562  int val8 ;
7563  int ecode8 = 0 ;
7564  int val9 ;
7565  int ecode9 = 0 ;
7566  int val10 ;
7567  int ecode10 = 0 ;
7568  int val11 ;
7569  int ecode11 = 0 ;
7570  int val12 ;
7571  int ecode12 = 0 ;
7572  PyArrayObject *tmp13 = NULL ;
7573  double val15 ;
7574  int ecode15 = 0 ;
7575  double val16 ;
7576  int ecode16 = 0 ;
7577  double val17 ;
7578  int ecode17 = 0 ;
7579  double val18 ;
7580  int ecode18 = 0 ;
7581  PyArrayObject *tmp19 = NULL ;
7582  PyArrayObject *tmp20 = NULL ;
7583  PyArrayObject *tmp21 = NULL ;
7584  PyArrayObject *tmp22 = NULL ;
7585  PyArrayObject *tmp23 = NULL ;
7586  PyArrayObject *tmp24 = NULL ;
7587  PyArrayObject *tmp25 = NULL ;
7588  PyArrayObject *tmp26 = NULL ;
7589  PyArrayObject *tmp27 = NULL ;
7590  PyArrayObject *tmp28 = NULL ;
7591  PyArrayObject *tmp29 = NULL ;
7592  PyArrayObject *tmp30 = NULL ;
7593  PyArrayObject *tmp31 = NULL ;
7594  PyObject *swig_obj[28] ;
7595 
7596  arg1 = &temp1;
7597  arg2 = &temp2;
7598  if (!SWIG_Python_UnpackTuple(args, "pllegend", 28, 28, swig_obj)) SWIG_fail;
7599  ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
7600  if (!SWIG_IsOK(ecode3)) {
7601  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
7602  }
7603  arg3 = (PLINT)(val3);
7604  ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
7605  if (!SWIG_IsOK(ecode4)) {
7606  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
7607  }
7608  arg4 = (PLINT)(val4);
7609  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
7610  if (!SWIG_IsOK(ecode5)) {
7611  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
7612  }
7613  arg5 = (PLFLT)(val5);
7614  ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
7615  if (!SWIG_IsOK(ecode6)) {
7616  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
7617  }
7618  arg6 = (PLFLT)(val6);
7619  ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
7620  if (!SWIG_IsOK(ecode7)) {
7621  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
7622  }
7623  arg7 = (PLFLT)(val7);
7624  ecode8 = SWIG_AsVal_int(swig_obj[5], &val8);
7625  if (!SWIG_IsOK(ecode8)) {
7626  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
7627  }
7628  arg8 = (PLINT)(val8);
7629  ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
7630  if (!SWIG_IsOK(ecode9)) {
7631  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
7632  }
7633  arg9 = (PLINT)(val9);
7634  ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
7635  if (!SWIG_IsOK(ecode10)) {
7636  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
7637  }
7638  arg10 = (PLINT)(val10);
7639  ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
7640  if (!SWIG_IsOK(ecode11)) {
7641  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
7642  }
7643  arg11 = (PLINT)(val11);
7644  ecode12 = SWIG_AsVal_int(swig_obj[9], &val12);
7645  if (!SWIG_IsOK(ecode12)) {
7646  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
7647  }
7648  arg12 = (PLINT)(val12);
7649  {
7650  tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[10], NPY_PLINT, 1, 1 );
7651  if ( tmp13 == NULL )
7652  return NULL;
7653  arg13 = Alen = PyArray_DIMS( tmp13 )[0];
7654  arg14 = (PLINT *) PyArray_DATA( tmp13 );
7655  }
7656  ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
7657  if (!SWIG_IsOK(ecode15)) {
7658  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
7659  }
7660  arg15 = (PLFLT)(val15);
7661  ecode16 = SWIG_AsVal_double(swig_obj[12], &val16);
7662  if (!SWIG_IsOK(ecode16)) {
7663  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
7664  }
7665  arg16 = (PLFLT)(val16);
7666  ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
7667  if (!SWIG_IsOK(ecode17)) {
7668  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
7669  }
7670  arg17 = (PLFLT)(val17);
7671  ecode18 = SWIG_AsVal_double(swig_obj[14], &val18);
7672  if (!SWIG_IsOK(ecode18)) {
7673  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
7674  }
7675  arg18 = (PLFLT)(val18);
7676  {
7677  tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[15], NPY_PLINT, 1, 1 );
7678  if ( tmp19 == NULL )
7679  return NULL;
7680  if ( PyArray_DIMS( tmp19 )[0] != Alen )
7681  {
7682  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7683  return NULL;
7684  }
7685  arg19 = (PLINT *) PyArray_DATA( tmp19 );
7686  }
7687  {
7688  int i;
7689  tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[16], NPY_STRING, 1, 1 );
7690  if ( tmp20 == NULL )
7691  return NULL;
7692  if ( PyArray_DIMS( tmp20 )[0] != Alen )
7693  {
7694  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7695  return NULL;
7696  }
7697  arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
7698  for ( i = 0; i < Alen; i++ )
7699  {
7700  arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
7701  if ( arg20[i] == NULL )
7702  {
7703  free( arg20 );
7704  return NULL;
7705  }
7706  }
7707  }
7708  {
7709  tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
7710  if ( tmp21 == NULL )
7711  return NULL;
7712  if ( PyArray_DIMS( tmp21 )[0] != Alen )
7713  {
7714  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7715  return NULL;
7716  }
7717  arg21 = (PLINT *) PyArray_DATA( tmp21 );
7718  }
7719  {
7720  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
7721  if ( tmp22 == NULL )
7722  return NULL;
7723  if ( PyArray_DIMS( tmp22 )[0] != Alen )
7724  {
7725  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7726  return NULL;
7727  }
7728  arg22 = (PLINT *) PyArray_DATA( tmp22 );
7729  }
7730  {
7731  if ( swig_obj[19] != Py_None )
7732  {
7733  tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 1, 1 );
7734  if ( tmp23 == NULL )
7735  return NULL;
7736  if ( PyArray_DIMS( tmp23 )[0] != Alen )
7737  {
7738  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7739  return NULL;
7740  }
7741  arg23 = (PLFLT *) PyArray_DATA( tmp23 );
7742  }
7743  else
7744  {
7745  arg23 = NULL;
7746  }
7747  }
7748  {
7749  if ( swig_obj[20] != Py_None )
7750  {
7751  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[20], NPY_PLFLT, 1, 1 );
7752  if ( tmp24 == NULL )
7753  return NULL;
7754  if ( PyArray_DIMS( tmp24 )[0] != Alen )
7755  {
7756  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7757  return NULL;
7758  }
7759  arg24 = (PLFLT *) PyArray_DATA( tmp24 );
7760  }
7761  else
7762  {
7763  arg24 = NULL;
7764  }
7765  }
7766  {
7767  tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[21], NPY_PLINT, 1, 1 );
7768  if ( tmp25 == NULL )
7769  return NULL;
7770  if ( PyArray_DIMS( tmp25 )[0] != Alen )
7771  {
7772  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7773  return NULL;
7774  }
7775  arg25 = (PLINT *) PyArray_DATA( tmp25 );
7776  }
7777  {
7778  tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[22], NPY_PLINT, 1, 1 );
7779  if ( tmp26 == NULL )
7780  return NULL;
7781  if ( PyArray_DIMS( tmp26 )[0] != Alen )
7782  {
7783  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7784  return NULL;
7785  }
7786  arg26 = (PLINT *) PyArray_DATA( tmp26 );
7787  }
7788  {
7789  if ( swig_obj[23] != Py_None )
7790  {
7791  tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[23], NPY_PLFLT, 1, 1 );
7792  if ( tmp27 == NULL )
7793  return NULL;
7794  if ( PyArray_DIMS( tmp27 )[0] != Alen )
7795  {
7796  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7797  return NULL;
7798  }
7799  arg27 = (PLFLT *) PyArray_DATA( tmp27 );
7800  }
7801  else
7802  {
7803  arg27 = NULL;
7804  }
7805  }
7806  {
7807  tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[24], NPY_PLINT, 1, 1 );
7808  if ( tmp28 == NULL )
7809  return NULL;
7810  if ( PyArray_DIMS( tmp28 )[0] != Alen )
7811  {
7812  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7813  return NULL;
7814  }
7815  arg28 = (PLINT *) PyArray_DATA( tmp28 );
7816  }
7817  {
7818  if ( swig_obj[25] != Py_None )
7819  {
7820  tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[25], NPY_PLFLT, 1, 1 );
7821  if ( tmp29 == NULL )
7822  return NULL;
7823  if ( PyArray_DIMS( tmp29 )[0] != Alen )
7824  {
7825  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7826  return NULL;
7827  }
7828  arg29 = (PLFLT *) PyArray_DATA( tmp29 );
7829  }
7830  else
7831  {
7832  arg29 = NULL;
7833  }
7834  }
7835  {
7836  tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[26], NPY_PLINT, 1, 1 );
7837  if ( tmp30 == NULL )
7838  return NULL;
7839  if ( PyArray_DIMS( tmp30 )[0] != Alen )
7840  {
7841  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7842  return NULL;
7843  }
7844  arg30 = (PLINT *) PyArray_DATA( tmp30 );
7845  }
7846  {
7847  int i;
7848  tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[27], NPY_STRING, 1, 1 );
7849  if ( tmp31 == NULL )
7850  return NULL;
7851  if ( PyArray_DIMS( tmp31 )[0] != Alen )
7852  {
7853  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7854  return NULL;
7855  }
7856  arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
7857  for ( i = 0; i < Alen; i++ )
7858  {
7859  arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
7860  if ( arg31[i] == NULL )
7861  {
7862  free( arg31 );
7863  return NULL;
7864  }
7865  }
7866  }
7867  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);
7868  resultobj = SWIG_Py_Void();
7869  if (SWIG_IsTmpObj(res1)) {
7870  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7871  } else {
7872  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7873  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7874  }
7875  if (SWIG_IsTmpObj(res2)) {
7876  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7877  } else {
7878  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7879  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7880  }
7881  {
7882  Py_CLEAR( tmp13 );
7883  }
7884  {
7885  Py_CLEAR( tmp19 );
7886  }
7887  {
7888  Py_CLEAR( tmp20 ); free( arg20 );
7889  }
7890  {
7891  Py_CLEAR( tmp21 );
7892  }
7893  {
7894  Py_CLEAR( tmp22 );
7895  }
7896  {
7897  Py_CLEAR( tmp23 );
7898  }
7899  {
7900  Py_CLEAR( tmp24 );
7901  }
7902  {
7903  Py_CLEAR( tmp25 );
7904  }
7905  {
7906  Py_CLEAR( tmp26 );
7907  }
7908  {
7909  Py_CLEAR( tmp27 );
7910  }
7911  {
7912  Py_CLEAR( tmp28 );
7913  }
7914  {
7915  Py_CLEAR( tmp29 );
7916  }
7917  {
7918  Py_CLEAR( tmp30 );
7919  }
7920  {
7921  Py_CLEAR( tmp31 ); free( arg31 );
7922  }
7923  return resultobj;
7924 fail:
7925  {
7926  Py_CLEAR( tmp13 );
7927  }
7928  {
7929  Py_CLEAR( tmp19 );
7930  }
7931  {
7932  Py_CLEAR( tmp20 ); free( arg20 );
7933  }
7934  {
7935  Py_CLEAR( tmp21 );
7936  }
7937  {
7938  Py_CLEAR( tmp22 );
7939  }
7940  {
7941  Py_CLEAR( tmp23 );
7942  }
7943  {
7944  Py_CLEAR( tmp24 );
7945  }
7946  {
7947  Py_CLEAR( tmp25 );
7948  }
7949  {
7950  Py_CLEAR( tmp26 );
7951  }
7952  {
7953  Py_CLEAR( tmp27 );
7954  }
7955  {
7956  Py_CLEAR( tmp28 );
7957  }
7958  {
7959  Py_CLEAR( tmp29 );
7960  }
7961  {
7962  Py_CLEAR( tmp30 );
7963  }
7964  {
7965  Py_CLEAR( tmp31 ); free( arg31 );
7966  }
7967  return NULL;
7968 }
7969 
7970 
7971 SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7972  PyObject *resultobj = 0;
7973  PLFLT *arg1 = (PLFLT *) 0 ;
7974  PLFLT *arg2 = (PLFLT *) 0 ;
7975  PLINT arg3 ;
7976  PLINT arg4 ;
7977  PLFLT arg5 ;
7978  PLFLT arg6 ;
7979  PLFLT arg7 ;
7980  PLFLT arg8 ;
7981  PLINT arg9 ;
7982  PLINT arg10 ;
7983  PLINT arg11 ;
7984  PLFLT arg12 ;
7985  PLFLT arg13 ;
7986  PLINT arg14 ;
7987  PLFLT arg15 ;
7988  PLINT arg16 ;
7989  PLINT *arg17 = (PLINT *) 0 ;
7990  char **arg18 = (char **) 0 ;
7991  PLINT arg19 ;
7992  char **arg20 = (char **) 0 ;
7993  PLFLT *arg21 = (PLFLT *) 0 ;
7994  PLINT *arg22 = (PLINT *) 0 ;
7995  PLINT *arg23 = (PLINT *) 0 ;
7996  PLFLT **arg24 = (PLFLT **) 0 ;
7997  PLFLT temp1 ;
7998  int res1 = SWIG_TMPOBJ ;
7999  PLFLT temp2 ;
8000  int res2 = SWIG_TMPOBJ ;
8001  int val3 ;
8002  int ecode3 = 0 ;
8003  int val4 ;
8004  int ecode4 = 0 ;
8005  double val5 ;
8006  int ecode5 = 0 ;
8007  double val6 ;
8008  int ecode6 = 0 ;
8009  double val7 ;
8010  int ecode7 = 0 ;
8011  double val8 ;
8012  int ecode8 = 0 ;
8013  int val9 ;
8014  int ecode9 = 0 ;
8015  int val10 ;
8016  int ecode10 = 0 ;
8017  int val11 ;
8018  int ecode11 = 0 ;
8019  double val12 ;
8020  int ecode12 = 0 ;
8021  double val13 ;
8022  int ecode13 = 0 ;
8023  int val14 ;
8024  int ecode14 = 0 ;
8025  double val15 ;
8026  int ecode15 = 0 ;
8027  PyArrayObject *tmp16 = NULL ;
8028  PyArrayObject *tmp18 = NULL ;
8029  PyArrayObject *tmp19 = NULL ;
8030  PyArrayObject *tmp21 = NULL ;
8031  PyArrayObject *tmp22 = NULL ;
8032  PyArrayObject *tmp23 = NULL ;
8033  PyArrayObject *tmp24 = NULL ;
8034  PyObject *swig_obj[20] ;
8035 
8036  arg1 = &temp1;
8037  arg2 = &temp2;
8038  if (!SWIG_Python_UnpackTuple(args, "plcolorbar", 20, 20, swig_obj)) SWIG_fail;
8039  ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8040  if (!SWIG_IsOK(ecode3)) {
8041  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8042  }
8043  arg3 = (PLINT)(val3);
8044  ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8045  if (!SWIG_IsOK(ecode4)) {
8046  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8047  }
8048  arg4 = (PLINT)(val4);
8049  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8050  if (!SWIG_IsOK(ecode5)) {
8051  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8052  }
8053  arg5 = (PLFLT)(val5);
8054  ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8055  if (!SWIG_IsOK(ecode6)) {
8056  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8057  }
8058  arg6 = (PLFLT)(val6);
8059  ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8060  if (!SWIG_IsOK(ecode7)) {
8061  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8062  }
8063  arg7 = (PLFLT)(val7);
8064  ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
8065  if (!SWIG_IsOK(ecode8)) {
8066  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8067  }
8068  arg8 = (PLFLT)(val8);
8069  ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8070  if (!SWIG_IsOK(ecode9)) {
8071  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8072  }
8073  arg9 = (PLINT)(val9);
8074  ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8075  if (!SWIG_IsOK(ecode10)) {
8076  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8077  }
8078  arg10 = (PLINT)(val10);
8079  ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8080  if (!SWIG_IsOK(ecode11)) {
8081  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8082  }
8083  arg11 = (PLINT)(val11);
8084  ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
8085  if (!SWIG_IsOK(ecode12)) {
8086  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8087  }
8088  arg12 = (PLFLT)(val12);
8089  ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
8090  if (!SWIG_IsOK(ecode13)) {
8091  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8092  }
8093  arg13 = (PLFLT)(val13);
8094  ecode14 = SWIG_AsVal_int(swig_obj[11], &val14);
8095  if (!SWIG_IsOK(ecode14)) {
8096  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8097  }
8098  arg14 = (PLINT)(val14);
8099  ecode15 = SWIG_AsVal_double(swig_obj[12], &val15);
8100  if (!SWIG_IsOK(ecode15)) {
8101  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8102  }
8103  arg15 = (PLFLT)(val15);
8104  {
8105  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
8106  if ( tmp16 == NULL )
8107  return NULL;
8108  arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8109  arg17 = (PLINT *) PyArray_DATA( tmp16 );
8110  }
8111  {
8112  int i;
8113  tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[14], NPY_STRING, 1, 1 );
8114  if ( tmp18 == NULL )
8115  return NULL;
8116  if ( PyArray_DIMS( tmp18 )[0] != Alen )
8117  {
8118  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8119  return NULL;
8120  }
8121  arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8122  for ( i = 0; i < Alen; i++ )
8123  {
8124  arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8125  if ( arg18[i] == NULL )
8126  {
8127  free( arg18 );
8128  return NULL;
8129  }
8130  }
8131  }
8132  {
8133  int i;
8134  tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[15], NPY_STRING, 1, 1 );
8135  if ( tmp19 == NULL )
8136  return NULL;
8137  Alen = PyArray_DIMS( tmp19 )[0];
8138  arg19 = Alen;
8139  arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8140  for ( i = 0; i < Alen; i++ )
8141  {
8142  arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8143  if ( arg20[i] == NULL )
8144  {
8145  free( arg20 );
8146  return NULL;
8147  }
8148  }
8149  }
8150  {
8151  tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[16], NPY_PLFLT, 1, 1 );
8152  if ( tmp21 == NULL )
8153  return NULL;
8154  if ( PyArray_DIMS( tmp21 )[0] != Alen )
8155  {
8156  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8157  return NULL;
8158  }
8159  arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8160  }
8161  {
8162  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8163  if ( tmp22 == NULL )
8164  return NULL;
8165  if ( PyArray_DIMS( tmp22 )[0] != Alen )
8166  {
8167  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8168  return NULL;
8169  }
8170  arg22 = (PLINT *) PyArray_DATA( tmp22 );
8171  }
8172  {
8173  int i;
8174  tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8175  if ( tmp23 == NULL )
8176  return NULL;
8177  if ( PyArray_DIMS( tmp23 )[0] != Alen )
8178  {
8179  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8180  return NULL;
8181  }
8182  Xlen = PyArray_DIMS( tmp23 )[0];
8183  arg23 = (PLINT *) PyArray_DATA( tmp23 );
8184  Ylen = -1;
8185  for ( i = 0; i < Xlen; i++ )
8186  if ( arg23[i] > Ylen )
8187  Ylen = arg23[i];
8188  }
8189  {
8190  int i, size;
8191  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 2, 2 );
8192  if ( tmp24 == NULL )
8193  return NULL;
8194  if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8195  {
8196  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8197  return NULL;
8198  }
8199  size = Ylen;
8200  arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8201  for ( i = 0; i < Xlen; i++ )
8202  arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8203  }
8204  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);
8205  resultobj = SWIG_Py_Void();
8206  if (SWIG_IsTmpObj(res1)) {
8207  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8208  } else {
8209  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8210  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8211  }
8212  if (SWIG_IsTmpObj(res2)) {
8213  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8214  } else {
8215  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8216  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8217  }
8218  {
8219  Py_CLEAR( tmp16 );
8220  }
8221  {
8222  Py_CLEAR( tmp18 ); free( arg18 );
8223  }
8224  {
8225  Py_CLEAR( tmp19 ); free( arg20 );
8226  }
8227  {
8228  Py_CLEAR( tmp21 );
8229  }
8230  {
8231  Py_CLEAR( tmp22 );
8232  }
8233  {
8234  Py_CLEAR( tmp23 );
8235  }
8236  {
8237  Py_CLEAR( tmp24 );
8238  free( arg24 );
8239  }
8240  return resultobj;
8241 fail:
8242  {
8243  Py_CLEAR( tmp16 );
8244  }
8245  {
8246  Py_CLEAR( tmp18 ); free( arg18 );
8247  }
8248  {
8249  Py_CLEAR( tmp19 ); free( arg20 );
8250  }
8251  {
8252  Py_CLEAR( tmp21 );
8253  }
8254  {
8255  Py_CLEAR( tmp22 );
8256  }
8257  {
8258  Py_CLEAR( tmp23 );
8259  }
8260  {
8261  Py_CLEAR( tmp24 );
8262  free( arg24 );
8263  }
8264  return NULL;
8265 }
8266 
8267 
8268 SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8269  PyObject *resultobj = 0;
8270  PLFLT arg1 ;
8271  PLFLT arg2 ;
8272  PLFLT arg3 ;
8273  double val1 ;
8274  int ecode1 = 0 ;
8275  double val2 ;
8276  int ecode2 = 0 ;
8277  double val3 ;
8278  int ecode3 = 0 ;
8279  PyObject *swig_obj[3] ;
8280 
8281  if (!SWIG_Python_UnpackTuple(args, "pllightsource", 3, 3, swig_obj)) SWIG_fail;
8282  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8283  if (!SWIG_IsOK(ecode1)) {
8284  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8285  }
8286  arg1 = (PLFLT)(val1);
8287  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8288  if (!SWIG_IsOK(ecode2)) {
8289  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8290  }
8291  arg2 = (PLFLT)(val2);
8292  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8293  if (!SWIG_IsOK(ecode3)) {
8294  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8295  }
8296  arg3 = (PLFLT)(val3);
8297  pllightsource(arg1,arg2,arg3);
8298  resultobj = SWIG_Py_Void();
8299  return resultobj;
8300 fail:
8301  return NULL;
8302 }
8303 
8304 
8305 SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8306  PyObject *resultobj = 0;
8307  PLINT arg1 ;
8308  PLFLT *arg2 = (PLFLT *) 0 ;
8309  PLFLT *arg3 = (PLFLT *) 0 ;
8310  PyArrayObject *tmp1 = NULL ;
8311  PyArrayObject *tmp3 = NULL ;
8312  PyObject *swig_obj[2] ;
8313 
8314  if (!SWIG_Python_UnpackTuple(args, "plline", 2, 2, swig_obj)) SWIG_fail;
8315  {
8316  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8317  if ( tmp1 == NULL )
8318  return NULL;
8319  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8320  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8321  }
8322  {
8323  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8324  if ( tmp3 == NULL )
8325  return NULL;
8326  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8327  {
8328  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8329  return NULL;
8330  }
8331  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8332  }
8333  plline(arg1,(double const *)arg2,(double const *)arg3);
8334  resultobj = SWIG_Py_Void();
8335  {
8336  Py_CLEAR( tmp1 );
8337  }
8338  {
8339  Py_CLEAR( tmp3 );
8340  }
8341  return resultobj;
8342 fail:
8343  {
8344  Py_CLEAR( tmp1 );
8345  }
8346  {
8347  Py_CLEAR( tmp3 );
8348  }
8349  return NULL;
8350 }
8351 
8352 
8353 SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8354  PyObject *resultobj = 0;
8355  PLINT arg1 ;
8356  PLFLT *arg2 = (PLFLT *) 0 ;
8357  PLFLT *arg3 = (PLFLT *) 0 ;
8358  PLFLT *arg4 = (PLFLT *) 0 ;
8359  PyArrayObject *tmp1 = NULL ;
8360  PyArrayObject *tmp3 = NULL ;
8361  PyArrayObject *tmp4 = NULL ;
8362  PyObject *swig_obj[3] ;
8363 
8364  if (!SWIG_Python_UnpackTuple(args, "plline3", 3, 3, swig_obj)) SWIG_fail;
8365  {
8366  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8367  if ( tmp1 == NULL )
8368  return NULL;
8369  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8370  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8371  }
8372  {
8373  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8374  if ( tmp3 == NULL )
8375  return NULL;
8376  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8377  {
8378  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8379  return NULL;
8380  }
8381  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8382  }
8383  {
8384  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
8385  if ( tmp4 == NULL )
8386  return NULL;
8387  if ( PyArray_DIMS( tmp4 )[0] != Alen )
8388  {
8389  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8390  return NULL;
8391  }
8392  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8393  }
8394  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8395  resultobj = SWIG_Py_Void();
8396  {
8397  Py_CLEAR( tmp1 );
8398  }
8399  {
8400  Py_CLEAR( tmp3 );
8401  }
8402  {
8403  Py_CLEAR( tmp4 );
8404  }
8405  return resultobj;
8406 fail:
8407  {
8408  Py_CLEAR( tmp1 );
8409  }
8410  {
8411  Py_CLEAR( tmp3 );
8412  }
8413  {
8414  Py_CLEAR( tmp4 );
8415  }
8416  return NULL;
8417 }
8418 
8419 
8420 SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8421  PyObject *resultobj = 0;
8422  PLINT arg1 ;
8423  int val1 ;
8424  int ecode1 = 0 ;
8425  PyObject *swig_obj[1] ;
8426 
8427  if (!args) SWIG_fail;
8428  swig_obj[0] = args;
8429  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
8430  if (!SWIG_IsOK(ecode1)) {
8431  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
8432  }
8433  arg1 = (PLINT)(val1);
8434  pllsty(arg1);
8435  resultobj = SWIG_Py_Void();
8436  return resultobj;
8437 fail:
8438  return NULL;
8439 }
8440 
8441 
8442 SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8443  PyObject *resultobj = 0;
8444  PLFLT *arg1 = (PLFLT *) 0 ;
8445  PLFLT *arg2 = (PLFLT *) 0 ;
8446  PLFLT **arg3 = (PLFLT **) 0 ;
8447  PLINT arg4 ;
8448  PLINT arg5 ;
8449  PLINT arg6 ;
8450  PyArrayObject *tmp1 = NULL ;
8451  PyArrayObject *tmp2 = NULL ;
8452  PyArrayObject *tmp3 = NULL ;
8453  int val6 ;
8454  int ecode6 = 0 ;
8455  PyObject *swig_obj[4] ;
8456 
8457  if (!SWIG_Python_UnpackTuple(args, "plmesh", 4, 4, swig_obj)) SWIG_fail;
8458  {
8459  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8460  if ( tmp1 == NULL )
8461  return NULL;
8462  Xlen = PyArray_DIMS( tmp1 )[0];
8463  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8464  }
8465  {
8466  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8467  if ( tmp2 == NULL )
8468  return NULL;
8469  Ylen = PyArray_DIMS( tmp2 )[0];
8470  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8471  }
8472  {
8473  int i, size;
8474  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8475  if ( tmp3 == NULL )
8476  return NULL;
8477  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8478  {
8479  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8480  return NULL;
8481  }
8482  arg4 = PyArray_DIMS( tmp3 )[0];
8483  arg5 = PyArray_DIMS( tmp3 )[1];
8484  size = arg5;
8485  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8486  for ( i = 0; i < arg4; i++ )
8487  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8488  }
8489  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8490  if (!SWIG_IsOK(ecode6)) {
8491  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
8492  }
8493  arg6 = (PLINT)(val6);
8494  plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
8495  resultobj = SWIG_Py_Void();
8496  {
8497  Py_CLEAR( tmp1 );
8498  }
8499  {
8500  Py_CLEAR( tmp2 );
8501  }
8502  {
8503  Py_CLEAR( tmp3 );
8504  free( arg3 );
8505  }
8506  return resultobj;
8507 fail:
8508  {
8509  Py_CLEAR( tmp1 );
8510  }
8511  {
8512  Py_CLEAR( tmp2 );
8513  }
8514  {
8515  Py_CLEAR( tmp3 );
8516  free( arg3 );
8517  }
8518  return NULL;
8519 }
8520 
8521 
8522 SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8523  PyObject *resultobj = 0;
8524  PLFLT *arg1 = (PLFLT *) 0 ;
8525  PLFLT *arg2 = (PLFLT *) 0 ;
8526  PLFLT **arg3 = (PLFLT **) 0 ;
8527  PLINT arg4 ;
8528  PLINT arg5 ;
8529  PLINT arg6 ;
8530  PLFLT *arg7 = (PLFLT *) 0 ;
8531  PLINT arg8 ;
8532  PyArrayObject *tmp1 = NULL ;
8533  PyArrayObject *tmp2 = NULL ;
8534  PyArrayObject *tmp3 = NULL ;
8535  int val6 ;
8536  int ecode6 = 0 ;
8537  PyArrayObject *tmp7 = NULL ;
8538  PyObject *swig_obj[5] ;
8539 
8540  if (!SWIG_Python_UnpackTuple(args, "plmeshc", 5, 5, swig_obj)) SWIG_fail;
8541  {
8542  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8543  if ( tmp1 == NULL )
8544  return NULL;
8545  Xlen = PyArray_DIMS( tmp1 )[0];
8546  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8547  }
8548  {
8549  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8550  if ( tmp2 == NULL )
8551  return NULL;
8552  Ylen = PyArray_DIMS( tmp2 )[0];
8553  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8554  }
8555  {
8556  int i, size;
8557  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8558  if ( tmp3 == NULL )
8559  return NULL;
8560  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8561  {
8562  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8563  return NULL;
8564  }
8565  arg4 = PyArray_DIMS( tmp3 )[0];
8566  arg5 = PyArray_DIMS( tmp3 )[1];
8567  size = arg5;
8568  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8569  for ( i = 0; i < arg4; i++ )
8570  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8571  }
8572  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8573  if (!SWIG_IsOK(ecode6)) {
8574  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
8575  }
8576  arg6 = (PLINT)(val6);
8577  {
8578  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
8579  if ( tmp7 == NULL )
8580  return NULL;
8581  arg8 = PyArray_DIMS( tmp7 )[0];
8582  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8583  }
8584  plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
8585  resultobj = SWIG_Py_Void();
8586  {
8587  Py_CLEAR( tmp1 );
8588  }
8589  {
8590  Py_CLEAR( tmp2 );
8591  }
8592  {
8593  Py_CLEAR( tmp3 );
8594  free( arg3 );
8595  }
8596  {
8597  Py_CLEAR( tmp7 );
8598  }
8599  return resultobj;
8600 fail:
8601  {
8602  Py_CLEAR( tmp1 );
8603  }
8604  {
8605  Py_CLEAR( tmp2 );
8606  }
8607  {
8608  Py_CLEAR( tmp3 );
8609  free( arg3 );
8610  }
8611  {
8612  Py_CLEAR( tmp7 );
8613  }
8614  return NULL;
8615 }
8616 
8617 
8618 SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8619  PyObject *resultobj = 0;
8620  PLINT *arg1 = (PLINT *) 0 ;
8621  PLINT temp1 ;
8622  int res1 = SWIG_TMPOBJ ;
8623 
8624  arg1 = &temp1;
8625  if (!SWIG_Python_UnpackTuple(args, "plmkstrm", 0, 0, 0)) SWIG_fail;
8626  plmkstrm(arg1);
8627  resultobj = SWIG_Py_Void();
8628  if (SWIG_IsTmpObj(res1)) {
8629  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
8630  } else {
8631  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8632  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8633  }
8634  return resultobj;
8635 fail:
8636  return NULL;
8637 }
8638 
8639 
8640 SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8641  PyObject *resultobj = 0;
8642  char *arg1 = (char *) 0 ;
8643  PLFLT arg2 ;
8644  PLFLT arg3 ;
8645  PLFLT arg4 ;
8646  char *arg5 = (char *) 0 ;
8647  int res1 ;
8648  char *buf1 = 0 ;
8649  int alloc1 = 0 ;
8650  double val2 ;
8651  int ecode2 = 0 ;
8652  double val3 ;
8653  int ecode3 = 0 ;
8654  double val4 ;
8655  int ecode4 = 0 ;
8656  int res5 ;
8657  char *buf5 = 0 ;
8658  int alloc5 = 0 ;
8659  PyObject *swig_obj[5] ;
8660 
8661  if (!SWIG_Python_UnpackTuple(args, "plmtex", 5, 5, swig_obj)) SWIG_fail;
8662  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8663  if (!SWIG_IsOK(res1)) {
8664  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
8665  }
8666  arg1 = (char *)(buf1);
8667  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8668  if (!SWIG_IsOK(ecode2)) {
8669  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
8670  }
8671  arg2 = (PLFLT)(val2);
8672  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8673  if (!SWIG_IsOK(ecode3)) {
8674  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
8675  }
8676  arg3 = (PLFLT)(val3);
8677  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8678  if (!SWIG_IsOK(ecode4)) {
8679  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
8680  }
8681  arg4 = (PLFLT)(val4);
8682  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
8683  if (!SWIG_IsOK(res5)) {
8684  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
8685  }
8686  arg5 = (char *)(buf5);
8687  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
8688  resultobj = SWIG_Py_Void();
8689  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8690  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8691  return resultobj;
8692 fail:
8693  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8694  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8695  return NULL;
8696 }
8697 
8698 
8699 SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8700  PyObject *resultobj = 0;
8701  char *arg1 = (char *) 0 ;
8702  PLFLT arg2 ;
8703  PLFLT arg3 ;
8704  PLFLT arg4 ;
8705  char *arg5 = (char *) 0 ;
8706  int res1 ;
8707  char *buf1 = 0 ;
8708  int alloc1 = 0 ;
8709  double val2 ;
8710  int ecode2 = 0 ;
8711  double val3 ;
8712  int ecode3 = 0 ;
8713  double val4 ;
8714  int ecode4 = 0 ;
8715  int res5 ;
8716  char *buf5 = 0 ;
8717  int alloc5 = 0 ;
8718  PyObject *swig_obj[5] ;
8719 
8720  if (!SWIG_Python_UnpackTuple(args, "plmtex3", 5, 5, swig_obj)) SWIG_fail;
8721  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8722  if (!SWIG_IsOK(res1)) {
8723  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
8724  }
8725  arg1 = (char *)(buf1);
8726  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8727  if (!SWIG_IsOK(ecode2)) {
8728  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
8729  }
8730  arg2 = (PLFLT)(val2);
8731  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8732  if (!SWIG_IsOK(ecode3)) {
8733  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
8734  }
8735  arg3 = (PLFLT)(val3);
8736  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8737  if (!SWIG_IsOK(ecode4)) {
8738  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
8739  }
8740  arg4 = (PLFLT)(val4);
8741  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
8742  if (!SWIG_IsOK(res5)) {
8743  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
8744  }
8745  arg5 = (char *)(buf5);
8746  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
8747  resultobj = SWIG_Py_Void();
8748  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8749  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8750  return resultobj;
8751 fail:
8752  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8753  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8754  return NULL;
8755 }
8756 
8757 
8758 SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8759  PyObject *resultobj = 0;
8760  PLFLT *arg1 = (PLFLT *) 0 ;
8761  PLFLT *arg2 = (PLFLT *) 0 ;
8762  PLFLT **arg3 = (PLFLT **) 0 ;
8763  PLINT arg4 ;
8764  PLINT arg5 ;
8765  PLINT arg6 ;
8766  PLBOOL arg7 ;
8767  PyArrayObject *tmp1 = NULL ;
8768  PyArrayObject *tmp2 = NULL ;
8769  PyArrayObject *tmp3 = NULL ;
8770  int val6 ;
8771  int ecode6 = 0 ;
8772  int val7 ;
8773  int ecode7 = 0 ;
8774  PyObject *swig_obj[5] ;
8775 
8776  if (!SWIG_Python_UnpackTuple(args, "plot3d", 5, 5, swig_obj)) SWIG_fail;
8777  {
8778  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8779  if ( tmp1 == NULL )
8780  return NULL;
8781  Xlen = PyArray_DIMS( tmp1 )[0];
8782  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8783  }
8784  {
8785  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8786  if ( tmp2 == NULL )
8787  return NULL;
8788  Ylen = PyArray_DIMS( tmp2 )[0];
8789  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8790  }
8791  {
8792  int i, size;
8793  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8794  if ( tmp3 == NULL )
8795  return NULL;
8796  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8797  {
8798  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8799  return NULL;
8800  }
8801  arg4 = PyArray_DIMS( tmp3 )[0];
8802  arg5 = PyArray_DIMS( tmp3 )[1];
8803  size = arg5;
8804  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8805  for ( i = 0; i < arg4; i++ )
8806  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8807  }
8808  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8809  if (!SWIG_IsOK(ecode6)) {
8810  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
8811  }
8812  arg6 = (PLINT)(val6);
8813  ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
8814  if (!SWIG_IsOK(ecode7)) {
8815  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
8816  }
8817  arg7 = (PLBOOL)(val7);
8818  plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
8819  resultobj = SWIG_Py_Void();
8820  {
8821  Py_CLEAR( tmp1 );
8822  }
8823  {
8824  Py_CLEAR( tmp2 );
8825  }
8826  {
8827  Py_CLEAR( tmp3 );
8828  free( arg3 );
8829  }
8830  return resultobj;
8831 fail:
8832  {
8833  Py_CLEAR( tmp1 );
8834  }
8835  {
8836  Py_CLEAR( tmp2 );
8837  }
8838  {
8839  Py_CLEAR( tmp3 );
8840  free( arg3 );
8841  }
8842  return NULL;
8843 }
8844 
8845 
8846 SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8847  PyObject *resultobj = 0;
8848  PLFLT *arg1 = (PLFLT *) 0 ;
8849  PLFLT *arg2 = (PLFLT *) 0 ;
8850  PLFLT **arg3 = (PLFLT **) 0 ;
8851  PLINT arg4 ;
8852  PLINT arg5 ;
8853  PLINT arg6 ;
8854  PLFLT *arg7 = (PLFLT *) 0 ;
8855  PLINT arg8 ;
8856  PyArrayObject *tmp1 = NULL ;
8857  PyArrayObject *tmp2 = NULL ;
8858  PyArrayObject *tmp3 = NULL ;
8859  int val6 ;
8860  int ecode6 = 0 ;
8861  PyArrayObject *tmp7 = NULL ;
8862  PyObject *swig_obj[5] ;
8863 
8864  if (!SWIG_Python_UnpackTuple(args, "plot3dc", 5, 5, swig_obj)) SWIG_fail;
8865  {
8866  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8867  if ( tmp1 == NULL )
8868  return NULL;
8869  Xlen = PyArray_DIMS( tmp1 )[0];
8870  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8871  }
8872  {
8873  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8874  if ( tmp2 == NULL )
8875  return NULL;
8876  Ylen = PyArray_DIMS( tmp2 )[0];
8877  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8878  }
8879  {
8880  int i, size;
8881  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8882  if ( tmp3 == NULL )
8883  return NULL;
8884  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8885  {
8886  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8887  return NULL;
8888  }
8889  arg4 = PyArray_DIMS( tmp3 )[0];
8890  arg5 = PyArray_DIMS( tmp3 )[1];
8891  size = arg5;
8892  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8893  for ( i = 0; i < arg4; i++ )
8894  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8895  }
8896  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8897  if (!SWIG_IsOK(ecode6)) {
8898  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
8899  }
8900  arg6 = (PLINT)(val6);
8901  {
8902  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
8903  if ( tmp7 == NULL )
8904  return NULL;
8905  arg8 = PyArray_DIMS( tmp7 )[0];
8906  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8907  }
8908  plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
8909  resultobj = SWIG_Py_Void();
8910  {
8911  Py_CLEAR( tmp1 );
8912  }
8913  {
8914  Py_CLEAR( tmp2 );
8915  }
8916  {
8917  Py_CLEAR( tmp3 );
8918  free( arg3 );
8919  }
8920  {
8921  Py_CLEAR( tmp7 );
8922  }
8923  return resultobj;
8924 fail:
8925  {
8926  Py_CLEAR( tmp1 );
8927  }
8928  {
8929  Py_CLEAR( tmp2 );
8930  }
8931  {
8932  Py_CLEAR( tmp3 );
8933  free( arg3 );
8934  }
8935  {
8936  Py_CLEAR( tmp7 );
8937  }
8938  return NULL;
8939 }
8940 
8941 
8942 SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8943  PyObject *resultobj = 0;
8944  PLFLT *arg1 = (PLFLT *) 0 ;
8945  PLFLT *arg2 = (PLFLT *) 0 ;
8946  PLFLT **arg3 = (PLFLT **) 0 ;
8947  PLINT arg4 ;
8948  PLINT arg5 ;
8949  PLINT arg6 ;
8950  PLFLT *arg7 = (PLFLT *) 0 ;
8951  PLINT arg8 ;
8952  PLINT arg9 ;
8953  PLINT arg10 ;
8954  PLINT *arg11 = (PLINT *) 0 ;
8955  PLINT *arg12 = (PLINT *) 0 ;
8956  PyArrayObject *tmp1 = NULL ;
8957  PyArrayObject *tmp2 = NULL ;
8958  PyArrayObject *tmp3 = NULL ;
8959  int val6 ;
8960  int ecode6 = 0 ;
8961  PyArrayObject *tmp7 = NULL ;
8962  int val9 ;
8963  int ecode9 = 0 ;
8964  PyArrayObject *tmp10 = NULL ;
8965  PyArrayObject *tmp12 = NULL ;
8966  PyObject *swig_obj[8] ;
8967 
8968  if (!SWIG_Python_UnpackTuple(args, "plot3dcl", 8, 8, swig_obj)) SWIG_fail;
8969  {
8970  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8971  if ( tmp1 == NULL )
8972  return NULL;
8973  Xlen = PyArray_DIMS( tmp1 )[0];
8974  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8975  }
8976  {
8977  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8978  if ( tmp2 == NULL )
8979  return NULL;
8980  Ylen = PyArray_DIMS( tmp2 )[0];
8981  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8982  }
8983  {
8984  int i, size;
8985  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8986  if ( tmp3 == NULL )
8987  return NULL;
8988  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8989  {
8990  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8991  return NULL;
8992  }
8993  arg4 = PyArray_DIMS( tmp3 )[0];
8994  arg5 = PyArray_DIMS( tmp3 )[1];
8995  size = arg5;
8996  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8997  for ( i = 0; i < arg4; i++ )
8998  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8999  }
9000  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9001  if (!SWIG_IsOK(ecode6)) {
9002  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9003  }
9004  arg6 = (PLINT)(val6);
9005  {
9006  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9007  if ( tmp7 == NULL )
9008  return NULL;
9009  arg8 = PyArray_DIMS( tmp7 )[0];
9010  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9011  }
9012  ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9013  if (!SWIG_IsOK(ecode9)) {
9014  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9015  }
9016  arg9 = (PLINT)(val9);
9017  {
9018  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9019  if ( tmp10 == NULL )
9020  return NULL;
9021  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9022  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9023  }
9024  {
9025  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9026  if ( tmp12 == NULL )
9027  return NULL;
9028  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9029  {
9030  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9031  return NULL;
9032  }
9033  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9034  }
9035  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);
9036  resultobj = SWIG_Py_Void();
9037  {
9038  Py_CLEAR( tmp1 );
9039  }
9040  {
9041  Py_CLEAR( tmp2 );
9042  }
9043  {
9044  Py_CLEAR( tmp3 );
9045  free( arg3 );
9046  }
9047  {
9048  Py_CLEAR( tmp7 );
9049  }
9050  {
9051  Py_CLEAR( tmp10 );
9052  }
9053  {
9054  Py_CLEAR( tmp12 );
9055  }
9056  return resultobj;
9057 fail:
9058  {
9059  Py_CLEAR( tmp1 );
9060  }
9061  {
9062  Py_CLEAR( tmp2 );
9063  }
9064  {
9065  Py_CLEAR( tmp3 );
9066  free( arg3 );
9067  }
9068  {
9069  Py_CLEAR( tmp7 );
9070  }
9071  {
9072  Py_CLEAR( tmp10 );
9073  }
9074  {
9075  Py_CLEAR( tmp12 );
9076  }
9077  return NULL;
9078 }
9079 
9080 
9081 SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9082  PyObject *resultobj = 0;
9083  PLFLT *arg1 = (PLFLT *) 0 ;
9084  PLFLT *arg2 = (PLFLT *) 0 ;
9085  PLFLT **arg3 = (PLFLT **) 0 ;
9086  PLINT arg4 ;
9087  PLINT arg5 ;
9088  PLINT arg6 ;
9089  PLFLT *arg7 = (PLFLT *) 0 ;
9090  PLINT arg8 ;
9091  PyArrayObject *tmp1 = NULL ;
9092  PyArrayObject *tmp2 = NULL ;
9093  PyArrayObject *tmp3 = NULL ;
9094  int val6 ;
9095  int ecode6 = 0 ;
9096  PyArrayObject *tmp7 = NULL ;
9097  PyObject *swig_obj[5] ;
9098 
9099  if (!SWIG_Python_UnpackTuple(args, "plsurf3d", 5, 5, swig_obj)) SWIG_fail;
9100  {
9101  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9102  if ( tmp1 == NULL )
9103  return NULL;
9104  Xlen = PyArray_DIMS( tmp1 )[0];
9105  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9106  }
9107  {
9108  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9109  if ( tmp2 == NULL )
9110  return NULL;
9111  Ylen = PyArray_DIMS( tmp2 )[0];
9112  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9113  }
9114  {
9115  int i, size;
9116  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9117  if ( tmp3 == NULL )
9118  return NULL;
9119  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9120  {
9121  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9122  return NULL;
9123  }
9124  arg4 = PyArray_DIMS( tmp3 )[0];
9125  arg5 = PyArray_DIMS( tmp3 )[1];
9126  size = arg5;
9127  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9128  for ( i = 0; i < arg4; i++ )
9129  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9130  }
9131  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9132  if (!SWIG_IsOK(ecode6)) {
9133  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9134  }
9135  arg6 = (PLINT)(val6);
9136  {
9137  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9138  if ( tmp7 == NULL )
9139  return NULL;
9140  arg8 = PyArray_DIMS( tmp7 )[0];
9141  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9142  }
9143  plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9144  resultobj = SWIG_Py_Void();
9145  {
9146  Py_CLEAR( tmp1 );
9147  }
9148  {
9149  Py_CLEAR( tmp2 );
9150  }
9151  {
9152  Py_CLEAR( tmp3 );
9153  free( arg3 );
9154  }
9155  {
9156  Py_CLEAR( tmp7 );
9157  }
9158  return resultobj;
9159 fail:
9160  {
9161  Py_CLEAR( tmp1 );
9162  }
9163  {
9164  Py_CLEAR( tmp2 );
9165  }
9166  {
9167  Py_CLEAR( tmp3 );
9168  free( arg3 );
9169  }
9170  {
9171  Py_CLEAR( tmp7 );
9172  }
9173  return NULL;
9174 }
9175 
9176 
9177 SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9178  PyObject *resultobj = 0;
9179  PLFLT *arg1 = (PLFLT *) 0 ;
9180  PLFLT *arg2 = (PLFLT *) 0 ;
9181  PLFLT **arg3 = (PLFLT **) 0 ;
9182  PLINT arg4 ;
9183  PLINT arg5 ;
9184  PLINT arg6 ;
9185  PLFLT *arg7 = (PLFLT *) 0 ;
9186  PLINT arg8 ;
9187  PLINT arg9 ;
9188  PLINT arg10 ;
9189  PLINT *arg11 = (PLINT *) 0 ;
9190  PLINT *arg12 = (PLINT *) 0 ;
9191  PyArrayObject *tmp1 = NULL ;
9192  PyArrayObject *tmp2 = NULL ;
9193  PyArrayObject *tmp3 = NULL ;
9194  int val6 ;
9195  int ecode6 = 0 ;
9196  PyArrayObject *tmp7 = NULL ;
9197  int val9 ;
9198  int ecode9 = 0 ;
9199  PyArrayObject *tmp10 = NULL ;
9200  PyArrayObject *tmp12 = NULL ;
9201  PyObject *swig_obj[8] ;
9202 
9203  if (!SWIG_Python_UnpackTuple(args, "plsurf3dl", 8, 8, swig_obj)) SWIG_fail;
9204  {
9205  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9206  if ( tmp1 == NULL )
9207  return NULL;
9208  Xlen = PyArray_DIMS( tmp1 )[0];
9209  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9210  }
9211  {
9212  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9213  if ( tmp2 == NULL )
9214  return NULL;
9215  Ylen = PyArray_DIMS( tmp2 )[0];
9216  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9217  }
9218  {
9219  int i, size;
9220  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9221  if ( tmp3 == NULL )
9222  return NULL;
9223  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9224  {
9225  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9226  return NULL;
9227  }
9228  arg4 = PyArray_DIMS( tmp3 )[0];
9229  arg5 = PyArray_DIMS( tmp3 )[1];
9230  size = arg5;
9231  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9232  for ( i = 0; i < arg4; i++ )
9233  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9234  }
9235  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9236  if (!SWIG_IsOK(ecode6)) {
9237  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9238  }
9239  arg6 = (PLINT)(val6);
9240  {
9241  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9242  if ( tmp7 == NULL )
9243  return NULL;
9244  arg8 = PyArray_DIMS( tmp7 )[0];
9245  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9246  }
9247  ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9248  if (!SWIG_IsOK(ecode9)) {
9249  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9250  }
9251  arg9 = (PLINT)(val9);
9252  {
9253  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9254  if ( tmp10 == NULL )
9255  return NULL;
9256  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9257  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9258  }
9259  {
9260  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9261  if ( tmp12 == NULL )
9262  return NULL;
9263  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9264  {
9265  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9266  return NULL;
9267  }
9268  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9269  }
9270  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);
9271  resultobj = SWIG_Py_Void();
9272  {
9273  Py_CLEAR( tmp1 );
9274  }
9275  {
9276  Py_CLEAR( tmp2 );
9277  }
9278  {
9279  Py_CLEAR( tmp3 );
9280  free( arg3 );
9281  }
9282  {
9283  Py_CLEAR( tmp7 );
9284  }
9285  {
9286  Py_CLEAR( tmp10 );
9287  }
9288  {
9289  Py_CLEAR( tmp12 );
9290  }
9291  return resultobj;
9292 fail:
9293  {
9294  Py_CLEAR( tmp1 );
9295  }
9296  {
9297  Py_CLEAR( tmp2 );
9298  }
9299  {
9300  Py_CLEAR( tmp3 );
9301  free( arg3 );
9302  }
9303  {
9304  Py_CLEAR( tmp7 );
9305  }
9306  {
9307  Py_CLEAR( tmp10 );
9308  }
9309  {
9310  Py_CLEAR( tmp12 );
9311  }
9312  return NULL;
9313 }
9314 
9315 
9316 SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9317  PyObject *resultobj = 0;
9318  int *arg1 = (int *) 0 ;
9319  char **arg2 = (char **) 0 ;
9320  PLINT arg3 ;
9321  int tmp1 ;
9322  int val3 ;
9323  int ecode3 = 0 ;
9324  PyObject *swig_obj[2] ;
9325  PLINT result;
9326 
9327  if (!SWIG_Python_UnpackTuple(args, "plparseopts", 2, 2, swig_obj)) SWIG_fail;
9328  {
9329  int i;
9330  PyObject *unicode_string;
9331 
9332  if ( !PyList_Check( swig_obj[0] ) )
9333  {
9334  PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9335  return NULL;
9336  }
9337  tmp1 = PyList_Size( swig_obj[0] );
9338  arg1 = &tmp1;
9339  arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9340  for ( i = 0; i < tmp1; i++ )
9341  {
9342  PyObject *s = PyList_GetItem( swig_obj[0], i );
9343  if ( PyString_Check( s ) )
9344  {
9345  arg2[i] = PyString_AsString( s );
9346  }
9347  else if ( PyUnicode_Check( s ) )
9348  {
9349  // unicode_string is never freed? memory leak here?
9350  unicode_string = PyUnicode_AsEncodedString( s, "utf-8", "Error ~" );
9351  arg2[i] = PyBytes_AS_STRING( unicode_string );
9352  }
9353  else
9354  {
9355  free( arg2 );
9356  PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9357  return NULL;
9358  }
9359  }
9360  arg2[i] = 0;
9361  }
9362  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
9363  if (!SWIG_IsOK(ecode3)) {
9364  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9365  }
9366  arg3 = (PLINT)(val3);
9367  result = (PLINT)plparseopts(arg1,arg2,arg3);
9368  resultobj = SWIG_From_int((int)(result));
9369  {
9370  if ( arg2 )
9371  free( arg2 );
9372  }
9373  return resultobj;
9374 fail:
9375  {
9376  if ( arg2 )
9377  free( arg2 );
9378  }
9379  return NULL;
9380 }
9381 
9382 
9383 SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9384  PyObject *resultobj = 0;
9385  PLINT arg1 ;
9386  PLINT *arg2 = (PLINT *) 0 ;
9387  PLINT *arg3 = (PLINT *) 0 ;
9388  PyArrayObject *tmp1 = NULL ;
9389  PyArrayObject *tmp3 = NULL ;
9390  PyObject *swig_obj[2] ;
9391 
9392  if (!SWIG_Python_UnpackTuple(args, "plpat", 2, 2, swig_obj)) SWIG_fail;
9393  {
9394  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
9395  if ( tmp1 == NULL )
9396  return NULL;
9397  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9398  arg2 = (PLINT *) PyArray_DATA( tmp1 );
9399  }
9400  {
9401  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
9402  if ( tmp3 == NULL )
9403  return NULL;
9404  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9405  {
9406  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9407  return NULL;
9408  }
9409  arg3 = (PLINT *) PyArray_DATA( tmp3 );
9410  }
9411  plpat(arg1,(int const *)arg2,(int const *)arg3);
9412  resultobj = SWIG_Py_Void();
9413  {
9414  Py_CLEAR( tmp1 );
9415  }
9416  {
9417  Py_CLEAR( tmp3 );
9418  }
9419  return resultobj;
9420 fail:
9421  {
9422  Py_CLEAR( tmp1 );
9423  }
9424  {
9425  Py_CLEAR( tmp3 );
9426  }
9427  return NULL;
9428 }
9429 
9430 
9431 SWIGINTERN PyObject *_wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9432  PyObject *resultobj = 0;
9433  PLINT arg1 ;
9434  PLFLT arg2 ;
9435  PLFLT arg3 ;
9436  PLFLT arg4 ;
9437  PLFLT arg5 ;
9438  int val1 ;
9439  int ecode1 = 0 ;
9440  double val2 ;
9441  int ecode2 = 0 ;
9442  double val3 ;
9443  int ecode3 = 0 ;
9444  double val4 ;
9445  int ecode4 = 0 ;
9446  double val5 ;
9447  int ecode5 = 0 ;
9448  PyObject *swig_obj[5] ;
9449 
9450  if (!SWIG_Python_UnpackTuple(args, "plpath", 5, 5, swig_obj)) SWIG_fail;
9451  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9452  if (!SWIG_IsOK(ecode1)) {
9453  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
9454  }
9455  arg1 = (PLINT)(val1);
9456  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9457  if (!SWIG_IsOK(ecode2)) {
9458  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
9459  }
9460  arg2 = (PLFLT)(val2);
9461  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9462  if (!SWIG_IsOK(ecode3)) {
9463  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
9464  }
9465  arg3 = (PLFLT)(val3);
9466  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9467  if (!SWIG_IsOK(ecode4)) {
9468  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
9469  }
9470  arg4 = (PLFLT)(val4);
9471  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
9472  if (!SWIG_IsOK(ecode5)) {
9473  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
9474  }
9475  arg5 = (PLFLT)(val5);
9476  plpath(arg1,arg2,arg3,arg4,arg5);
9477  resultobj = SWIG_Py_Void();
9478  return resultobj;
9479 fail:
9480  return NULL;
9481 }
9482 
9483 
9484 SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9485  PyObject *resultobj = 0;
9486  PLINT arg1 ;
9487  PLFLT *arg2 = (PLFLT *) 0 ;
9488  PLFLT *arg3 = (PLFLT *) 0 ;
9489  PLINT arg4 ;
9490  PyArrayObject *tmp1 = NULL ;
9491  PyArrayObject *tmp3 = NULL ;
9492  int val4 ;
9493  int ecode4 = 0 ;
9494  PyObject *swig_obj[3] ;
9495 
9496  if (!SWIG_Python_UnpackTuple(args, "plpoin", 3, 3, swig_obj)) SWIG_fail;
9497  {
9498  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9499  if ( tmp1 == NULL )
9500  return NULL;
9501  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9502  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9503  }
9504  {
9505  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9506  if ( tmp3 == NULL )
9507  return NULL;
9508  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9509  {
9510  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9511  return NULL;
9512  }
9513  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9514  }
9515  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
9516  if (!SWIG_IsOK(ecode4)) {
9517  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
9518  }
9519  arg4 = (PLINT)(val4);
9520  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
9521  resultobj = SWIG_Py_Void();
9522  {
9523  Py_CLEAR( tmp1 );
9524  }
9525  {
9526  Py_CLEAR( tmp3 );
9527  }
9528  return resultobj;
9529 fail:
9530  {
9531  Py_CLEAR( tmp1 );
9532  }
9533  {
9534  Py_CLEAR( tmp3 );
9535  }
9536  return NULL;
9537 }
9538 
9539 
9540 SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9541  PyObject *resultobj = 0;
9542  PLINT arg1 ;
9543  PLFLT *arg2 = (PLFLT *) 0 ;
9544  PLFLT *arg3 = (PLFLT *) 0 ;
9545  PLFLT *arg4 = (PLFLT *) 0 ;
9546  PLINT arg5 ;
9547  PyArrayObject *tmp1 = NULL ;
9548  PyArrayObject *tmp3 = NULL ;
9549  PyArrayObject *tmp4 = NULL ;
9550  int val5 ;
9551  int ecode5 = 0 ;
9552  PyObject *swig_obj[4] ;
9553 
9554  if (!SWIG_Python_UnpackTuple(args, "plpoin3", 4, 4, swig_obj)) SWIG_fail;
9555  {
9556  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9557  if ( tmp1 == NULL )
9558  return NULL;
9559  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9560  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9561  }
9562  {
9563  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9564  if ( tmp3 == NULL )
9565  return NULL;
9566  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9567  {
9568  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9569  return NULL;
9570  }
9571  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9572  }
9573  {
9574  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
9575  if ( tmp4 == NULL )
9576  return NULL;
9577  if ( PyArray_DIMS( tmp4 )[0] != Alen )
9578  {
9579  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9580  return NULL;
9581  }
9582  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9583  }
9584  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
9585  if (!SWIG_IsOK(ecode5)) {
9586  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
9587  }
9588  arg5 = (PLINT)(val5);
9589  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
9590  resultobj = SWIG_Py_Void();
9591  {
9592  Py_CLEAR( tmp1 );
9593  }
9594  {
9595  Py_CLEAR( tmp3 );
9596  }
9597  {
9598  Py_CLEAR( tmp4 );
9599  }
9600  return resultobj;
9601 fail:
9602  {
9603  Py_CLEAR( tmp1 );
9604  }
9605  {
9606  Py_CLEAR( tmp3 );
9607  }
9608  {
9609  Py_CLEAR( tmp4 );
9610  }
9611  return NULL;
9612 }
9613 
9614 
9615 SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9616  PyObject *resultobj = 0;
9617  PLINT arg1 ;
9618  PLFLT *arg2 = (PLFLT *) 0 ;
9619  PLFLT *arg3 = (PLFLT *) 0 ;
9620  PLFLT *arg4 = (PLFLT *) 0 ;
9621  PLBOOL *arg5 = (PLBOOL *) 0 ;
9622  PLBOOL arg6 ;
9623  PyArrayObject *tmp1 = NULL ;
9624  PyArrayObject *tmp3 = NULL ;
9625  PyArrayObject *tmp4 = NULL ;
9626  PyArrayObject *tmp5 = NULL ;
9627  int val6 ;
9628  int ecode6 = 0 ;
9629  PyObject *swig_obj[5] ;
9630 
9631  if (!SWIG_Python_UnpackTuple(args, "plpoly3", 5, 5, swig_obj)) SWIG_fail;
9632  {
9633  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9634  if ( tmp1 == NULL )
9635  return NULL;
9636  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9637  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9638  }
9639  {
9640  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9641  if ( tmp3 == NULL )
9642  return NULL;
9643  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9644  {
9645  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9646  return NULL;
9647  }
9648  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9649  }
9650  {
9651  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
9652  if ( tmp4 == NULL )
9653  return NULL;
9654  if ( PyArray_DIMS( tmp4 )[0] != Alen )
9655  {
9656  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9657  return NULL;
9658  }
9659  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9660  }
9661  {
9662  tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[3], NPY_PLINT, 1, 1 );
9663  if ( tmp5 == NULL )
9664  return NULL;
9665  if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
9666  {
9667  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
9668  return NULL;
9669  }
9670  arg5 = (PLINT *) PyArray_DATA( tmp5 );
9671  }
9672  ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
9673  if (!SWIG_IsOK(ecode6)) {
9674  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
9675  }
9676  arg6 = (PLBOOL)(val6);
9677  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
9678  resultobj = SWIG_Py_Void();
9679  {
9680  Py_CLEAR( tmp1 );
9681  }
9682  {
9683  Py_CLEAR( tmp3 );
9684  }
9685  {
9686  Py_CLEAR( tmp4 );
9687  }
9688  {
9689  Py_CLEAR( tmp5 );
9690  }
9691  return resultobj;
9692 fail:
9693  {
9694  Py_CLEAR( tmp1 );
9695  }
9696  {
9697  Py_CLEAR( tmp3 );
9698  }
9699  {
9700  Py_CLEAR( tmp4 );
9701  }
9702  {
9703  Py_CLEAR( tmp5 );
9704  }
9705  return NULL;
9706 }
9707 
9708 
9709 SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9710  PyObject *resultobj = 0;
9711  PLINT arg1 ;
9712  PLINT arg2 ;
9713  int val1 ;
9714  int ecode1 = 0 ;
9715  int val2 ;
9716  int ecode2 = 0 ;
9717  PyObject *swig_obj[2] ;
9718 
9719  if (!SWIG_Python_UnpackTuple(args, "plprec", 2, 2, swig_obj)) SWIG_fail;
9720  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9721  if (!SWIG_IsOK(ecode1)) {
9722  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
9723  }
9724  arg1 = (PLINT)(val1);
9725  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
9726  if (!SWIG_IsOK(ecode2)) {
9727  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
9728  }
9729  arg2 = (PLINT)(val2);
9730  plprec(arg1,arg2);
9731  resultobj = SWIG_Py_Void();
9732  return resultobj;
9733 fail:
9734  return NULL;
9735 }
9736 
9737 
9738 SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9739  PyObject *resultobj = 0;
9740  PLINT arg1 ;
9741  int val1 ;
9742  int ecode1 = 0 ;
9743  PyObject *swig_obj[1] ;
9744 
9745  if (!args) SWIG_fail;
9746  swig_obj[0] = args;
9747  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9748  if (!SWIG_IsOK(ecode1)) {
9749  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
9750  }
9751  arg1 = (PLINT)(val1);
9752  plpsty(arg1);
9753  resultobj = SWIG_Py_Void();
9754  return resultobj;
9755 fail:
9756  return NULL;
9757 }
9758 
9759 
9760 SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9761  PyObject *resultobj = 0;
9762  PLFLT arg1 ;
9763  PLFLT arg2 ;
9764  PLFLT arg3 ;
9765  PLFLT arg4 ;
9766  PLFLT arg5 ;
9767  char *arg6 = (char *) 0 ;
9768  double val1 ;
9769  int ecode1 = 0 ;
9770  double val2 ;
9771  int ecode2 = 0 ;
9772  double val3 ;
9773  int ecode3 = 0 ;
9774  double val4 ;
9775  int ecode4 = 0 ;
9776  double val5 ;
9777  int ecode5 = 0 ;
9778  int res6 ;
9779  char *buf6 = 0 ;
9780  int alloc6 = 0 ;
9781  PyObject *swig_obj[6] ;
9782 
9783  if (!SWIG_Python_UnpackTuple(args, "plptex", 6, 6, swig_obj)) SWIG_fail;
9784  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
9785  if (!SWIG_IsOK(ecode1)) {
9786  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
9787  }
9788  arg1 = (PLFLT)(val1);
9789  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9790  if (!SWIG_IsOK(ecode2)) {
9791  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
9792  }
9793  arg2 = (PLFLT)(val2);
9794  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9795  if (!SWIG_IsOK(ecode3)) {
9796  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
9797  }
9798  arg3 = (PLFLT)(val3);
9799  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9800  if (!SWIG_IsOK(ecode4)) {
9801  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
9802  }
9803  arg4 = (PLFLT)(val4);
9804  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
9805  if (!SWIG_IsOK(ecode5)) {
9806  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
9807  }
9808  arg5 = (PLFLT)(val5);
9809  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
9810  if (!SWIG_IsOK(res6)) {
9811  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
9812  }
9813  arg6 = (char *)(buf6);
9814  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
9815  resultobj = SWIG_Py_Void();
9816  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
9817  return resultobj;
9818 fail:
9819  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
9820  return NULL;
9821 }
9822 
9823 
9824 SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9825  PyObject *resultobj = 0;
9826  PLFLT arg1 ;
9827  PLFLT arg2 ;
9828  PLFLT arg3 ;
9829  PLFLT arg4 ;
9830  PLFLT arg5 ;
9831  PLFLT arg6 ;
9832  PLFLT arg7 ;
9833  PLFLT arg8 ;
9834  PLFLT arg9 ;
9835  PLFLT arg10 ;
9836  char *arg11 = (char *) 0 ;
9837  double val1 ;
9838  int ecode1 = 0 ;
9839  double val2 ;
9840  int ecode2 = 0 ;
9841  double val3 ;
9842  int ecode3 = 0 ;
9843  double val4 ;
9844  int ecode4 = 0 ;
9845  double val5 ;
9846  int ecode5 = 0 ;
9847  double val6 ;
9848  int ecode6 = 0 ;
9849  double val7 ;
9850  int ecode7 = 0 ;
9851  double val8 ;
9852  int ecode8 = 0 ;
9853  double val9 ;
9854  int ecode9 = 0 ;
9855  double val10 ;
9856  int ecode10 = 0 ;
9857  int res11 ;
9858  char *buf11 = 0 ;
9859  int alloc11 = 0 ;
9860  PyObject *swig_obj[11] ;
9861 
9862  if (!SWIG_Python_UnpackTuple(args, "plptex3", 11, 11, swig_obj)) SWIG_fail;
9863  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
9864  if (!SWIG_IsOK(ecode1)) {
9865  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
9866  }
9867  arg1 = (PLFLT)(val1);
9868  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9869  if (!SWIG_IsOK(ecode2)) {
9870  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
9871  }
9872  arg2 = (PLFLT)(val2);
9873  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9874  if (!SWIG_IsOK(ecode3)) {
9875  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
9876  }
9877  arg3 = (PLFLT)(val3);
9878  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9879  if (!SWIG_IsOK(ecode4)) {
9880  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
9881  }
9882  arg4 = (PLFLT)(val4);
9883  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
9884  if (!SWIG_IsOK(ecode5)) {
9885  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
9886  }
9887  arg5 = (PLFLT)(val5);
9888  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
9889  if (!SWIG_IsOK(ecode6)) {
9890  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
9891  }
9892  arg6 = (PLFLT)(val6);
9893  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
9894  if (!SWIG_IsOK(ecode7)) {
9895  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
9896  }
9897  arg7 = (PLFLT)(val7);
9898  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
9899  if (!SWIG_IsOK(ecode8)) {
9900  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
9901  }
9902  arg8 = (PLFLT)(val8);
9903  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
9904  if (!SWIG_IsOK(ecode9)) {
9905  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
9906  }
9907  arg9 = (PLFLT)(val9);
9908  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
9909  if (!SWIG_IsOK(ecode10)) {
9910  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
9911  }
9912  arg10 = (PLFLT)(val10);
9913  res11 = SWIG_AsCharPtrAndSize(swig_obj[10], &buf11, NULL, &alloc11);
9914  if (!SWIG_IsOK(res11)) {
9915  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
9916  }
9917  arg11 = (char *)(buf11);
9918  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
9919  resultobj = SWIG_Py_Void();
9920  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
9921  return resultobj;
9922 fail:
9923  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
9924  return NULL;
9925 }
9926 
9927 
9928 SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9929  PyObject *resultobj = 0;
9930  PLFLT result;
9931 
9932  if (!SWIG_Python_UnpackTuple(args, "plrandd", 0, 0, 0)) SWIG_fail;
9933  result = (PLFLT)plrandd();
9934  resultobj = SWIG_From_double((double)(result));
9935  return resultobj;
9936 fail:
9937  return NULL;
9938 }
9939 
9940 
9941 SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9942  PyObject *resultobj = 0;
9943 
9944  if (!SWIG_Python_UnpackTuple(args, "plreplot", 0, 0, 0)) SWIG_fail;
9945  plreplot();
9946  resultobj = SWIG_Py_Void();
9947  return resultobj;
9948 fail:
9949  return NULL;
9950 }
9951 
9952 
9953 SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9954  PyObject *resultobj = 0;
9955  PLFLT arg1 ;
9956  PLFLT arg2 ;
9957  PLFLT arg3 ;
9958  PLFLT *arg4 = (PLFLT *) 0 ;
9959  PLFLT *arg5 = (PLFLT *) 0 ;
9960  PLFLT *arg6 = (PLFLT *) 0 ;
9961  double val1 ;
9962  int ecode1 = 0 ;
9963  double val2 ;
9964  int ecode2 = 0 ;
9965  double val3 ;
9966  int ecode3 = 0 ;
9967  PLFLT temp4 ;
9968  int res4 = SWIG_TMPOBJ ;
9969  PLFLT temp5 ;
9970  int res5 = SWIG_TMPOBJ ;
9971  PLFLT temp6 ;
9972  int res6 = SWIG_TMPOBJ ;
9973  PyObject *swig_obj[3] ;
9974 
9975  arg4 = &temp4;
9976  arg5 = &temp5;
9977  arg6 = &temp6;
9978  if (!SWIG_Python_UnpackTuple(args, "plrgbhls", 3, 3, swig_obj)) SWIG_fail;
9979  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
9980  if (!SWIG_IsOK(ecode1)) {
9981  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
9982  }
9983  arg1 = (PLFLT)(val1);
9984  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9985  if (!SWIG_IsOK(ecode2)) {
9986  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
9987  }
9988  arg2 = (PLFLT)(val2);
9989  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9990  if (!SWIG_IsOK(ecode3)) {
9991  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
9992  }
9993  arg3 = (PLFLT)(val3);
9994  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
9995  resultobj = SWIG_Py_Void();
9996  if (SWIG_IsTmpObj(res4)) {
9997  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
9998  } else {
9999  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10000  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
10001  }
10002  if (SWIG_IsTmpObj(res5)) {
10003  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
10004  } else {
10005  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10006  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10007  }
10008  if (SWIG_IsTmpObj(res6)) {
10009  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10010  } else {
10011  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10012  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10013  }
10014  return resultobj;
10015 fail:
10016  return NULL;
10017 }
10018 
10019 
10020 SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10021  PyObject *resultobj = 0;
10022  PLFLT arg1 ;
10023  PLFLT arg2 ;
10024  double val1 ;
10025  int ecode1 = 0 ;
10026  double val2 ;
10027  int ecode2 = 0 ;
10028  PyObject *swig_obj[2] ;
10029 
10030  if (!SWIG_Python_UnpackTuple(args, "plschr", 2, 2, swig_obj)) SWIG_fail;
10031  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10032  if (!SWIG_IsOK(ecode1)) {
10033  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10034  }
10035  arg1 = (PLFLT)(val1);
10036  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10037  if (!SWIG_IsOK(ecode2)) {
10038  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10039  }
10040  arg2 = (PLFLT)(val2);
10041  plschr(arg1,arg2);
10042  resultobj = SWIG_Py_Void();
10043  return resultobj;
10044 fail:
10045  return NULL;
10046 }
10047 
10048 
10049 SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10050  PyObject *resultobj = 0;
10051  PLINT *arg1 = (PLINT *) 0 ;
10052  PLINT *arg2 = (PLINT *) 0 ;
10053  PLINT *arg3 = (PLINT *) 0 ;
10054  PLINT arg4 ;
10055  PyArrayObject *tmp1 = NULL ;
10056  PyArrayObject *tmp2 = NULL ;
10057  PyArrayObject *tmp3 = NULL ;
10058  PyObject *swig_obj[3] ;
10059 
10060  if (!SWIG_Python_UnpackTuple(args, "plscmap0", 3, 3, swig_obj)) SWIG_fail;
10061  {
10062  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10063  if ( tmp1 == NULL )
10064  return NULL;
10065  Alen = PyArray_DIMS( tmp1 )[0];
10066  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10067  }
10068  {
10069  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10070  if ( tmp2 == NULL )
10071  return NULL;
10072  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10073  {
10074  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10075  return NULL;
10076  }
10077  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10078  }
10079  {
10080  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10081  if ( tmp3 == NULL )
10082  return NULL;
10083  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10084  {
10085  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10086  return NULL;
10087  }
10088  arg4 = PyArray_DIMS( tmp3 )[0];
10089  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10090  }
10091  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10092  resultobj = SWIG_Py_Void();
10093  {
10094  Py_CLEAR( tmp1 );
10095  }
10096  {
10097  Py_CLEAR( tmp2 );
10098  }
10099  {
10100  Py_CLEAR( tmp3 );
10101  }
10102  return resultobj;
10103 fail:
10104  {
10105  Py_CLEAR( tmp1 );
10106  }
10107  {
10108  Py_CLEAR( tmp2 );
10109  }
10110  {
10111  Py_CLEAR( tmp3 );
10112  }
10113  return NULL;
10114 }
10115 
10116 
10117 SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10118  PyObject *resultobj = 0;
10119  PLINT *arg1 = (PLINT *) 0 ;
10120  PLINT *arg2 = (PLINT *) 0 ;
10121  PLINT *arg3 = (PLINT *) 0 ;
10122  PLFLT *arg4 = (PLFLT *) 0 ;
10123  PLINT arg5 ;
10124  PyArrayObject *tmp1 = NULL ;
10125  PyArrayObject *tmp2 = NULL ;
10126  PyArrayObject *tmp3 = NULL ;
10127  PyArrayObject *tmp4 = NULL ;
10128  PyObject *swig_obj[4] ;
10129 
10130  if (!SWIG_Python_UnpackTuple(args, "plscmap0a", 4, 4, swig_obj)) SWIG_fail;
10131  {
10132  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10133  if ( tmp1 == NULL )
10134  return NULL;
10135  Alen = PyArray_DIMS( tmp1 )[0];
10136  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10137  }
10138  {
10139  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10140  if ( tmp2 == NULL )
10141  return NULL;
10142  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10143  {
10144  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10145  return NULL;
10146  }
10147  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10148  }
10149  {
10150  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10151  if ( tmp3 == NULL )
10152  return NULL;
10153  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10154  {
10155  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10156  return NULL;
10157  }
10158  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10159  }
10160  {
10161  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10162  if ( tmp4 == NULL )
10163  return NULL;
10164  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10165  {
10166  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10167  return NULL;
10168  }
10169  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10170  arg5 = PyArray_DIMS( tmp4 )[0];
10171  }
10172  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10173  resultobj = SWIG_Py_Void();
10174  {
10175  Py_CLEAR( tmp1 );
10176  }
10177  {
10178  Py_CLEAR( tmp2 );
10179  }
10180  {
10181  Py_CLEAR( tmp3 );
10182  }
10183  {
10184  Py_CLEAR( tmp4 );
10185  }
10186  return resultobj;
10187 fail:
10188  {
10189  Py_CLEAR( tmp1 );
10190  }
10191  {
10192  Py_CLEAR( tmp2 );
10193  }
10194  {
10195  Py_CLEAR( tmp3 );
10196  }
10197  {
10198  Py_CLEAR( tmp4 );
10199  }
10200  return NULL;
10201 }
10202 
10203 
10204 SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10205  PyObject *resultobj = 0;
10206  PLINT arg1 ;
10207  int val1 ;
10208  int ecode1 = 0 ;
10209  PyObject *swig_obj[1] ;
10210 
10211  if (!args) SWIG_fail;
10212  swig_obj[0] = args;
10213  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10214  if (!SWIG_IsOK(ecode1)) {
10215  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10216  }
10217  arg1 = (PLINT)(val1);
10218  plscmap0n(arg1);
10219  resultobj = SWIG_Py_Void();
10220  return resultobj;
10221 fail:
10222  return NULL;
10223 }
10224 
10225 
10226 SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10227  PyObject *resultobj = 0;
10228  PLINT *arg1 = (PLINT *) 0 ;
10229  PLINT *arg2 = (PLINT *) 0 ;
10230  PLINT *arg3 = (PLINT *) 0 ;
10231  PLINT arg4 ;
10232  PyArrayObject *tmp1 = NULL ;
10233  PyArrayObject *tmp2 = NULL ;
10234  PyArrayObject *tmp3 = NULL ;
10235  PyObject *swig_obj[3] ;
10236 
10237  if (!SWIG_Python_UnpackTuple(args, "plscmap1", 3, 3, swig_obj)) SWIG_fail;
10238  {
10239  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10240  if ( tmp1 == NULL )
10241  return NULL;
10242  Alen = PyArray_DIMS( tmp1 )[0];
10243  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10244  }
10245  {
10246  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10247  if ( tmp2 == NULL )
10248  return NULL;
10249  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10250  {
10251  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10252  return NULL;
10253  }
10254  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10255  }
10256  {
10257  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10258  if ( tmp3 == NULL )
10259  return NULL;
10260  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10261  {
10262  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10263  return NULL;
10264  }
10265  arg4 = PyArray_DIMS( tmp3 )[0];
10266  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10267  }
10268  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10269  resultobj = SWIG_Py_Void();
10270  {
10271  Py_CLEAR( tmp1 );
10272  }
10273  {
10274  Py_CLEAR( tmp2 );
10275  }
10276  {
10277  Py_CLEAR( tmp3 );
10278  }
10279  return resultobj;
10280 fail:
10281  {
10282  Py_CLEAR( tmp1 );
10283  }
10284  {
10285  Py_CLEAR( tmp2 );
10286  }
10287  {
10288  Py_CLEAR( tmp3 );
10289  }
10290  return NULL;
10291 }
10292 
10293 
10294 SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10295  PyObject *resultobj = 0;
10296  PLINT *arg1 = (PLINT *) 0 ;
10297  PLINT *arg2 = (PLINT *) 0 ;
10298  PLINT *arg3 = (PLINT *) 0 ;
10299  PLFLT *arg4 = (PLFLT *) 0 ;
10300  PLINT arg5 ;
10301  PyArrayObject *tmp1 = NULL ;
10302  PyArrayObject *tmp2 = NULL ;
10303  PyArrayObject *tmp3 = NULL ;
10304  PyArrayObject *tmp4 = NULL ;
10305  PyObject *swig_obj[4] ;
10306 
10307  if (!SWIG_Python_UnpackTuple(args, "plscmap1a", 4, 4, swig_obj)) SWIG_fail;
10308  {
10309  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10310  if ( tmp1 == NULL )
10311  return NULL;
10312  Alen = PyArray_DIMS( tmp1 )[0];
10313  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10314  }
10315  {
10316  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10317  if ( tmp2 == NULL )
10318  return NULL;
10319  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10320  {
10321  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10322  return NULL;
10323  }
10324  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10325  }
10326  {
10327  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10328  if ( tmp3 == NULL )
10329  return NULL;
10330  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10331  {
10332  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10333  return NULL;
10334  }
10335  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10336  }
10337  {
10338  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10339  if ( tmp4 == NULL )
10340  return NULL;
10341  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10342  {
10343  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10344  return NULL;
10345  }
10346  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10347  arg5 = PyArray_DIMS( tmp4 )[0];
10348  }
10349  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10350  resultobj = SWIG_Py_Void();
10351  {
10352  Py_CLEAR( tmp1 );
10353  }
10354  {
10355  Py_CLEAR( tmp2 );
10356  }
10357  {
10358  Py_CLEAR( tmp3 );
10359  }
10360  {
10361  Py_CLEAR( tmp4 );
10362  }
10363  return resultobj;
10364 fail:
10365  {
10366  Py_CLEAR( tmp1 );
10367  }
10368  {
10369  Py_CLEAR( tmp2 );
10370  }
10371  {
10372  Py_CLEAR( tmp3 );
10373  }
10374  {
10375  Py_CLEAR( tmp4 );
10376  }
10377  return NULL;
10378 }
10379 
10380 
10381 SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10382  PyObject *resultobj = 0;
10383  PLBOOL arg1 ;
10384  PLINT arg2 ;
10385  PLFLT *arg3 = (PLFLT *) 0 ;
10386  PLFLT *arg4 = (PLFLT *) 0 ;
10387  PLFLT *arg5 = (PLFLT *) 0 ;
10388  PLFLT *arg6 = (PLFLT *) 0 ;
10389  PLBOOL *arg7 = (PLBOOL *) 0 ;
10390  int val1 ;
10391  int ecode1 = 0 ;
10392  PyArrayObject *tmp2 = NULL ;
10393  PyArrayObject *tmp4 = NULL ;
10394  PyArrayObject *tmp5 = NULL ;
10395  PyArrayObject *tmp6 = NULL ;
10396  PyArrayObject *tmp7 = NULL ;
10397  PyObject *swig_obj[6] ;
10398 
10399  if (!SWIG_Python_UnpackTuple(args, "plscmap1l", 6, 6, swig_obj)) SWIG_fail;
10400  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10401  if (!SWIG_IsOK(ecode1)) {
10402  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10403  }
10404  arg1 = (PLBOOL)(val1);
10405  {
10406  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10407  if ( tmp2 == NULL )
10408  return NULL;
10409  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10410  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10411  }
10412  {
10413  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10414  if ( tmp4 == NULL )
10415  return NULL;
10416  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10417  {
10418  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10419  return NULL;
10420  }
10421  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10422  }
10423  {
10424  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10425  if ( tmp5 == NULL )
10426  return NULL;
10427  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10428  {
10429  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10430  return NULL;
10431  }
10432  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10433  }
10434  {
10435  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
10436  if ( tmp6 == NULL )
10437  return NULL;
10438  if ( PyArray_DIMS( tmp6 )[0] != Alen )
10439  {
10440  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10441  return NULL;
10442  }
10443  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10444  }
10445  {
10446  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[5], NPY_PLINT, 1, 1 );
10447  if ( tmp7 == NULL )
10448  return NULL;
10449  if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10450  {
10451  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10452  return NULL;
10453  }
10454  arg7 = (PLINT *) PyArray_DATA( tmp7 );
10455  }
10456  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
10457  resultobj = SWIG_Py_Void();
10458  {
10459  Py_CLEAR( tmp2 );
10460  }
10461  {
10462  Py_CLEAR( tmp4 );
10463  }
10464  {
10465  Py_CLEAR( tmp5 );
10466  }
10467  {
10468  Py_CLEAR( tmp6 );
10469  }
10470  {
10471  Py_CLEAR( tmp7 );
10472  }
10473  return resultobj;
10474 fail:
10475  {
10476  Py_CLEAR( tmp2 );
10477  }
10478  {
10479  Py_CLEAR( tmp4 );
10480  }
10481  {
10482  Py_CLEAR( tmp5 );
10483  }
10484  {
10485  Py_CLEAR( tmp6 );
10486  }
10487  {
10488  Py_CLEAR( tmp7 );
10489  }
10490  return NULL;
10491 }
10492 
10493 
10494 SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10495  PyObject *resultobj = 0;
10496  PLBOOL arg1 ;
10497  PLINT arg2 ;
10498  PLFLT *arg3 = (PLFLT *) 0 ;
10499  PLFLT *arg4 = (PLFLT *) 0 ;
10500  PLFLT *arg5 = (PLFLT *) 0 ;
10501  PLFLT *arg6 = (PLFLT *) 0 ;
10502  PLFLT *arg7 = (PLFLT *) 0 ;
10503  PLBOOL *arg8 = (PLBOOL *) 0 ;
10504  int val1 ;
10505  int ecode1 = 0 ;
10506  PyArrayObject *tmp2 = NULL ;
10507  PyArrayObject *tmp4 = NULL ;
10508  PyArrayObject *tmp5 = NULL ;
10509  PyArrayObject *tmp6 = NULL ;
10510  PyArrayObject *tmp7 = NULL ;
10511  PyArrayObject *tmp8 = NULL ;
10512  PyObject *swig_obj[7] ;
10513 
10514  if (!SWIG_Python_UnpackTuple(args, "plscmap1la", 7, 7, swig_obj)) SWIG_fail;
10515  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10516  if (!SWIG_IsOK(ecode1)) {
10517  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
10518  }
10519  arg1 = (PLBOOL)(val1);
10520  {
10521  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10522  if ( tmp2 == NULL )
10523  return NULL;
10524  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10525  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10526  }
10527  {
10528  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10529  if ( tmp4 == NULL )
10530  return NULL;
10531  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10532  {
10533  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10534  return NULL;
10535  }
10536  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10537  }
10538  {
10539  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10540  if ( tmp5 == NULL )
10541  return NULL;
10542  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10543  {
10544  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10545  return NULL;
10546  }
10547  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10548  }
10549  {
10550  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
10551  if ( tmp6 == NULL )
10552  return NULL;
10553  if ( PyArray_DIMS( tmp6 )[0] != Alen )
10554  {
10555  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10556  return NULL;
10557  }
10558  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10559  }
10560  {
10561  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
10562  if ( tmp7 == NULL )
10563  return NULL;
10564  if ( PyArray_DIMS( tmp7 )[0] != Alen )
10565  {
10566  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10567  return NULL;
10568  }
10569  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
10570  }
10571  {
10572  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
10573  if ( tmp8 == NULL )
10574  return NULL;
10575  if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
10576  {
10577  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10578  return NULL;
10579  }
10580  arg8 = (PLINT *) PyArray_DATA( tmp8 );
10581  }
10582  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
10583  resultobj = SWIG_Py_Void();
10584  {
10585  Py_CLEAR( tmp2 );
10586  }
10587  {
10588  Py_CLEAR( tmp4 );
10589  }
10590  {
10591  Py_CLEAR( tmp5 );
10592  }
10593  {
10594  Py_CLEAR( tmp6 );
10595  }
10596  {
10597  Py_CLEAR( tmp7 );
10598  }
10599  {
10600  Py_CLEAR( tmp8 );
10601  }
10602  return resultobj;
10603 fail:
10604  {
10605  Py_CLEAR( tmp2 );
10606  }
10607  {
10608  Py_CLEAR( tmp4 );
10609  }
10610  {
10611  Py_CLEAR( tmp5 );
10612  }
10613  {
10614  Py_CLEAR( tmp6 );
10615  }
10616  {
10617  Py_CLEAR( tmp7 );
10618  }
10619  {
10620  Py_CLEAR( tmp8 );
10621  }
10622  return NULL;
10623 }
10624 
10625 
10626 SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10627  PyObject *resultobj = 0;
10628  PLINT arg1 ;
10629  int val1 ;
10630  int ecode1 = 0 ;
10631  PyObject *swig_obj[1] ;
10632 
10633  if (!args) SWIG_fail;
10634  swig_obj[0] = args;
10635  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10636  if (!SWIG_IsOK(ecode1)) {
10637  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
10638  }
10639  arg1 = (PLINT)(val1);
10640  plscmap1n(arg1);
10641  resultobj = SWIG_Py_Void();
10642  return resultobj;
10643 fail:
10644  return NULL;
10645 }
10646 
10647 
10648 SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10649  PyObject *resultobj = 0;
10650  PLFLT arg1 ;
10651  PLFLT arg2 ;
10652  double val1 ;
10653  int ecode1 = 0 ;
10654  double val2 ;
10655  int ecode2 = 0 ;
10656  PyObject *swig_obj[2] ;
10657 
10658  if (!SWIG_Python_UnpackTuple(args, "plscmap1_range", 2, 2, swig_obj)) SWIG_fail;
10659  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10660  if (!SWIG_IsOK(ecode1)) {
10661  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
10662  }
10663  arg1 = (PLFLT)(val1);
10664  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10665  if (!SWIG_IsOK(ecode2)) {
10666  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
10667  }
10668  arg2 = (PLFLT)(val2);
10669  plscmap1_range(arg1,arg2);
10670  resultobj = SWIG_Py_Void();
10671  return resultobj;
10672 fail:
10673  return NULL;
10674 }
10675 
10676 
10677 SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10678  PyObject *resultobj = 0;
10679  PLFLT *arg1 = (PLFLT *) 0 ;
10680  PLFLT *arg2 = (PLFLT *) 0 ;
10681  PLFLT temp1 ;
10682  int res1 = SWIG_TMPOBJ ;
10683  PLFLT temp2 ;
10684  int res2 = SWIG_TMPOBJ ;
10685 
10686  arg1 = &temp1;
10687  arg2 = &temp2;
10688  if (!SWIG_Python_UnpackTuple(args, "plgcmap1_range", 0, 0, 0)) SWIG_fail;
10689  plgcmap1_range(arg1,arg2);
10690  resultobj = SWIG_Py_Void();
10691  if (SWIG_IsTmpObj(res1)) {
10692  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
10693  } else {
10694  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10695  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
10696  }
10697  if (SWIG_IsTmpObj(res2)) {
10698  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
10699  } else {
10700  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10701  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
10702  }
10703  return resultobj;
10704 fail:
10705  return NULL;
10706 }
10707 
10708 
10709 SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10710  PyObject *resultobj = 0;
10711  PLINT arg1 ;
10712  PLINT arg2 ;
10713  PLINT arg3 ;
10714  PLINT arg4 ;
10715  int val1 ;
10716  int ecode1 = 0 ;
10717  int val2 ;
10718  int ecode2 = 0 ;
10719  int val3 ;
10720  int ecode3 = 0 ;
10721  int val4 ;
10722  int ecode4 = 0 ;
10723  PyObject *swig_obj[4] ;
10724 
10725  if (!SWIG_Python_UnpackTuple(args, "plscol0", 4, 4, swig_obj)) SWIG_fail;
10726  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10727  if (!SWIG_IsOK(ecode1)) {
10728  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
10729  }
10730  arg1 = (PLINT)(val1);
10731  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10732  if (!SWIG_IsOK(ecode2)) {
10733  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
10734  }
10735  arg2 = (PLINT)(val2);
10736  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10737  if (!SWIG_IsOK(ecode3)) {
10738  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
10739  }
10740  arg3 = (PLINT)(val3);
10741  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
10742  if (!SWIG_IsOK(ecode4)) {
10743  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
10744  }
10745  arg4 = (PLINT)(val4);
10746  plscol0(arg1,arg2,arg3,arg4);
10747  resultobj = SWIG_Py_Void();
10748  return resultobj;
10749 fail:
10750  return NULL;
10751 }
10752 
10753 
10754 SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10755  PyObject *resultobj = 0;
10756  PLINT arg1 ;
10757  PLINT arg2 ;
10758  PLINT arg3 ;
10759  PLINT arg4 ;
10760  PLFLT arg5 ;
10761  int val1 ;
10762  int ecode1 = 0 ;
10763  int val2 ;
10764  int ecode2 = 0 ;
10765  int val3 ;
10766  int ecode3 = 0 ;
10767  int val4 ;
10768  int ecode4 = 0 ;
10769  double val5 ;
10770  int ecode5 = 0 ;
10771  PyObject *swig_obj[5] ;
10772 
10773  if (!SWIG_Python_UnpackTuple(args, "plscol0a", 5, 5, swig_obj)) SWIG_fail;
10774  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10775  if (!SWIG_IsOK(ecode1)) {
10776  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
10777  }
10778  arg1 = (PLINT)(val1);
10779  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10780  if (!SWIG_IsOK(ecode2)) {
10781  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
10782  }
10783  arg2 = (PLINT)(val2);
10784  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10785  if (!SWIG_IsOK(ecode3)) {
10786  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
10787  }
10788  arg3 = (PLINT)(val3);
10789  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
10790  if (!SWIG_IsOK(ecode4)) {
10791  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
10792  }
10793  arg4 = (PLINT)(val4);
10794  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10795  if (!SWIG_IsOK(ecode5)) {
10796  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
10797  }
10798  arg5 = (PLFLT)(val5);
10799  plscol0a(arg1,arg2,arg3,arg4,arg5);
10800  resultobj = SWIG_Py_Void();
10801  return resultobj;
10802 fail:
10803  return NULL;
10804 }
10805 
10806 
10807 SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10808  PyObject *resultobj = 0;
10809  PLINT arg1 ;
10810  PLINT arg2 ;
10811  PLINT arg3 ;
10812  int val1 ;
10813  int ecode1 = 0 ;
10814  int val2 ;
10815  int ecode2 = 0 ;
10816  int val3 ;
10817  int ecode3 = 0 ;
10818  PyObject *swig_obj[3] ;
10819 
10820  if (!SWIG_Python_UnpackTuple(args, "plscolbg", 3, 3, swig_obj)) SWIG_fail;
10821  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10822  if (!SWIG_IsOK(ecode1)) {
10823  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
10824  }
10825  arg1 = (PLINT)(val1);
10826  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10827  if (!SWIG_IsOK(ecode2)) {
10828  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
10829  }
10830  arg2 = (PLINT)(val2);
10831  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10832  if (!SWIG_IsOK(ecode3)) {
10833  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
10834  }
10835  arg3 = (PLINT)(val3);
10836  plscolbg(arg1,arg2,arg3);
10837  resultobj = SWIG_Py_Void();
10838  return resultobj;
10839 fail:
10840  return NULL;
10841 }
10842 
10843 
10844 SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10845  PyObject *resultobj = 0;
10846  PLINT arg1 ;
10847  PLINT arg2 ;
10848  PLINT arg3 ;
10849  PLFLT arg4 ;
10850  int val1 ;
10851  int ecode1 = 0 ;
10852  int val2 ;
10853  int ecode2 = 0 ;
10854  int val3 ;
10855  int ecode3 = 0 ;
10856  double val4 ;
10857  int ecode4 = 0 ;
10858  PyObject *swig_obj[4] ;
10859 
10860  if (!SWIG_Python_UnpackTuple(args, "plscolbga", 4, 4, swig_obj)) SWIG_fail;
10861  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10862  if (!SWIG_IsOK(ecode1)) {
10863  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
10864  }
10865  arg1 = (PLINT)(val1);
10866  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10867  if (!SWIG_IsOK(ecode2)) {
10868  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
10869  }
10870  arg2 = (PLINT)(val2);
10871  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10872  if (!SWIG_IsOK(ecode3)) {
10873  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
10874  }
10875  arg3 = (PLINT)(val3);
10876  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10877  if (!SWIG_IsOK(ecode4)) {
10878  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
10879  }
10880  arg4 = (PLFLT)(val4);
10881  plscolbga(arg1,arg2,arg3,arg4);
10882  resultobj = SWIG_Py_Void();
10883  return resultobj;
10884 fail:
10885  return NULL;
10886 }
10887 
10888 
10889 SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10890  PyObject *resultobj = 0;
10891  PLINT arg1 ;
10892  int val1 ;
10893  int ecode1 = 0 ;
10894  PyObject *swig_obj[1] ;
10895 
10896  if (!args) SWIG_fail;
10897  swig_obj[0] = args;
10898  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10899  if (!SWIG_IsOK(ecode1)) {
10900  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
10901  }
10902  arg1 = (PLINT)(val1);
10903  plscolor(arg1);
10904  resultobj = SWIG_Py_Void();
10905  return resultobj;
10906 fail:
10907  return NULL;
10908 }
10909 
10910 
10911 SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10912  PyObject *resultobj = 0;
10913  PLINT arg1 ;
10914  int val1 ;
10915  int ecode1 = 0 ;
10916  PyObject *swig_obj[1] ;
10917 
10918  if (!args) SWIG_fail;
10919  swig_obj[0] = args;
10920  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10921  if (!SWIG_IsOK(ecode1)) {
10922  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
10923  }
10924  arg1 = (PLINT)(val1);
10925  plscompression(arg1);
10926  resultobj = SWIG_Py_Void();
10927  return resultobj;
10928 fail:
10929  return NULL;
10930 }
10931 
10932 
10933 SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10934  PyObject *resultobj = 0;
10935  char *arg1 = (char *) 0 ;
10936  int res1 ;
10937  char *buf1 = 0 ;
10938  int alloc1 = 0 ;
10939  PyObject *swig_obj[1] ;
10940 
10941  if (!args) SWIG_fail;
10942  swig_obj[0] = args;
10943  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
10944  if (!SWIG_IsOK(res1)) {
10945  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
10946  }
10947  arg1 = (char *)(buf1);
10948  plsdev((char const *)arg1);
10949  resultobj = SWIG_Py_Void();
10950  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10951  return resultobj;
10952 fail:
10953  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10954  return NULL;
10955 }
10956 
10957 
10958 SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10959  PyObject *resultobj = 0;
10960  PLFLT arg1 ;
10961  PLFLT arg2 ;
10962  PLFLT arg3 ;
10963  PLFLT arg4 ;
10964  double val1 ;
10965  int ecode1 = 0 ;
10966  double val2 ;
10967  int ecode2 = 0 ;
10968  double val3 ;
10969  int ecode3 = 0 ;
10970  double val4 ;
10971  int ecode4 = 0 ;
10972  PyObject *swig_obj[4] ;
10973 
10974  if (!SWIG_Python_UnpackTuple(args, "plsdidev", 4, 4, swig_obj)) SWIG_fail;
10975  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10976  if (!SWIG_IsOK(ecode1)) {
10977  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
10978  }
10979  arg1 = (PLFLT)(val1);
10980  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10981  if (!SWIG_IsOK(ecode2)) {
10982  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
10983  }
10984  arg2 = (PLFLT)(val2);
10985  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10986  if (!SWIG_IsOK(ecode3)) {
10987  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
10988  }
10989  arg3 = (PLFLT)(val3);
10990  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10991  if (!SWIG_IsOK(ecode4)) {
10992  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
10993  }
10994  arg4 = (PLFLT)(val4);
10995  plsdidev(arg1,arg2,arg3,arg4);
10996  resultobj = SWIG_Py_Void();
10997  return resultobj;
10998 fail:
10999  return NULL;
11000 }
11001 
11002 
11003 SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11004  PyObject *resultobj = 0;
11005  PLINT arg1 ;
11006  PLINT arg2 ;
11007  PLINT arg3 ;
11008  PLINT arg4 ;
11009  PLFLT arg5 ;
11010  PLFLT arg6 ;
11011  int val1 ;
11012  int ecode1 = 0 ;
11013  int val2 ;
11014  int ecode2 = 0 ;
11015  int val3 ;
11016  int ecode3 = 0 ;
11017  int val4 ;
11018  int ecode4 = 0 ;
11019  double val5 ;
11020  int ecode5 = 0 ;
11021  double val6 ;
11022  int ecode6 = 0 ;
11023  PyObject *swig_obj[6] ;
11024 
11025  if (!SWIG_Python_UnpackTuple(args, "plsdimap", 6, 6, swig_obj)) SWIG_fail;
11026  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11027  if (!SWIG_IsOK(ecode1)) {
11028  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11029  }
11030  arg1 = (PLINT)(val1);
11031  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11032  if (!SWIG_IsOK(ecode2)) {
11033  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11034  }
11035  arg2 = (PLINT)(val2);
11036  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11037  if (!SWIG_IsOK(ecode3)) {
11038  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11039  }
11040  arg3 = (PLINT)(val3);
11041  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11042  if (!SWIG_IsOK(ecode4)) {
11043  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11044  }
11045  arg4 = (PLINT)(val4);
11046  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11047  if (!SWIG_IsOK(ecode5)) {
11048  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11049  }
11050  arg5 = (PLFLT)(val5);
11051  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
11052  if (!SWIG_IsOK(ecode6)) {
11053  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11054  }
11055  arg6 = (PLFLT)(val6);
11056  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11057  resultobj = SWIG_Py_Void();
11058  return resultobj;
11059 fail:
11060  return NULL;
11061 }
11062 
11063 
11064 SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11065  PyObject *resultobj = 0;
11066  PLFLT arg1 ;
11067  double val1 ;
11068  int ecode1 = 0 ;
11069  PyObject *swig_obj[1] ;
11070 
11071  if (!args) SWIG_fail;
11072  swig_obj[0] = args;
11073  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11074  if (!SWIG_IsOK(ecode1)) {
11075  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11076  }
11077  arg1 = (PLFLT)(val1);
11078  plsdiori(arg1);
11079  resultobj = SWIG_Py_Void();
11080  return resultobj;
11081 fail:
11082  return NULL;
11083 }
11084 
11085 
11086 SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11087  PyObject *resultobj = 0;
11088  PLFLT arg1 ;
11089  PLFLT arg2 ;
11090  PLFLT arg3 ;
11091  PLFLT arg4 ;
11092  double val1 ;
11093  int ecode1 = 0 ;
11094  double val2 ;
11095  int ecode2 = 0 ;
11096  double val3 ;
11097  int ecode3 = 0 ;
11098  double val4 ;
11099  int ecode4 = 0 ;
11100  PyObject *swig_obj[4] ;
11101 
11102  if (!SWIG_Python_UnpackTuple(args, "plsdiplt", 4, 4, swig_obj)) SWIG_fail;
11103  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11104  if (!SWIG_IsOK(ecode1)) {
11105  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11106  }
11107  arg1 = (PLFLT)(val1);
11108  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11109  if (!SWIG_IsOK(ecode2)) {
11110  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11111  }
11112  arg2 = (PLFLT)(val2);
11113  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11114  if (!SWIG_IsOK(ecode3)) {
11115  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11116  }
11117  arg3 = (PLFLT)(val3);
11118  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11119  if (!SWIG_IsOK(ecode4)) {
11120  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11121  }
11122  arg4 = (PLFLT)(val4);
11123  plsdiplt(arg1,arg2,arg3,arg4);
11124  resultobj = SWIG_Py_Void();
11125  return resultobj;
11126 fail:
11127  return NULL;
11128 }
11129 
11130 
11131 SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11132  PyObject *resultobj = 0;
11133  PLFLT arg1 ;
11134  PLFLT arg2 ;
11135  PLFLT arg3 ;
11136  PLFLT arg4 ;
11137  double val1 ;
11138  int ecode1 = 0 ;
11139  double val2 ;
11140  int ecode2 = 0 ;
11141  double val3 ;
11142  int ecode3 = 0 ;
11143  double val4 ;
11144  int ecode4 = 0 ;
11145  PyObject *swig_obj[4] ;
11146 
11147  if (!SWIG_Python_UnpackTuple(args, "plsdiplz", 4, 4, swig_obj)) SWIG_fail;
11148  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11149  if (!SWIG_IsOK(ecode1)) {
11150  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11151  }
11152  arg1 = (PLFLT)(val1);
11153  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11154  if (!SWIG_IsOK(ecode2)) {
11155  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11156  }
11157  arg2 = (PLFLT)(val2);
11158  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11159  if (!SWIG_IsOK(ecode3)) {
11160  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11161  }
11162  arg3 = (PLFLT)(val3);
11163  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11164  if (!SWIG_IsOK(ecode4)) {
11165  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11166  }
11167  arg4 = (PLFLT)(val4);
11168  plsdiplz(arg1,arg2,arg3,arg4);
11169  resultobj = SWIG_Py_Void();
11170  return resultobj;
11171 fail:
11172  return NULL;
11173 }
11174 
11175 
11176 SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11177  PyObject *resultobj = 0;
11178  unsigned int arg1 ;
11179  unsigned int val1 ;
11180  int ecode1 = 0 ;
11181  PyObject *swig_obj[1] ;
11182 
11183  if (!args) SWIG_fail;
11184  swig_obj[0] = args;
11185  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11186  if (!SWIG_IsOK(ecode1)) {
11187  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11188  }
11189  arg1 = (unsigned int)(val1);
11190  plseed(arg1);
11191  resultobj = SWIG_Py_Void();
11192  return resultobj;
11193 fail:
11194  return NULL;
11195 }
11196 
11197 
11198 SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11199  PyObject *resultobj = 0;
11200  char arg1 ;
11201  char val1 ;
11202  int ecode1 = 0 ;
11203  PyObject *swig_obj[1] ;
11204 
11205  if (!args) SWIG_fail;
11206  swig_obj[0] = args;
11207  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
11208  if (!SWIG_IsOK(ecode1)) {
11209  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11210  }
11211  arg1 = (char)(val1);
11212  plsesc(arg1);
11213  resultobj = SWIG_Py_Void();
11214  return resultobj;
11215 fail:
11216  return NULL;
11217 }
11218 
11219 
11220 SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11221  PyObject *resultobj = 0;
11222  char *arg1 = (char *) 0 ;
11223  char *arg2 = (char *) 0 ;
11224  int res1 ;
11225  char *buf1 = 0 ;
11226  int alloc1 = 0 ;
11227  int res2 ;
11228  char *buf2 = 0 ;
11229  int alloc2 = 0 ;
11230  PyObject *swig_obj[2] ;
11231  PLINT result;
11232 
11233  if (!SWIG_Python_UnpackTuple(args, "plsetopt", 2, 2, swig_obj)) SWIG_fail;
11234  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11235  if (!SWIG_IsOK(res1)) {
11236  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11237  }
11238  arg1 = (char *)(buf1);
11239  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
11240  if (!SWIG_IsOK(res2)) {
11241  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11242  }
11243  arg2 = (char *)(buf2);
11244  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11245  resultobj = SWIG_From_int((int)(result));
11246  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11247  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11248  return resultobj;
11249 fail:
11250  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11251  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11252  return NULL;
11253 }
11254 
11255 
11256 SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11257  PyObject *resultobj = 0;
11258  PLINT arg1 ;
11259  PLINT arg2 ;
11260  PLINT arg3 ;
11261  int val1 ;
11262  int ecode1 = 0 ;
11263  int val2 ;
11264  int ecode2 = 0 ;
11265  int val3 ;
11266  int ecode3 = 0 ;
11267  PyObject *swig_obj[3] ;
11268 
11269  if (!SWIG_Python_UnpackTuple(args, "plsfam", 3, 3, swig_obj)) SWIG_fail;
11270  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11271  if (!SWIG_IsOK(ecode1)) {
11272  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11273  }
11274  arg1 = (PLINT)(val1);
11275  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11276  if (!SWIG_IsOK(ecode2)) {
11277  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11278  }
11279  arg2 = (PLINT)(val2);
11280  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11281  if (!SWIG_IsOK(ecode3)) {
11282  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11283  }
11284  arg3 = (PLINT)(val3);
11285  plsfam(arg1,arg2,arg3);
11286  resultobj = SWIG_Py_Void();
11287  return resultobj;
11288 fail:
11289  return NULL;
11290 }
11291 
11292 
11293 SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11294  PyObject *resultobj = 0;
11295  PLUNICODE arg1 ;
11296  unsigned int val1 ;
11297  int ecode1 = 0 ;
11298  PyObject *swig_obj[1] ;
11299 
11300  if (!args) SWIG_fail;
11301  swig_obj[0] = args;
11302  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11303  if (!SWIG_IsOK(ecode1)) {
11304  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11305  }
11306  arg1 = (PLUNICODE)(val1);
11307  plsfci(arg1);
11308  resultobj = SWIG_Py_Void();
11309  return resultobj;
11310 fail:
11311  return NULL;
11312 }
11313 
11314 
11315 SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11316  PyObject *resultobj = 0;
11317  char *arg1 = (char *) 0 ;
11318  int res1 ;
11319  char *buf1 = 0 ;
11320  int alloc1 = 0 ;
11321  PyObject *swig_obj[1] ;
11322 
11323  if (!args) SWIG_fail;
11324  swig_obj[0] = args;
11325  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11326  if (!SWIG_IsOK(res1)) {
11327  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11328  }
11329  arg1 = (char *)(buf1);
11330  plsfnam((char const *)arg1);
11331  resultobj = SWIG_Py_Void();
11332  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11333  return resultobj;
11334 fail:
11335  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11336  return NULL;
11337 }
11338 
11339 
11340 SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11341  PyObject *resultobj = 0;
11342  PLINT arg1 ;
11343  PLINT arg2 ;
11344  PLINT arg3 ;
11345  int val1 ;
11346  int ecode1 = 0 ;
11347  int val2 ;
11348  int ecode2 = 0 ;
11349  int val3 ;
11350  int ecode3 = 0 ;
11351  PyObject *swig_obj[3] ;
11352 
11353  if (!SWIG_Python_UnpackTuple(args, "plsfont", 3, 3, swig_obj)) SWIG_fail;
11354  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11355  if (!SWIG_IsOK(ecode1)) {
11356  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11357  }
11358  arg1 = (PLINT)(val1);
11359  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11360  if (!SWIG_IsOK(ecode2)) {
11361  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11362  }
11363  arg2 = (PLINT)(val2);
11364  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11365  if (!SWIG_IsOK(ecode3)) {
11366  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11367  }
11368  arg3 = (PLINT)(val3);
11369  plsfont(arg1,arg2,arg3);
11370  resultobj = SWIG_Py_Void();
11371  return resultobj;
11372 fail:
11373  return NULL;
11374 }
11375 
11376 
11377 SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11378  PyObject *resultobj = 0;
11379  PLFLT **arg1 = (PLFLT **) 0 ;
11380  PLINT arg2 ;
11381  PLINT arg3 ;
11382  defined_func arg4 = (defined_func) 0 ;
11383  PLFLT arg5 ;
11384  PLFLT arg6 ;
11385  PLFLT arg7 ;
11386  PLFLT arg8 ;
11387  PLFLT *arg9 = (PLFLT *) 0 ;
11388  PLINT arg10 ;
11389  PLFLT arg11 ;
11390  PLINT arg12 ;
11391  PLFLT arg13 ;
11392  fill_func arg14 = (fill_func) 0 ;
11393  PLBOOL arg15 ;
11394  pltr_func arg16 = (pltr_func) 0 ;
11395  PLPointer arg17 = (PLPointer) 0 ;
11396  PyArrayObject *tmp1 = NULL ;
11397  double val5 ;
11398  int ecode5 = 0 ;
11399  double val6 ;
11400  int ecode6 = 0 ;
11401  double val7 ;
11402  int ecode7 = 0 ;
11403  double val8 ;
11404  int ecode8 = 0 ;
11405  PyArrayObject *tmp9 = NULL ;
11406  double val11 ;
11407  int ecode11 = 0 ;
11408  int val12 ;
11409  int ecode12 = 0 ;
11410  double val13 ;
11411  int ecode13 = 0 ;
11412  int val15 ;
11413  int ecode15 = 0 ;
11414  PyObject *swig_obj[12] ;
11415 
11416  {
11417  python_pltr = 0;
11418  arg16 = NULL;
11419  }
11420  {
11421  arg17 = NULL;
11422  }
11423  {
11424  arg4 = NULL;
11425  }
11426  {
11427  arg14 = plfill;
11428  }
11429  if (!SWIG_Python_UnpackTuple(args, "plshades", 10, 12, swig_obj)) SWIG_fail;
11430  {
11431  int i, size;
11432  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
11433  if ( tmp1 == NULL )
11434  return NULL;
11435  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11436  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11437  size = arg3;
11438  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
11439  for ( i = 0; i < arg2; i++ )
11440  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11441  }
11442  ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
11443  if (!SWIG_IsOK(ecode5)) {
11444  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
11445  }
11446  arg5 = (PLFLT)(val5);
11447  ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
11448  if (!SWIG_IsOK(ecode6)) {
11449  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
11450  }
11451  arg6 = (PLFLT)(val6);
11452  ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
11453  if (!SWIG_IsOK(ecode7)) {
11454  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
11455  }
11456  arg7 = (PLFLT)(val7);
11457  ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
11458  if (!SWIG_IsOK(ecode8)) {
11459  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
11460  }
11461  arg8 = (PLFLT)(val8);
11462  {
11463  tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
11464  if ( tmp9 == NULL )
11465  return NULL;
11466  arg10 = PyArray_DIMS( tmp9 )[0];
11467  arg9 = (PLFLT *) PyArray_DATA( tmp9 );
11468  }
11469  ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
11470  if (!SWIG_IsOK(ecode11)) {
11471  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
11472  }
11473  arg11 = (PLFLT)(val11);
11474  ecode12 = SWIG_AsVal_int(swig_obj[7], &val12);
11475  if (!SWIG_IsOK(ecode12)) {
11476  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
11477  }
11478  arg12 = (PLINT)(val12);
11479  ecode13 = SWIG_AsVal_double(swig_obj[8], &val13);
11480  if (!SWIG_IsOK(ecode13)) {
11481  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
11482  }
11483  arg13 = (PLFLT)(val13);
11484  ecode15 = SWIG_AsVal_int(swig_obj[9], &val15);
11485  if (!SWIG_IsOK(ecode15)) {
11486  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
11487  }
11488  arg15 = (PLBOOL)(val15);
11489  if (swig_obj[10]) {
11490  {
11491  // it must be a callable or None
11492  if ( swig_obj[10] == Py_None )
11493  {
11494  arg16 = NULL;
11495  }
11496  else
11497  {
11498  if ( !PyCallable_Check( (PyObject *) swig_obj[10] ) )
11499  {
11500  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11501  return NULL;
11502  }
11503  arg16 = marshal_pltr( swig_obj[10] );
11504  }
11505  }
11506  }
11507  if (swig_obj[11]) {
11508  {
11509  if ( swig_obj[11] == Py_None )
11510  arg17 = NULL;
11511  else
11512  {
11513  arg17 = marshal_PLPointer( swig_obj[11], 0 );
11514  }
11515  }
11516  }
11517  plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11518  resultobj = SWIG_Py_Void();
11519  {
11520  Py_CLEAR( tmp1 );
11521  free( arg1 );
11522  }
11523  {
11524  Py_CLEAR( tmp9 );
11525  }
11526  {
11527  cleanup_pltr();
11528  }
11529  {
11531  }
11532  return resultobj;
11533 fail:
11534  {
11535  Py_CLEAR( tmp1 );
11536  free( arg1 );
11537  }
11538  {
11539  Py_CLEAR( tmp9 );
11540  }
11541  {
11542  cleanup_pltr();
11543  }
11544  {
11546  }
11547  return NULL;
11548 }
11549 
11550 
11551 SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11552  PyObject *resultobj = 0;
11553  PLFLT **arg1 = (PLFLT **) 0 ;
11554  PLINT arg2 ;
11555  PLINT arg3 ;
11556  defined_func arg4 = (defined_func) 0 ;
11557  PLFLT arg5 ;
11558  PLFLT arg6 ;
11559  PLFLT arg7 ;
11560  PLFLT arg8 ;
11561  PLFLT arg9 ;
11562  PLFLT arg10 ;
11563  PLINT arg11 ;
11564  PLFLT arg12 ;
11565  PLFLT arg13 ;
11566  PLINT arg14 ;
11567  PLFLT arg15 ;
11568  PLINT arg16 ;
11569  PLFLT arg17 ;
11570  fill_func arg18 = (fill_func) 0 ;
11571  PLBOOL arg19 ;
11572  pltr_func arg20 = (pltr_func) 0 ;
11573  PLPointer arg21 = (PLPointer) 0 ;
11574  PyArrayObject *tmp1 = NULL ;
11575  double val5 ;
11576  int ecode5 = 0 ;
11577  double val6 ;
11578  int ecode6 = 0 ;
11579  double val7 ;
11580  int ecode7 = 0 ;
11581  double val8 ;
11582  int ecode8 = 0 ;
11583  double val9 ;
11584  int ecode9 = 0 ;
11585  double val10 ;
11586  int ecode10 = 0 ;
11587  int val11 ;
11588  int ecode11 = 0 ;
11589  double val12 ;
11590  int ecode12 = 0 ;
11591  double val13 ;
11592  int ecode13 = 0 ;
11593  int val14 ;
11594  int ecode14 = 0 ;
11595  double val15 ;
11596  int ecode15 = 0 ;
11597  int val16 ;
11598  int ecode16 = 0 ;
11599  double val17 ;
11600  int ecode17 = 0 ;
11601  int val19 ;
11602  int ecode19 = 0 ;
11603  PyObject *swig_obj[17] ;
11604 
11605  {
11606  python_pltr = 0;
11607  arg20 = NULL;
11608  }
11609  {
11610  arg21 = NULL;
11611  }
11612  {
11613  arg4 = NULL;
11614  }
11615  {
11616  arg18 = plfill;
11617  }
11618  if (!SWIG_Python_UnpackTuple(args, "plshade", 15, 17, swig_obj)) SWIG_fail;
11619  {
11620  int i, size;
11621  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
11622  if ( tmp1 == NULL )
11623  return NULL;
11624  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11625  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11626  size = arg3;
11627  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
11628  for ( i = 0; i < arg2; i++ )
11629  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11630  }
11631  ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
11632  if (!SWIG_IsOK(ecode5)) {
11633  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
11634  }
11635  arg5 = (PLFLT)(val5);
11636  ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
11637  if (!SWIG_IsOK(ecode6)) {
11638  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
11639  }
11640  arg6 = (PLFLT)(val6);
11641  ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
11642  if (!SWIG_IsOK(ecode7)) {
11643  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
11644  }
11645  arg7 = (PLFLT)(val7);
11646  ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
11647  if (!SWIG_IsOK(ecode8)) {
11648  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
11649  }
11650  arg8 = (PLFLT)(val8);
11651  ecode9 = SWIG_AsVal_double(swig_obj[5], &val9);
11652  if (!SWIG_IsOK(ecode9)) {
11653  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
11654  }
11655  arg9 = (PLFLT)(val9);
11656  ecode10 = SWIG_AsVal_double(swig_obj[6], &val10);
11657  if (!SWIG_IsOK(ecode10)) {
11658  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
11659  }
11660  arg10 = (PLFLT)(val10);
11661  ecode11 = SWIG_AsVal_int(swig_obj[7], &val11);
11662  if (!SWIG_IsOK(ecode11)) {
11663  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
11664  }
11665  arg11 = (PLINT)(val11);
11666  ecode12 = SWIG_AsVal_double(swig_obj[8], &val12);
11667  if (!SWIG_IsOK(ecode12)) {
11668  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
11669  }
11670  arg12 = (PLFLT)(val12);
11671  ecode13 = SWIG_AsVal_double(swig_obj[9], &val13);
11672  if (!SWIG_IsOK(ecode13)) {
11673  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
11674  }
11675  arg13 = (PLFLT)(val13);
11676  ecode14 = SWIG_AsVal_int(swig_obj[10], &val14);
11677  if (!SWIG_IsOK(ecode14)) {
11678  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
11679  }
11680  arg14 = (PLINT)(val14);
11681  ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
11682  if (!SWIG_IsOK(ecode15)) {
11683  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
11684  }
11685  arg15 = (PLFLT)(val15);
11686  ecode16 = SWIG_AsVal_int(swig_obj[12], &val16);
11687  if (!SWIG_IsOK(ecode16)) {
11688  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
11689  }
11690  arg16 = (PLINT)(val16);
11691  ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
11692  if (!SWIG_IsOK(ecode17)) {
11693  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
11694  }
11695  arg17 = (PLFLT)(val17);
11696  ecode19 = SWIG_AsVal_int(swig_obj[14], &val19);
11697  if (!SWIG_IsOK(ecode19)) {
11698  SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
11699  }
11700  arg19 = (PLBOOL)(val19);
11701  if (swig_obj[15]) {
11702  {
11703  // it must be a callable or None
11704  if ( swig_obj[15] == Py_None )
11705  {
11706  arg20 = NULL;
11707  }
11708  else
11709  {
11710  if ( !PyCallable_Check( (PyObject *) swig_obj[15] ) )
11711  {
11712  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11713  return NULL;
11714  }
11715  arg20 = marshal_pltr( swig_obj[15] );
11716  }
11717  }
11718  }
11719  if (swig_obj[16]) {
11720  {
11721  if ( swig_obj[16] == Py_None )
11722  arg21 = NULL;
11723  else
11724  {
11725  arg21 = marshal_PLPointer( swig_obj[16], 0 );
11726  }
11727  }
11728  }
11729  plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
11730  resultobj = SWIG_Py_Void();
11731  {
11732  Py_CLEAR( tmp1 );
11733  free( arg1 );
11734  }
11735  {
11736  cleanup_pltr();
11737  }
11738  {
11740  }
11741  return resultobj;
11742 fail:
11743  {
11744  Py_CLEAR( tmp1 );
11745  free( arg1 );
11746  }
11747  {
11748  cleanup_pltr();
11749  }
11750  {
11752  }
11753  return NULL;
11754 }
11755 
11756 
11757 SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11758  PyObject *resultobj = 0;
11759  label_func arg1 = (label_func) 0 ;
11760  PLPointer arg2 = (PLPointer) 0 ;
11761  int res2 ;
11762  PyObject *swig_obj[2] ;
11763 
11764  if (!SWIG_Python_UnpackTuple(args, "plslabelfunc", 2, 2, swig_obj)) SWIG_fail;
11765  {
11766  // Release reference to previous function if applicable
11767  if ( python_label )
11768  {
11769  Py_CLEAR( python_label );
11770  python_label = 0;
11771  }
11772  // it must be a callable or None
11773  if ( swig_obj[0] == Py_None )
11774  {
11775  arg1 = NULL;
11776  }
11777  else
11778  {
11779  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
11780  {
11781  PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
11782  return NULL;
11783  }
11784  // hold a reference to it
11785  Py_XINCREF( (PyObject *) swig_obj[0] );
11786  python_label = (PyObject *) swig_obj[0];
11787  // this function handles calling the python function
11788  arg1 = do_label_callback;
11789  }
11790  }
11791  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
11792  if (!SWIG_IsOK(res2)) {
11793  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
11794  }
11795  plslabelfunc(arg1,arg2);
11796  resultobj = SWIG_Py_Void();
11797  return resultobj;
11798 fail:
11799  return NULL;
11800 }
11801 
11802 
11803 SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11804  PyObject *resultobj = 0;
11805  PLFLT arg1 ;
11806  PLFLT arg2 ;
11807  double val1 ;
11808  int ecode1 = 0 ;
11809  double val2 ;
11810  int ecode2 = 0 ;
11811  PyObject *swig_obj[2] ;
11812 
11813  if (!SWIG_Python_UnpackTuple(args, "plsmaj", 2, 2, swig_obj)) SWIG_fail;
11814  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11815  if (!SWIG_IsOK(ecode1)) {
11816  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
11817  }
11818  arg1 = (PLFLT)(val1);
11819  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11820  if (!SWIG_IsOK(ecode2)) {
11821  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
11822  }
11823  arg2 = (PLFLT)(val2);
11824  plsmaj(arg1,arg2);
11825  resultobj = SWIG_Py_Void();
11826  return resultobj;
11827 fail:
11828  return NULL;
11829 }
11830 
11831 
11832 SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11833  PyObject *resultobj = 0;
11834  PLINT arg1 ;
11835  PLINT arg2 ;
11836  void *arg3 = (void *) 0 ;
11837  int val1 ;
11838  int ecode1 = 0 ;
11839  int val2 ;
11840  int ecode2 = 0 ;
11841  PyObject *swig_obj[3] ;
11842 
11843  if (!SWIG_Python_UnpackTuple(args, "plsmem", 3, 3, swig_obj)) SWIG_fail;
11844  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11845  if (!SWIG_IsOK(ecode1)) {
11846  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
11847  }
11848  arg1 = (PLINT)(val1);
11849  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11850  if (!SWIG_IsOK(ecode2)) {
11851  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
11852  }
11853  arg2 = (PLINT)(val2);
11854  {
11855  int res; void *buf = 0;
11856  Py_buffer view;
11857  res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
11858  buf = view.buf;
11859  PyBuffer_Release(&view);
11860  if (res < 0) {
11861  PyErr_Clear();
11862  SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem)""'");
11863  }
11864  arg3 = (void *) buf;
11865  }
11866  plsmem(arg1,arg2,arg3);
11867  resultobj = SWIG_Py_Void();
11868  return resultobj;
11869 fail:
11870  return NULL;
11871 }
11872 
11873 
11874 SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11875  PyObject *resultobj = 0;
11876  PLINT arg1 ;
11877  PLINT arg2 ;
11878  void *arg3 = (void *) 0 ;
11879  int val1 ;
11880  int ecode1 = 0 ;
11881  int val2 ;
11882  int ecode2 = 0 ;
11883  PyObject *swig_obj[3] ;
11884 
11885  if (!SWIG_Python_UnpackTuple(args, "plsmema", 3, 3, swig_obj)) SWIG_fail;
11886  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11887  if (!SWIG_IsOK(ecode1)) {
11888  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
11889  }
11890  arg1 = (PLINT)(val1);
11891  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11892  if (!SWIG_IsOK(ecode2)) {
11893  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
11894  }
11895  arg2 = (PLINT)(val2);
11896  {
11897  int res; void *buf = 0;
11898  Py_buffer view;
11899  res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
11900  buf = view.buf;
11901  PyBuffer_Release(&view);
11902  if (res < 0) {
11903  PyErr_Clear();
11904  SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem)""'");
11905  }
11906  arg3 = (void *) buf;
11907  }
11908  plsmema(arg1,arg2,arg3);
11909  resultobj = SWIG_Py_Void();
11910  return resultobj;
11911 fail:
11912  return NULL;
11913 }
11914 
11915 
11916 SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11917  PyObject *resultobj = 0;
11918  PLFLT arg1 ;
11919  PLFLT arg2 ;
11920  double val1 ;
11921  int ecode1 = 0 ;
11922  double val2 ;
11923  int ecode2 = 0 ;
11924  PyObject *swig_obj[2] ;
11925 
11926  if (!SWIG_Python_UnpackTuple(args, "plsmin", 2, 2, swig_obj)) SWIG_fail;
11927  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11928  if (!SWIG_IsOK(ecode1)) {
11929  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
11930  }
11931  arg1 = (PLFLT)(val1);
11932  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11933  if (!SWIG_IsOK(ecode2)) {
11934  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
11935  }
11936  arg2 = (PLFLT)(val2);
11937  plsmin(arg1,arg2);
11938  resultobj = SWIG_Py_Void();
11939  return resultobj;
11940 fail:
11941  return NULL;
11942 }
11943 
11944 
11945 SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11946  PyObject *resultobj = 0;
11947  PLINT arg1 ;
11948  int val1 ;
11949  int ecode1 = 0 ;
11950  PyObject *swig_obj[1] ;
11951 
11952  if (!args) SWIG_fail;
11953  swig_obj[0] = args;
11954  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11955  if (!SWIG_IsOK(ecode1)) {
11956  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
11957  }
11958  arg1 = (PLINT)(val1);
11959  plsori(arg1);
11960  resultobj = SWIG_Py_Void();
11961  return resultobj;
11962 fail:
11963  return NULL;
11964 }
11965 
11966 
11967 SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11968  PyObject *resultobj = 0;
11969  PLFLT arg1 ;
11970  PLFLT arg2 ;
11971  PLINT arg3 ;
11972  PLINT arg4 ;
11973  PLINT arg5 ;
11974  PLINT arg6 ;
11975  double val1 ;
11976  int ecode1 = 0 ;
11977  double val2 ;
11978  int ecode2 = 0 ;
11979  int val3 ;
11980  int ecode3 = 0 ;
11981  int val4 ;
11982  int ecode4 = 0 ;
11983  int val5 ;
11984  int ecode5 = 0 ;
11985  int val6 ;
11986  int ecode6 = 0 ;
11987  PyObject *swig_obj[6] ;
11988 
11989  if (!SWIG_Python_UnpackTuple(args, "plspage", 6, 6, swig_obj)) SWIG_fail;
11990  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11991  if (!SWIG_IsOK(ecode1)) {
11992  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
11993  }
11994  arg1 = (PLFLT)(val1);
11995  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11996  if (!SWIG_IsOK(ecode2)) {
11997  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
11998  }
11999  arg2 = (PLFLT)(val2);
12000  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12001  if (!SWIG_IsOK(ecode3)) {
12002  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12003  }
12004  arg3 = (PLINT)(val3);
12005  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
12006  if (!SWIG_IsOK(ecode4)) {
12007  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12008  }
12009  arg4 = (PLINT)(val4);
12010  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
12011  if (!SWIG_IsOK(ecode5)) {
12012  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12013  }
12014  arg5 = (PLINT)(val5);
12015  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
12016  if (!SWIG_IsOK(ecode6)) {
12017  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12018  }
12019  arg6 = (PLINT)(val6);
12020  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12021  resultobj = SWIG_Py_Void();
12022  return resultobj;
12023 fail:
12024  return NULL;
12025 }
12026 
12027 
12028 SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12029  PyObject *resultobj = 0;
12030  char *arg1 = (char *) 0 ;
12031  int res1 ;
12032  char *buf1 = 0 ;
12033  int alloc1 = 0 ;
12034  PyObject *swig_obj[1] ;
12035 
12036  if (!args) SWIG_fail;
12037  swig_obj[0] = args;
12038  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12039  if (!SWIG_IsOK(res1)) {
12040  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12041  }
12042  arg1 = (char *)(buf1);
12043  plspal0((char const *)arg1);
12044  resultobj = SWIG_Py_Void();
12045  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12046  return resultobj;
12047 fail:
12048  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12049  return NULL;
12050 }
12051 
12052 
12053 SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12054  PyObject *resultobj = 0;
12055  char *arg1 = (char *) 0 ;
12056  PLBOOL arg2 ;
12057  int res1 ;
12058  char *buf1 = 0 ;
12059  int alloc1 = 0 ;
12060  int val2 ;
12061  int ecode2 = 0 ;
12062  PyObject *swig_obj[2] ;
12063 
12064  if (!SWIG_Python_UnpackTuple(args, "plspal1", 2, 2, swig_obj)) SWIG_fail;
12065  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12066  if (!SWIG_IsOK(res1)) {
12067  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12068  }
12069  arg1 = (char *)(buf1);
12070  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12071  if (!SWIG_IsOK(ecode2)) {
12072  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12073  }
12074  arg2 = (PLBOOL)(val2);
12075  plspal1((char const *)arg1,arg2);
12076  resultobj = SWIG_Py_Void();
12077  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12078  return resultobj;
12079 fail:
12080  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12081  return NULL;
12082 }
12083 
12084 
12085 SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12086  PyObject *resultobj = 0;
12087  PLBOOL arg1 ;
12088  int val1 ;
12089  int ecode1 = 0 ;
12090  PyObject *swig_obj[1] ;
12091 
12092  if (!args) SWIG_fail;
12093  swig_obj[0] = args;
12094  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12095  if (!SWIG_IsOK(ecode1)) {
12096  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12097  }
12098  arg1 = (PLBOOL)(val1);
12099  plspause(arg1);
12100  resultobj = SWIG_Py_Void();
12101  return resultobj;
12102 fail:
12103  return NULL;
12104 }
12105 
12106 
12107 SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12108  PyObject *resultobj = 0;
12109  PLINT arg1 ;
12110  int val1 ;
12111  int ecode1 = 0 ;
12112  PyObject *swig_obj[1] ;
12113 
12114  if (!args) SWIG_fail;
12115  swig_obj[0] = args;
12116  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12117  if (!SWIG_IsOK(ecode1)) {
12118  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12119  }
12120  arg1 = (PLINT)(val1);
12121  plsstrm(arg1);
12122  resultobj = SWIG_Py_Void();
12123  return resultobj;
12124 fail:
12125  return NULL;
12126 }
12127 
12128 
12129 SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12130  PyObject *resultobj = 0;
12131  PLINT arg1 ;
12132  PLINT arg2 ;
12133  int val1 ;
12134  int ecode1 = 0 ;
12135  int val2 ;
12136  int ecode2 = 0 ;
12137  PyObject *swig_obj[2] ;
12138 
12139  if (!SWIG_Python_UnpackTuple(args, "plssub", 2, 2, swig_obj)) SWIG_fail;
12140  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12141  if (!SWIG_IsOK(ecode1)) {
12142  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12143  }
12144  arg1 = (PLINT)(val1);
12145  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12146  if (!SWIG_IsOK(ecode2)) {
12147  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12148  }
12149  arg2 = (PLINT)(val2);
12150  plssub(arg1,arg2);
12151  resultobj = SWIG_Py_Void();
12152  return resultobj;
12153 fail:
12154  return NULL;
12155 }
12156 
12157 
12158 SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12159  PyObject *resultobj = 0;
12160  PLFLT arg1 ;
12161  PLFLT arg2 ;
12162  double val1 ;
12163  int ecode1 = 0 ;
12164  double val2 ;
12165  int ecode2 = 0 ;
12166  PyObject *swig_obj[2] ;
12167 
12168  if (!SWIG_Python_UnpackTuple(args, "plssym", 2, 2, swig_obj)) SWIG_fail;
12169  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12170  if (!SWIG_IsOK(ecode1)) {
12171  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12172  }
12173  arg1 = (PLFLT)(val1);
12174  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12175  if (!SWIG_IsOK(ecode2)) {
12176  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12177  }
12178  arg2 = (PLFLT)(val2);
12179  plssym(arg1,arg2);
12180  resultobj = SWIG_Py_Void();
12181  return resultobj;
12182 fail:
12183  return NULL;
12184 }
12185 
12186 
12187 SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12188  PyObject *resultobj = 0;
12189  PLINT arg1 ;
12190  PLINT arg2 ;
12191  int val1 ;
12192  int ecode1 = 0 ;
12193  int val2 ;
12194  int ecode2 = 0 ;
12195  PyObject *swig_obj[2] ;
12196 
12197  if (!SWIG_Python_UnpackTuple(args, "plstar", 2, 2, swig_obj)) SWIG_fail;
12198  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12199  if (!SWIG_IsOK(ecode1)) {
12200  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12201  }
12202  arg1 = (PLINT)(val1);
12203  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12204  if (!SWIG_IsOK(ecode2)) {
12205  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12206  }
12207  arg2 = (PLINT)(val2);
12208  plstar(arg1,arg2);
12209  resultobj = SWIG_Py_Void();
12210  return resultobj;
12211 fail:
12212  return NULL;
12213 }
12214 
12215 
12216 SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12217  PyObject *resultobj = 0;
12218  char *arg1 = (char *) 0 ;
12219  PLINT arg2 ;
12220  PLINT arg3 ;
12221  int res1 ;
12222  char *buf1 = 0 ;
12223  int alloc1 = 0 ;
12224  int val2 ;
12225  int ecode2 = 0 ;
12226  int val3 ;
12227  int ecode3 = 0 ;
12228  PyObject *swig_obj[3] ;
12229 
12230  if (!SWIG_Python_UnpackTuple(args, "plstart", 3, 3, swig_obj)) SWIG_fail;
12231  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12232  if (!SWIG_IsOK(res1)) {
12233  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12234  }
12235  arg1 = (char *)(buf1);
12236  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12237  if (!SWIG_IsOK(ecode2)) {
12238  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12239  }
12240  arg2 = (PLINT)(val2);
12241  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12242  if (!SWIG_IsOK(ecode3)) {
12243  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12244  }
12245  arg3 = (PLINT)(val3);
12246  plstart((char const *)arg1,arg2,arg3);
12247  resultobj = SWIG_Py_Void();
12248  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12249  return resultobj;
12250 fail:
12251  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12252  return NULL;
12253 }
12254 
12255 
12256 SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12257  PyObject *resultobj = 0;
12258  ct_func arg1 = (ct_func) 0 ;
12259  PLPointer arg2 = (PLPointer) 0 ;
12260  int res2 ;
12261  PyObject *swig_obj[2] ;
12262 
12263  {
12264  python_ct = 0;
12265  arg1 = NULL;
12266  }
12267  if (!SWIG_Python_UnpackTuple(args, "plstransform", 0, 2, swig_obj)) SWIG_fail;
12268  if (swig_obj[0]) {
12269  {
12270  if ( python_ct )
12271  cleanup_ct();
12272  // it must be a callable or none
12273  if ( swig_obj[0] == Py_None )
12274  {
12275  arg1 = NULL;
12276  }
12277  else
12278  {
12279  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12280  {
12281  PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12282  return NULL;
12283  }
12284  arg1 = marshal_ct( swig_obj[0] );
12285  }
12286  }
12287  }
12288  if (swig_obj[1]) {
12289  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12290  if (!SWIG_IsOK(res2)) {
12291  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12292  }
12293  }
12294  plstransform(arg1,arg2);
12295  resultobj = SWIG_Py_Void();
12296  return resultobj;
12297 fail:
12298  return NULL;
12299 }
12300 
12301 
12302 SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12303  PyObject *resultobj = 0;
12304  PLINT arg1 ;
12305  PLFLT *arg2 = (PLFLT *) 0 ;
12306  PLFLT *arg3 = (PLFLT *) 0 ;
12307  char *arg4 = (char *) 0 ;
12308  PyArrayObject *tmp1 = NULL ;
12309  PyArrayObject *tmp3 = NULL ;
12310  int res4 ;
12311  char *buf4 = 0 ;
12312  int alloc4 = 0 ;
12313  PyObject *swig_obj[3] ;
12314 
12315  if (!SWIG_Python_UnpackTuple(args, "plstring", 3, 3, swig_obj)) SWIG_fail;
12316  {
12317  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12318  if ( tmp1 == NULL )
12319  return NULL;
12320  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12321  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12322  }
12323  {
12324  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12325  if ( tmp3 == NULL )
12326  return NULL;
12327  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12328  {
12329  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12330  return NULL;
12331  }
12332  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12333  }
12334  res4 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf4, NULL, &alloc4);
12335  if (!SWIG_IsOK(res4)) {
12336  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12337  }
12338  arg4 = (char *)(buf4);
12339  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12340  resultobj = SWIG_Py_Void();
12341  {
12342  Py_CLEAR( tmp1 );
12343  }
12344  {
12345  Py_CLEAR( tmp3 );
12346  }
12347  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12348  return resultobj;
12349 fail:
12350  {
12351  Py_CLEAR( tmp1 );
12352  }
12353  {
12354  Py_CLEAR( tmp3 );
12355  }
12356  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12357  return NULL;
12358 }
12359 
12360 
12361 SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12362  PyObject *resultobj = 0;
12363  PLINT arg1 ;
12364  PLFLT *arg2 = (PLFLT *) 0 ;
12365  PLFLT *arg3 = (PLFLT *) 0 ;
12366  PLFLT *arg4 = (PLFLT *) 0 ;
12367  char *arg5 = (char *) 0 ;
12368  PyArrayObject *tmp1 = NULL ;
12369  PyArrayObject *tmp3 = NULL ;
12370  PyArrayObject *tmp4 = NULL ;
12371  int res5 ;
12372  char *buf5 = 0 ;
12373  int alloc5 = 0 ;
12374  PyObject *swig_obj[4] ;
12375 
12376  if (!SWIG_Python_UnpackTuple(args, "plstring3", 4, 4, swig_obj)) SWIG_fail;
12377  {
12378  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12379  if ( tmp1 == NULL )
12380  return NULL;
12381  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12382  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12383  }
12384  {
12385  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12386  if ( tmp3 == NULL )
12387  return NULL;
12388  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12389  {
12390  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12391  return NULL;
12392  }
12393  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12394  }
12395  {
12396  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
12397  if ( tmp4 == NULL )
12398  return NULL;
12399  if ( PyArray_DIMS( tmp4 )[0] != Alen )
12400  {
12401  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12402  return NULL;
12403  }
12404  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
12405  }
12406  res5 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf5, NULL, &alloc5);
12407  if (!SWIG_IsOK(res5)) {
12408  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
12409  }
12410  arg5 = (char *)(buf5);
12411  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
12412  resultobj = SWIG_Py_Void();
12413  {
12414  Py_CLEAR( tmp1 );
12415  }
12416  {
12417  Py_CLEAR( tmp3 );
12418  }
12419  {
12420  Py_CLEAR( tmp4 );
12421  }
12422  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12423  return resultobj;
12424 fail:
12425  {
12426  Py_CLEAR( tmp1 );
12427  }
12428  {
12429  Py_CLEAR( tmp3 );
12430  }
12431  {
12432  Py_CLEAR( tmp4 );
12433  }
12434  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12435  return NULL;
12436 }
12437 
12438 
12439 SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12440  PyObject *resultobj = 0;
12441  PLINT arg1 ;
12442  PLINT arg2 ;
12443  PLFLT arg3 ;
12444  PLFLT arg4 ;
12445  int val1 ;
12446  int ecode1 = 0 ;
12447  int val2 ;
12448  int ecode2 = 0 ;
12449  double val3 ;
12450  int ecode3 = 0 ;
12451  double val4 ;
12452  int ecode4 = 0 ;
12453  PyObject *swig_obj[4] ;
12454 
12455  if (!SWIG_Python_UnpackTuple(args, "plstripa", 4, 4, swig_obj)) SWIG_fail;
12456  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12457  if (!SWIG_IsOK(ecode1)) {
12458  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
12459  }
12460  arg1 = (PLINT)(val1);
12461  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12462  if (!SWIG_IsOK(ecode2)) {
12463  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
12464  }
12465  arg2 = (PLINT)(val2);
12466  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
12467  if (!SWIG_IsOK(ecode3)) {
12468  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
12469  }
12470  arg3 = (PLFLT)(val3);
12471  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
12472  if (!SWIG_IsOK(ecode4)) {
12473  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
12474  }
12475  arg4 = (PLFLT)(val4);
12476  plstripa(arg1,arg2,arg3,arg4);
12477  resultobj = SWIG_Py_Void();
12478  return resultobj;
12479 fail:
12480  return NULL;
12481 }
12482 
12483 
12484 SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12485  PyObject *resultobj = 0;
12486  PLINT *arg1 = (PLINT *) 0 ;
12487  char *arg2 = (char *) 0 ;
12488  char *arg3 = (char *) 0 ;
12489  PLFLT arg4 ;
12490  PLFLT arg5 ;
12491  PLFLT arg6 ;
12492  PLFLT arg7 ;
12493  PLFLT arg8 ;
12494  PLFLT arg9 ;
12495  PLFLT arg10 ;
12496  PLBOOL arg11 ;
12497  PLBOOL arg12 ;
12498  PLINT arg13 ;
12499  PLINT arg14 ;
12500  PLINT *arg15 = (PLINT *) 0 ;
12501  PLINT *arg16 = (PLINT *) 0 ;
12502  char **arg17 ;
12503  char *arg18 = (char *) 0 ;
12504  char *arg19 = (char *) 0 ;
12505  char *arg20 = (char *) 0 ;
12506  PLINT temp1 ;
12507  int res1 = SWIG_TMPOBJ ;
12508  int res2 ;
12509  char *buf2 = 0 ;
12510  int alloc2 = 0 ;
12511  int res3 ;
12512  char *buf3 = 0 ;
12513  int alloc3 = 0 ;
12514  double val4 ;
12515  int ecode4 = 0 ;
12516  double val5 ;
12517  int ecode5 = 0 ;
12518  double val6 ;
12519  int ecode6 = 0 ;
12520  double val7 ;
12521  int ecode7 = 0 ;
12522  double val8 ;
12523  int ecode8 = 0 ;
12524  double val9 ;
12525  int ecode9 = 0 ;
12526  double val10 ;
12527  int ecode10 = 0 ;
12528  int val11 ;
12529  int ecode11 = 0 ;
12530  int val12 ;
12531  int ecode12 = 0 ;
12532  int val13 ;
12533  int ecode13 = 0 ;
12534  int val14 ;
12535  int ecode14 = 0 ;
12536  PyArrayObject *tmp15 = NULL ;
12537  PyArrayObject *tmp16 = NULL ;
12538  char **tmp17 = NULL ;
12539  int res18 ;
12540  char *buf18 = 0 ;
12541  int alloc18 = 0 ;
12542  int res19 ;
12543  char *buf19 = 0 ;
12544  int alloc19 = 0 ;
12545  int res20 ;
12546  char *buf20 = 0 ;
12547  int alloc20 = 0 ;
12548  PyObject *swig_obj[19] ;
12549 
12550  arg1 = &temp1;
12551  if (!SWIG_Python_UnpackTuple(args, "plstripc", 19, 19, swig_obj)) SWIG_fail;
12552  res2 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf2, NULL, &alloc2);
12553  if (!SWIG_IsOK(res2)) {
12554  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
12555  }
12556  arg2 = (char *)(buf2);
12557  res3 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf3, NULL, &alloc3);
12558  if (!SWIG_IsOK(res3)) {
12559  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
12560  }
12561  arg3 = (char *)(buf3);
12562  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
12563  if (!SWIG_IsOK(ecode4)) {
12564  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
12565  }
12566  arg4 = (PLFLT)(val4);
12567  ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
12568  if (!SWIG_IsOK(ecode5)) {
12569  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
12570  }
12571  arg5 = (PLFLT)(val5);
12572  ecode6 = SWIG_AsVal_double(swig_obj[4], &val6);
12573  if (!SWIG_IsOK(ecode6)) {
12574  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
12575  }
12576  arg6 = (PLFLT)(val6);
12577  ecode7 = SWIG_AsVal_double(swig_obj[5], &val7);
12578  if (!SWIG_IsOK(ecode7)) {
12579  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
12580  }
12581  arg7 = (PLFLT)(val7);
12582  ecode8 = SWIG_AsVal_double(swig_obj[6], &val8);
12583  if (!SWIG_IsOK(ecode8)) {
12584  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
12585  }
12586  arg8 = (PLFLT)(val8);
12587  ecode9 = SWIG_AsVal_double(swig_obj[7], &val9);
12588  if (!SWIG_IsOK(ecode9)) {
12589  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
12590  }
12591  arg9 = (PLFLT)(val9);
12592  ecode10 = SWIG_AsVal_double(swig_obj[8], &val10);
12593  if (!SWIG_IsOK(ecode10)) {
12594  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
12595  }
12596  arg10 = (PLFLT)(val10);
12597  ecode11 = SWIG_AsVal_int(swig_obj[9], &val11);
12598  if (!SWIG_IsOK(ecode11)) {
12599  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
12600  }
12601  arg11 = (PLBOOL)(val11);
12602  ecode12 = SWIG_AsVal_int(swig_obj[10], &val12);
12603  if (!SWIG_IsOK(ecode12)) {
12604  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
12605  }
12606  arg12 = (PLBOOL)(val12);
12607  ecode13 = SWIG_AsVal_int(swig_obj[11], &val13);
12608  if (!SWIG_IsOK(ecode13)) {
12609  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
12610  }
12611  arg13 = (PLINT)(val13);
12612  ecode14 = SWIG_AsVal_int(swig_obj[12], &val14);
12613  if (!SWIG_IsOK(ecode14)) {
12614  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
12615  }
12616  arg14 = (PLINT)(val14);
12617  {
12618  tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
12619  if ( tmp15 == NULL )
12620  return NULL;
12621  Alen = PyArray_DIMS( tmp15 )[0];
12622  arg15 = (PLINT *) PyArray_DATA( tmp15 );
12623  }
12624  {
12625  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[14], NPY_PLINT, 1, 1 );
12626  if ( tmp16 == NULL )
12627  return NULL;
12628  if ( PyArray_DIMS( tmp16 )[0] != Alen )
12629  {
12630  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12631  return NULL;
12632  }
12633  arg16 = (PLINT *) PyArray_DATA( tmp16 );
12634  }
12635  {
12636  int i;
12637  PyObject *elt, *unicode_string;
12638 
12639  if ( !PySequence_Check( swig_obj[15] ) || PySequence_Size( swig_obj[15] ) != 4 )
12640  {
12641  PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
12642  return NULL;
12643  }
12644  if ( Alen != 4 )
12645  {
12646  PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
12647  return NULL;
12648  }
12649  tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
12650  if ( tmp17 == NULL )
12651  return NULL;
12652  arg17 = tmp17;
12653  for ( i = 0; i < 4; i++ )
12654  {
12655  arg17[i] = NULL;
12656  elt = PySequence_Fast_GET_ITEM( swig_obj[15], i );
12657  if ( PyString_Check( elt ) )
12658  {
12659  arg17[i] = PyString_AsString( elt );
12660  }
12661  else if ( PyUnicode_Check( elt ) )
12662  {
12663  unicode_string = PyUnicode_AsEncodedString( elt, "utf-8", "Error ~" );
12664  arg17[i] = PyBytes_AS_STRING( unicode_string );
12665  }
12666  if ( arg17[i] == NULL )
12667  {
12668  free( tmp17 );
12669  return NULL;
12670  }
12671  }
12672  }
12673  res18 = SWIG_AsCharPtrAndSize(swig_obj[16], &buf18, NULL, &alloc18);
12674  if (!SWIG_IsOK(res18)) {
12675  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
12676  }
12677  arg18 = (char *)(buf18);
12678  res19 = SWIG_AsCharPtrAndSize(swig_obj[17], &buf19, NULL, &alloc19);
12679  if (!SWIG_IsOK(res19)) {
12680  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
12681  }
12682  arg19 = (char *)(buf19);
12683  res20 = SWIG_AsCharPtrAndSize(swig_obj[18], &buf20, NULL, &alloc20);
12684  if (!SWIG_IsOK(res20)) {
12685  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
12686  }
12687  arg20 = (char *)(buf20);
12688  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);
12689  resultobj = SWIG_Py_Void();
12690  if (SWIG_IsTmpObj(res1)) {
12691  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
12692  } else {
12693  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12694  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
12695  }
12696  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12697  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
12698  {
12699  Py_CLEAR( tmp15 );
12700  }
12701  {
12702  Py_CLEAR( tmp16 );
12703  }
12704  {
12705  free( tmp17 );
12706  }
12707  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
12708  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
12709  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
12710  return resultobj;
12711 fail:
12712  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12713  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
12714  {
12715  Py_CLEAR( tmp15 );
12716  }
12717  {
12718  Py_CLEAR( tmp16 );
12719  }
12720  {
12721  free( tmp17 );
12722  }
12723  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
12724  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
12725  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
12726  return NULL;
12727 }
12728 
12729 
12730 SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12731  PyObject *resultobj = 0;
12732  PLINT arg1 ;
12733  int val1 ;
12734  int ecode1 = 0 ;
12735  PyObject *swig_obj[1] ;
12736 
12737  if (!args) SWIG_fail;
12738  swig_obj[0] = args;
12739  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12740  if (!SWIG_IsOK(ecode1)) {
12741  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
12742  }
12743  arg1 = (PLINT)(val1);
12744  plstripd(arg1);
12745  resultobj = SWIG_Py_Void();
12746  return resultobj;
12747 fail:
12748  return NULL;
12749 }
12750 
12751 
12752 SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12753  PyObject *resultobj = 0;
12754  PLINT arg1 ;
12755  PLINT *arg2 = (PLINT *) 0 ;
12756  PLINT *arg3 = (PLINT *) 0 ;
12757  PyArrayObject *tmp1 = NULL ;
12758  PyArrayObject *tmp3 = NULL ;
12759  PyObject *swig_obj[2] ;
12760 
12761  if (!SWIG_Python_UnpackTuple(args, "plstyl", 2, 2, swig_obj)) SWIG_fail;
12762  {
12763  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
12764  if ( tmp1 == NULL )
12765  return NULL;
12766  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12767  arg2 = (PLINT *) PyArray_DATA( tmp1 );
12768  }
12769  {
12770  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
12771  if ( tmp3 == NULL )
12772  return NULL;
12773  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12774  {
12775  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12776  return NULL;
12777  }
12778  arg3 = (PLINT *) PyArray_DATA( tmp3 );
12779  }
12780  plstyl(arg1,(int const *)arg2,(int const *)arg3);
12781  resultobj = SWIG_Py_Void();
12782  {
12783  Py_CLEAR( tmp1 );
12784  }
12785  {
12786  Py_CLEAR( tmp3 );
12787  }
12788  return resultobj;
12789 fail:
12790  {
12791  Py_CLEAR( tmp1 );
12792  }
12793  {
12794  Py_CLEAR( tmp3 );
12795  }
12796  return NULL;
12797 }
12798 
12799 
12800 SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12801  PyObject *resultobj = 0;
12802  PLFLT *arg1 = (PLFLT *) 0 ;
12803  PLFLT *arg2 = (PLFLT *) 0 ;
12804  PLINT arg3 ;
12805  PLBOOL arg4 ;
12806  PyArrayObject *tmp1 = NULL ;
12807  PyArrayObject *tmp2 = NULL ;
12808  int val4 ;
12809  int ecode4 = 0 ;
12810  PyObject *swig_obj[3] ;
12811 
12812  if (!SWIG_Python_UnpackTuple(args, "plsvect", 3, 3, swig_obj)) SWIG_fail;
12813  {
12814  if ( swig_obj[0] != Py_None )
12815  {
12816  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12817  if ( tmp1 == NULL )
12818  return NULL;
12819  Alen = PyArray_DIMS( tmp1 )[0];
12820  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
12821  }
12822  else
12823  {
12824  arg1 = NULL;
12825  Alen = 0;
12826  }
12827  }
12828  {
12829  if ( swig_obj[1] != Py_None )
12830  {
12831  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12832  if ( tmp2 == NULL )
12833  return NULL;
12834  if ( PyArray_DIMS( tmp2 )[0] != Alen )
12835  {
12836  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12837  return NULL;
12838  }
12839  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
12840  arg3 = PyArray_DIMS( tmp2 )[0];
12841  }
12842  else
12843  {
12844  arg2 = NULL;
12845  arg3 = 0;
12846  }
12847  }
12848  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
12849  if (!SWIG_IsOK(ecode4)) {
12850  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
12851  }
12852  arg4 = (PLBOOL)(val4);
12853  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
12854  resultobj = SWIG_Py_Void();
12855  {
12856  Py_CLEAR( tmp1 );
12857  }
12858  {
12859  Py_CLEAR( tmp2 );
12860  }
12861  return resultobj;
12862 fail:
12863  {
12864  Py_CLEAR( tmp1 );
12865  }
12866  {
12867  Py_CLEAR( tmp2 );
12868  }
12869  return NULL;
12870 }
12871 
12872 
12873 SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12874  PyObject *resultobj = 0;
12875  PLFLT arg1 ;
12876  PLFLT arg2 ;
12877  PLFLT arg3 ;
12878  PLFLT arg4 ;
12879  double val1 ;
12880  int ecode1 = 0 ;
12881  double val2 ;
12882  int ecode2 = 0 ;
12883  double val3 ;
12884  int ecode3 = 0 ;
12885  double val4 ;
12886  int ecode4 = 0 ;
12887  PyObject *swig_obj[4] ;
12888 
12889  if (!SWIG_Python_UnpackTuple(args, "plsvpa", 4, 4, swig_obj)) SWIG_fail;
12890  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12891  if (!SWIG_IsOK(ecode1)) {
12892  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
12893  }
12894  arg1 = (PLFLT)(val1);
12895  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12896  if (!SWIG_IsOK(ecode2)) {
12897  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
12898  }
12899  arg2 = (PLFLT)(val2);
12900  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
12901  if (!SWIG_IsOK(ecode3)) {
12902  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
12903  }
12904  arg3 = (PLFLT)(val3);
12905  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
12906  if (!SWIG_IsOK(ecode4)) {
12907  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
12908  }
12909  arg4 = (PLFLT)(val4);
12910  plsvpa(arg1,arg2,arg3,arg4);
12911  resultobj = SWIG_Py_Void();
12912  return resultobj;
12913 fail:
12914  return NULL;
12915 }
12916 
12917 
12918 SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12919  PyObject *resultobj = 0;
12920  PLINT arg1 ;
12921  PLINT arg2 ;
12922  int val1 ;
12923  int ecode1 = 0 ;
12924  int val2 ;
12925  int ecode2 = 0 ;
12926  PyObject *swig_obj[2] ;
12927 
12928  if (!SWIG_Python_UnpackTuple(args, "plsxax", 2, 2, swig_obj)) SWIG_fail;
12929  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12930  if (!SWIG_IsOK(ecode1)) {
12931  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
12932  }
12933  arg1 = (PLINT)(val1);
12934  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12935  if (!SWIG_IsOK(ecode2)) {
12936  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
12937  }
12938  arg2 = (PLINT)(val2);
12939  plsxax(arg1,arg2);
12940  resultobj = SWIG_Py_Void();
12941  return resultobj;
12942 fail:
12943  return NULL;
12944 }
12945 
12946 
12947 SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12948  PyObject *resultobj = 0;
12949  PLINT arg1 ;
12950  PLINT arg2 ;
12951  int val1 ;
12952  int ecode1 = 0 ;
12953  int val2 ;
12954  int ecode2 = 0 ;
12955  PyObject *swig_obj[2] ;
12956 
12957  if (!SWIG_Python_UnpackTuple(args, "plsyax", 2, 2, swig_obj)) SWIG_fail;
12958  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12959  if (!SWIG_IsOK(ecode1)) {
12960  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
12961  }
12962  arg1 = (PLINT)(val1);
12963  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12964  if (!SWIG_IsOK(ecode2)) {
12965  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
12966  }
12967  arg2 = (PLINT)(val2);
12968  plsyax(arg1,arg2);
12969  resultobj = SWIG_Py_Void();
12970  return resultobj;
12971 fail:
12972  return NULL;
12973 }
12974 
12975 
12976 SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12977  PyObject *resultobj = 0;
12978  PLINT arg1 ;
12979  PLFLT *arg2 = (PLFLT *) 0 ;
12980  PLFLT *arg3 = (PLFLT *) 0 ;
12981  PLINT arg4 ;
12982  PyArrayObject *tmp1 = NULL ;
12983  PyArrayObject *tmp3 = NULL ;
12984  int val4 ;
12985  int ecode4 = 0 ;
12986  PyObject *swig_obj[3] ;
12987 
12988  if (!SWIG_Python_UnpackTuple(args, "plsym", 3, 3, swig_obj)) SWIG_fail;
12989  {
12990  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12991  if ( tmp1 == NULL )
12992  return NULL;
12993  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12994  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12995  }
12996  {
12997  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12998  if ( tmp3 == NULL )
12999  return NULL;
13000  if ( PyArray_DIMS( tmp3 )[0] != Alen )
13001  {
13002  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13003  return NULL;
13004  }
13005  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13006  }
13007  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13008  if (!SWIG_IsOK(ecode4)) {
13009  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13010  }
13011  arg4 = (PLINT)(val4);
13012  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13013  resultobj = SWIG_Py_Void();
13014  {
13015  Py_CLEAR( tmp1 );
13016  }
13017  {
13018  Py_CLEAR( tmp3 );
13019  }
13020  return resultobj;
13021 fail:
13022  {
13023  Py_CLEAR( tmp1 );
13024  }
13025  {
13026  Py_CLEAR( tmp3 );
13027  }
13028  return NULL;
13029 }
13030 
13031 
13032 SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13033  PyObject *resultobj = 0;
13034  PLINT arg1 ;
13035  PLINT arg2 ;
13036  int val1 ;
13037  int ecode1 = 0 ;
13038  int val2 ;
13039  int ecode2 = 0 ;
13040  PyObject *swig_obj[2] ;
13041 
13042  if (!SWIG_Python_UnpackTuple(args, "plszax", 2, 2, swig_obj)) SWIG_fail;
13043  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13044  if (!SWIG_IsOK(ecode1)) {
13045  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13046  }
13047  arg1 = (PLINT)(val1);
13048  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13049  if (!SWIG_IsOK(ecode2)) {
13050  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13051  }
13052  arg2 = (PLINT)(val2);
13053  plszax(arg1,arg2);
13054  resultobj = SWIG_Py_Void();
13055  return resultobj;
13056 fail:
13057  return NULL;
13058 }
13059 
13060 
13061 SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13062  PyObject *resultobj = 0;
13063 
13064  if (!SWIG_Python_UnpackTuple(args, "pltext", 0, 0, 0)) SWIG_fail;
13065  pltext();
13066  resultobj = SWIG_Py_Void();
13067  return resultobj;
13068 fail:
13069  return NULL;
13070 }
13071 
13072 
13073 SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13074  PyObject *resultobj = 0;
13075  char *arg1 = (char *) 0 ;
13076  int res1 ;
13077  char *buf1 = 0 ;
13078  int alloc1 = 0 ;
13079  PyObject *swig_obj[1] ;
13080 
13081  if (!args) SWIG_fail;
13082  swig_obj[0] = args;
13083  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
13084  if (!SWIG_IsOK(res1)) {
13085  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13086  }
13087  arg1 = (char *)(buf1);
13088  pltimefmt((char const *)arg1);
13089  resultobj = SWIG_Py_Void();
13090  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13091  return resultobj;
13092 fail:
13093  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13094  return NULL;
13095 }
13096 
13097 
13098 SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13099  PyObject *resultobj = 0;
13100  PLFLT arg1 ;
13101  double val1 ;
13102  int ecode1 = 0 ;
13103  PyObject *swig_obj[1] ;
13104 
13105  if (!args) SWIG_fail;
13106  swig_obj[0] = args;
13107  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13108  if (!SWIG_IsOK(ecode1)) {
13109  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13110  }
13111  arg1 = (PLFLT)(val1);
13112  plvasp(arg1);
13113  resultobj = SWIG_Py_Void();
13114  return resultobj;
13115 fail:
13116  return NULL;
13117 }
13118 
13119 
13120 SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13121  PyObject *resultobj = 0;
13122  PLFLT **arg1 = (PLFLT **) 0 ;
13123  PLFLT **arg2 = (PLFLT **) 0 ;
13124  PLINT arg3 ;
13125  PLINT arg4 ;
13126  PLFLT arg5 ;
13127  pltr_func arg6 = (pltr_func) 0 ;
13128  PLPointer arg7 = (PLPointer) 0 ;
13129  PyArrayObject *tmp1 = NULL ;
13130  PyArrayObject *tmp2 = NULL ;
13131  double val5 ;
13132  int ecode5 = 0 ;
13133  PyObject *swig_obj[5] ;
13134 
13135  {
13136  python_pltr = 0;
13137  arg6 = NULL;
13138  }
13139  {
13140  arg7 = NULL;
13141  }
13142  if (!SWIG_Python_UnpackTuple(args, "plvect", 3, 5, swig_obj)) SWIG_fail;
13143  {
13144  int i, size;
13145  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
13146  if ( tmp1 == NULL )
13147  return NULL;
13148  Xlen = PyArray_DIMS( tmp1 )[0];
13149  Ylen = PyArray_DIMS( tmp1 )[1];
13150  size = Ylen;
13151  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13152  for ( i = 0; i < Xlen; i++ )
13153  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13154  }
13155  {
13156  int i, size;
13157  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 2, 2 );
13158  if ( tmp2 == NULL )
13159  return NULL;
13160  if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13161  {
13162  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13163  return NULL;
13164  }
13165  arg3 = PyArray_DIMS( tmp2 )[0];
13166  arg4 = PyArray_DIMS( tmp2 )[1];
13167  size = arg4;
13168  arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13169  for ( i = 0; i < arg3; i++ )
13170  arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13171  }
13172  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
13173  if (!SWIG_IsOK(ecode5)) {
13174  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13175  }
13176  arg5 = (PLFLT)(val5);
13177  if (swig_obj[3]) {
13178  {
13179  // it must be a callable or None
13180  if ( swig_obj[3] == Py_None )
13181  {
13182  arg6 = NULL;
13183  }
13184  else
13185  {
13186  if ( !PyCallable_Check( (PyObject *) swig_obj[3] ) )
13187  {
13188  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13189  return NULL;
13190  }
13191  arg6 = marshal_pltr( swig_obj[3] );
13192  }
13193  }
13194  }
13195  if (swig_obj[4]) {
13196  {
13197  if ( swig_obj[4] == Py_None )
13198  arg7 = NULL;
13199  else
13200  {
13201  arg7 = marshal_PLPointer( swig_obj[4], 0 );
13202  }
13203  }
13204  }
13205  plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13206  resultobj = SWIG_Py_Void();
13207  {
13208  Py_CLEAR( tmp1 );
13209  free( arg1 );
13210  }
13211  {
13212  Py_CLEAR( tmp2 );
13213  free( arg2 );
13214  }
13215  {
13216  cleanup_pltr();
13217  }
13218  {
13220  }
13221  return resultobj;
13222 fail:
13223  {
13224  Py_CLEAR( tmp1 );
13225  free( arg1 );
13226  }
13227  {
13228  Py_CLEAR( tmp2 );
13229  free( arg2 );
13230  }
13231  {
13232  cleanup_pltr();
13233  }
13234  {
13236  }
13237  return NULL;
13238 }
13239 
13240 
13241 SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13242  PyObject *resultobj = 0;
13243  PLFLT arg1 ;
13244  PLFLT arg2 ;
13245  PLFLT arg3 ;
13246  PLFLT arg4 ;
13247  PLFLT arg5 ;
13248  double val1 ;
13249  int ecode1 = 0 ;
13250  double val2 ;
13251  int ecode2 = 0 ;
13252  double val3 ;
13253  int ecode3 = 0 ;
13254  double val4 ;
13255  int ecode4 = 0 ;
13256  double val5 ;
13257  int ecode5 = 0 ;
13258  PyObject *swig_obj[5] ;
13259 
13260  if (!SWIG_Python_UnpackTuple(args, "plvpas", 5, 5, swig_obj)) SWIG_fail;
13261  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13262  if (!SWIG_IsOK(ecode1)) {
13263  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13264  }
13265  arg1 = (PLFLT)(val1);
13266  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13267  if (!SWIG_IsOK(ecode2)) {
13268  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13269  }
13270  arg2 = (PLFLT)(val2);
13271  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13272  if (!SWIG_IsOK(ecode3)) {
13273  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13274  }
13275  arg3 = (PLFLT)(val3);
13276  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13277  if (!SWIG_IsOK(ecode4)) {
13278  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13279  }
13280  arg4 = (PLFLT)(val4);
13281  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13282  if (!SWIG_IsOK(ecode5)) {
13283  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13284  }
13285  arg5 = (PLFLT)(val5);
13286  plvpas(arg1,arg2,arg3,arg4,arg5);
13287  resultobj = SWIG_Py_Void();
13288  return resultobj;
13289 fail:
13290  return NULL;
13291 }
13292 
13293 
13294 SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13295  PyObject *resultobj = 0;
13296  PLFLT arg1 ;
13297  PLFLT arg2 ;
13298  PLFLT arg3 ;
13299  PLFLT arg4 ;
13300  double val1 ;
13301  int ecode1 = 0 ;
13302  double val2 ;
13303  int ecode2 = 0 ;
13304  double val3 ;
13305  int ecode3 = 0 ;
13306  double val4 ;
13307  int ecode4 = 0 ;
13308  PyObject *swig_obj[4] ;
13309 
13310  if (!SWIG_Python_UnpackTuple(args, "plvpor", 4, 4, swig_obj)) SWIG_fail;
13311  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13312  if (!SWIG_IsOK(ecode1)) {
13313  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13314  }
13315  arg1 = (PLFLT)(val1);
13316  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13317  if (!SWIG_IsOK(ecode2)) {
13318  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13319  }
13320  arg2 = (PLFLT)(val2);
13321  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13322  if (!SWIG_IsOK(ecode3)) {
13323  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
13324  }
13325  arg3 = (PLFLT)(val3);
13326  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13327  if (!SWIG_IsOK(ecode4)) {
13328  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
13329  }
13330  arg4 = (PLFLT)(val4);
13331  plvpor(arg1,arg2,arg3,arg4);
13332  resultobj = SWIG_Py_Void();
13333  return resultobj;
13334 fail:
13335  return NULL;
13336 }
13337 
13338 
13339 SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13340  PyObject *resultobj = 0;
13341 
13342  if (!SWIG_Python_UnpackTuple(args, "plvsta", 0, 0, 0)) SWIG_fail;
13343  plvsta();
13344  resultobj = SWIG_Py_Void();
13345  return resultobj;
13346 fail:
13347  return NULL;
13348 }
13349 
13350 
13351 SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13352  PyObject *resultobj = 0;
13353  PLFLT arg1 ;
13354  PLFLT arg2 ;
13355  PLFLT arg3 ;
13356  PLFLT arg4 ;
13357  PLFLT arg5 ;
13358  PLFLT arg6 ;
13359  PLFLT arg7 ;
13360  PLFLT arg8 ;
13361  PLFLT arg9 ;
13362  PLFLT arg10 ;
13363  PLFLT arg11 ;
13364  double val1 ;
13365  int ecode1 = 0 ;
13366  double val2 ;
13367  int ecode2 = 0 ;
13368  double val3 ;
13369  int ecode3 = 0 ;
13370  double val4 ;
13371  int ecode4 = 0 ;
13372  double val5 ;
13373  int ecode5 = 0 ;
13374  double val6 ;
13375  int ecode6 = 0 ;
13376  double val7 ;
13377  int ecode7 = 0 ;
13378  double val8 ;
13379  int ecode8 = 0 ;
13380  double val9 ;
13381  int ecode9 = 0 ;
13382  double val10 ;
13383  int ecode10 = 0 ;
13384  double val11 ;
13385  int ecode11 = 0 ;
13386  PyObject *swig_obj[11] ;
13387 
13388  if (!SWIG_Python_UnpackTuple(args, "plw3d", 11, 11, swig_obj)) SWIG_fail;
13389  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13390  if (!SWIG_IsOK(ecode1)) {
13391  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
13392  }
13393  arg1 = (PLFLT)(val1);
13394  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13395  if (!SWIG_IsOK(ecode2)) {
13396  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
13397  }
13398  arg2 = (PLFLT)(val2);
13399  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13400  if (!SWIG_IsOK(ecode3)) {
13401  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
13402  }
13403  arg3 = (PLFLT)(val3);
13404  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13405  if (!SWIG_IsOK(ecode4)) {
13406  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
13407  }
13408  arg4 = (PLFLT)(val4);
13409  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13410  if (!SWIG_IsOK(ecode5)) {
13411  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
13412  }
13413  arg5 = (PLFLT)(val5);
13414  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13415  if (!SWIG_IsOK(ecode6)) {
13416  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
13417  }
13418  arg6 = (PLFLT)(val6);
13419  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
13420  if (!SWIG_IsOK(ecode7)) {
13421  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
13422  }
13423  arg7 = (PLFLT)(val7);
13424  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
13425  if (!SWIG_IsOK(ecode8)) {
13426  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
13427  }
13428  arg8 = (PLFLT)(val8);
13429  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
13430  if (!SWIG_IsOK(ecode9)) {
13431  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
13432  }
13433  arg9 = (PLFLT)(val9);
13434  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
13435  if (!SWIG_IsOK(ecode10)) {
13436  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
13437  }
13438  arg10 = (PLFLT)(val10);
13439  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
13440  if (!SWIG_IsOK(ecode11)) {
13441  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
13442  }
13443  arg11 = (PLFLT)(val11);
13444  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13445  resultobj = SWIG_Py_Void();
13446  return resultobj;
13447 fail:
13448  return NULL;
13449 }
13450 
13451 
13452 SWIGINTERN PyObject *_wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13453  PyObject *resultobj = 0;
13454  PLFLT arg1 ;
13455  double val1 ;
13456  int ecode1 = 0 ;
13457  PyObject *swig_obj[1] ;
13458 
13459  if (!args) SWIG_fail;
13460  swig_obj[0] = args;
13461  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13462  if (!SWIG_IsOK(ecode1)) {
13463  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
13464  }
13465  arg1 = (PLFLT)(val1);
13466  plwidth(arg1);
13467  resultobj = SWIG_Py_Void();
13468  return resultobj;
13469 fail:
13470  return NULL;
13471 }
13472 
13473 
13474 SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13475  PyObject *resultobj = 0;
13476  PLFLT arg1 ;
13477  PLFLT arg2 ;
13478  PLFLT arg3 ;
13479  PLFLT arg4 ;
13480  double val1 ;
13481  int ecode1 = 0 ;
13482  double val2 ;
13483  int ecode2 = 0 ;
13484  double val3 ;
13485  int ecode3 = 0 ;
13486  double val4 ;
13487  int ecode4 = 0 ;
13488  PyObject *swig_obj[4] ;
13489 
13490  if (!SWIG_Python_UnpackTuple(args, "plwind", 4, 4, swig_obj)) SWIG_fail;
13491  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13492  if (!SWIG_IsOK(ecode1)) {
13493  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
13494  }
13495  arg1 = (PLFLT)(val1);
13496  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13497  if (!SWIG_IsOK(ecode2)) {
13498  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
13499  }
13500  arg2 = (PLFLT)(val2);
13501  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13502  if (!SWIG_IsOK(ecode3)) {
13503  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
13504  }
13505  arg3 = (PLFLT)(val3);
13506  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13507  if (!SWIG_IsOK(ecode4)) {
13508  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
13509  }
13510  arg4 = (PLFLT)(val4);
13511  plwind(arg1,arg2,arg3,arg4);
13512  resultobj = SWIG_Py_Void();
13513  return resultobj;
13514 fail:
13515  return NULL;
13516 }
13517 
13518 
13519 SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13520  PyObject *resultobj = 0;
13521  PLBOOL arg1 ;
13522  PLBOOL *arg2 = (PLBOOL *) 0 ;
13523  int val1 ;
13524  int ecode1 = 0 ;
13525  PLBOOL temp2 ;
13526  int res2 = SWIG_TMPOBJ ;
13527  PyObject *swig_obj[1] ;
13528 
13529  arg2 = &temp2;
13530  if (!args) SWIG_fail;
13531  swig_obj[0] = args;
13532  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13533  if (!SWIG_IsOK(ecode1)) {
13534  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
13535  }
13536  arg1 = (PLBOOL)(val1);
13537  plxormod(arg1,arg2);
13538  resultobj = SWIG_Py_Void();
13539  if (SWIG_IsTmpObj(res2)) {
13540  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13541  } else {
13542  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13543  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13544  }
13545  return resultobj;
13546 fail:
13547  return NULL;
13548 }
13549 
13550 
13551 SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13552  PyObject *resultobj = 0;
13553  mapform_func arg1 = (mapform_func) 0 ;
13554  char *arg2 = (char *) 0 ;
13555  PLFLT arg3 ;
13556  PLFLT arg4 ;
13557  PLFLT arg5 ;
13558  PLFLT arg6 ;
13559  int res2 ;
13560  char *buf2 = 0 ;
13561  int alloc2 = 0 ;
13562  double val3 ;
13563  int ecode3 = 0 ;
13564  double val4 ;
13565  int ecode4 = 0 ;
13566  double val5 ;
13567  int ecode5 = 0 ;
13568  double val6 ;
13569  int ecode6 = 0 ;
13570  PyObject *swig_obj[6] ;
13571 
13572  if (!SWIG_Python_UnpackTuple(args, "plmap", 6, 6, swig_obj)) SWIG_fail;
13573  {
13574  // it must be a callable or none
13575  if ( swig_obj[0] == Py_None )
13576  {
13577  arg1 = NULL;
13578  }
13579  else
13580  {
13581  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13582  {
13583  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13584  return NULL;
13585  }
13586  arg1 = marshal_mapform( swig_obj[0] );
13587  }
13588  }
13589  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13590  if (!SWIG_IsOK(res2)) {
13591  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
13592  }
13593  arg2 = (char *)(buf2);
13594  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13595  if (!SWIG_IsOK(ecode3)) {
13596  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
13597  }
13598  arg3 = (PLFLT)(val3);
13599  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13600  if (!SWIG_IsOK(ecode4)) {
13601  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
13602  }
13603  arg4 = (PLFLT)(val4);
13604  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13605  if (!SWIG_IsOK(ecode5)) {
13606  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
13607  }
13608  arg5 = (PLFLT)(val5);
13609  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13610  if (!SWIG_IsOK(ecode6)) {
13611  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
13612  }
13613  arg6 = (PLFLT)(val6);
13614  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
13615  resultobj = SWIG_Py_Void();
13616  {
13617  cleanup_mapform();
13618  }
13619  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13620  return resultobj;
13621 fail:
13622  {
13623  cleanup_mapform();
13624  }
13625  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13626  return NULL;
13627 }
13628 
13629 
13630 SWIGINTERN PyObject *_wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13631  PyObject *resultobj = 0;
13632  mapform_func arg1 = (mapform_func) 0 ;
13633  char *arg2 = (char *) 0 ;
13634  PLFLT arg3 ;
13635  PLFLT arg4 ;
13636  PLFLT arg5 ;
13637  PLFLT arg6 ;
13638  PLINT *arg7 = (PLINT *) 0 ;
13639  PLINT arg8 ;
13640  int res2 ;
13641  char *buf2 = 0 ;
13642  int alloc2 = 0 ;
13643  double val3 ;
13644  int ecode3 = 0 ;
13645  double val4 ;
13646  int ecode4 = 0 ;
13647  double val5 ;
13648  int ecode5 = 0 ;
13649  double val6 ;
13650  int ecode6 = 0 ;
13651  PyArrayObject *tmp7 = NULL ;
13652  PyObject *swig_obj[7] ;
13653 
13654  if (!SWIG_Python_UnpackTuple(args, "plmapline", 7, 7, swig_obj)) SWIG_fail;
13655  {
13656  // it must be a callable or none
13657  if ( swig_obj[0] == Py_None )
13658  {
13659  arg1 = NULL;
13660  }
13661  else
13662  {
13663  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13664  {
13665  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13666  return NULL;
13667  }
13668  arg1 = marshal_mapform( swig_obj[0] );
13669  }
13670  }
13671  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13672  if (!SWIG_IsOK(res2)) {
13673  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
13674  }
13675  arg2 = (char *)(buf2);
13676  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13677  if (!SWIG_IsOK(ecode3)) {
13678  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
13679  }
13680  arg3 = (PLFLT)(val3);
13681  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13682  if (!SWIG_IsOK(ecode4)) {
13683  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
13684  }
13685  arg4 = (PLFLT)(val4);
13686  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13687  if (!SWIG_IsOK(ecode5)) {
13688  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
13689  }
13690  arg5 = (PLFLT)(val5);
13691  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13692  if (!SWIG_IsOK(ecode6)) {
13693  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
13694  }
13695  arg6 = (PLFLT)(val6);
13696  {
13697  if ( swig_obj[6] != Py_None )
13698  {
13699  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
13700  if ( tmp7 == NULL )
13701  return NULL;
13702  arg7 = (PLINT *) PyArray_DATA( tmp7 );
13703  arg8 = PyArray_DIMS( tmp7 )[0];
13704  }
13705  else
13706  {
13707  arg7 = NULL;
13708  arg8 = 0;
13709  }
13710  }
13711  plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
13712  resultobj = SWIG_Py_Void();
13713  {
13714  cleanup_mapform();
13715  }
13716  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13717  {
13718  Py_CLEAR( tmp7 );
13719  }
13720  return resultobj;
13721 fail:
13722  {
13723  cleanup_mapform();
13724  }
13725  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13726  {
13727  Py_CLEAR( tmp7 );
13728  }
13729  return NULL;
13730 }
13731 
13732 
13733 SWIGINTERN PyObject *_wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13734  PyObject *resultobj = 0;
13735  mapform_func arg1 = (mapform_func) 0 ;
13736  char *arg2 = (char *) 0 ;
13737  char *arg3 = (char *) 0 ;
13738  PLFLT arg4 ;
13739  PLFLT arg5 ;
13740  PLFLT arg6 ;
13741  PLFLT arg7 ;
13742  PLINT *arg8 = (PLINT *) 0 ;
13743  PLINT arg9 ;
13744  int res2 ;
13745  char *buf2 = 0 ;
13746  int alloc2 = 0 ;
13747  int res3 ;
13748  char *buf3 = 0 ;
13749  int alloc3 = 0 ;
13750  double val4 ;
13751  int ecode4 = 0 ;
13752  double val5 ;
13753  int ecode5 = 0 ;
13754  double val6 ;
13755  int ecode6 = 0 ;
13756  double val7 ;
13757  int ecode7 = 0 ;
13758  PyArrayObject *tmp8 = NULL ;
13759  PyObject *swig_obj[8] ;
13760 
13761  if (!SWIG_Python_UnpackTuple(args, "plmapstring", 8, 8, swig_obj)) SWIG_fail;
13762  {
13763  // it must be a callable or none
13764  if ( swig_obj[0] == Py_None )
13765  {
13766  arg1 = NULL;
13767  }
13768  else
13769  {
13770  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13771  {
13772  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13773  return NULL;
13774  }
13775  arg1 = marshal_mapform( swig_obj[0] );
13776  }
13777  }
13778  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13779  if (!SWIG_IsOK(res2)) {
13780  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
13781  }
13782  arg2 = (char *)(buf2);
13783  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
13784  if (!SWIG_IsOK(res3)) {
13785  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
13786  }
13787  arg3 = (char *)(buf3);
13788  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13789  if (!SWIG_IsOK(ecode4)) {
13790  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
13791  }
13792  arg4 = (PLFLT)(val4);
13793  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13794  if (!SWIG_IsOK(ecode5)) {
13795  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
13796  }
13797  arg5 = (PLFLT)(val5);
13798  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13799  if (!SWIG_IsOK(ecode6)) {
13800  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
13801  }
13802  arg6 = (PLFLT)(val6);
13803  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
13804  if (!SWIG_IsOK(ecode7)) {
13805  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
13806  }
13807  arg7 = (PLFLT)(val7);
13808  {
13809  if ( swig_obj[7] != Py_None )
13810  {
13811  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
13812  if ( tmp8 == NULL )
13813  return NULL;
13814  arg8 = (PLINT *) PyArray_DATA( tmp8 );
13815  arg9 = PyArray_DIMS( tmp8 )[0];
13816  }
13817  else
13818  {
13819  arg8 = NULL;
13820  arg9 = 0;
13821  }
13822  }
13823  plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
13824  resultobj = SWIG_Py_Void();
13825  {
13826  cleanup_mapform();
13827  }
13828  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13829  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13830  {
13831  Py_CLEAR( tmp8 );
13832  }
13833  return resultobj;
13834 fail:
13835  {
13836  cleanup_mapform();
13837  }
13838  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13839  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13840  {
13841  Py_CLEAR( tmp8 );
13842  }
13843  return NULL;
13844 }
13845 
13846 
13847 SWIGINTERN PyObject *_wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13848  PyObject *resultobj = 0;
13849  mapform_func arg1 = (mapform_func) 0 ;
13850  char *arg2 = (char *) 0 ;
13851  PLFLT arg3 ;
13852  PLFLT arg4 ;
13853  PLFLT arg5 ;
13854  char *arg6 = (char *) 0 ;
13855  PLFLT arg7 ;
13856  PLFLT arg8 ;
13857  PLFLT arg9 ;
13858  PLFLT arg10 ;
13859  PLINT arg11 ;
13860  int res2 ;
13861  char *buf2 = 0 ;
13862  int alloc2 = 0 ;
13863  double val3 ;
13864  int ecode3 = 0 ;
13865  double val4 ;
13866  int ecode4 = 0 ;
13867  double val5 ;
13868  int ecode5 = 0 ;
13869  int res6 ;
13870  char *buf6 = 0 ;
13871  int alloc6 = 0 ;
13872  double val7 ;
13873  int ecode7 = 0 ;
13874  double val8 ;
13875  int ecode8 = 0 ;
13876  double val9 ;
13877  int ecode9 = 0 ;
13878  double val10 ;
13879  int ecode10 = 0 ;
13880  int val11 ;
13881  int ecode11 = 0 ;
13882  PyObject *swig_obj[11] ;
13883 
13884  if (!SWIG_Python_UnpackTuple(args, "plmaptex", 11, 11, swig_obj)) SWIG_fail;
13885  {
13886  // it must be a callable or none
13887  if ( swig_obj[0] == Py_None )
13888  {
13889  arg1 = NULL;
13890  }
13891  else
13892  {
13893  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13894  {
13895  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13896  return NULL;
13897  }
13898  arg1 = marshal_mapform( swig_obj[0] );
13899  }
13900  }
13901  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13902  if (!SWIG_IsOK(res2)) {
13903  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
13904  }
13905  arg2 = (char *)(buf2);
13906  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13907  if (!SWIG_IsOK(ecode3)) {
13908  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
13909  }
13910  arg3 = (PLFLT)(val3);
13911  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13912  if (!SWIG_IsOK(ecode4)) {
13913  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
13914  }
13915  arg4 = (PLFLT)(val4);
13916  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13917  if (!SWIG_IsOK(ecode5)) {
13918  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
13919  }
13920  arg5 = (PLFLT)(val5);
13921  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
13922  if (!SWIG_IsOK(res6)) {
13923  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
13924  }
13925  arg6 = (char *)(buf6);
13926  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
13927  if (!SWIG_IsOK(ecode7)) {
13928  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
13929  }
13930  arg7 = (PLFLT)(val7);
13931  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
13932  if (!SWIG_IsOK(ecode8)) {
13933  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
13934  }
13935  arg8 = (PLFLT)(val8);
13936  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
13937  if (!SWIG_IsOK(ecode9)) {
13938  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
13939  }
13940  arg9 = (PLFLT)(val9);
13941  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
13942  if (!SWIG_IsOK(ecode10)) {
13943  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
13944  }
13945  arg10 = (PLFLT)(val10);
13946  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
13947  if (!SWIG_IsOK(ecode11)) {
13948  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
13949  }
13950  arg11 = (PLINT)(val11);
13951  plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
13952  resultobj = SWIG_Py_Void();
13953  {
13954  cleanup_mapform();
13955  }
13956  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13957  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
13958  return resultobj;
13959 fail:
13960  {
13961  cleanup_mapform();
13962  }
13963  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13964  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
13965  return NULL;
13966 }
13967 
13968 
13969 SWIGINTERN PyObject *_wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13970  PyObject *resultobj = 0;
13971  mapform_func arg1 = (mapform_func) 0 ;
13972  char *arg2 = (char *) 0 ;
13973  PLFLT arg3 ;
13974  PLFLT arg4 ;
13975  PLFLT arg5 ;
13976  PLFLT arg6 ;
13977  PLINT *arg7 = (PLINT *) 0 ;
13978  PLINT arg8 ;
13979  int res2 ;
13980  char *buf2 = 0 ;
13981  int alloc2 = 0 ;
13982  double val3 ;
13983  int ecode3 = 0 ;
13984  double val4 ;
13985  int ecode4 = 0 ;
13986  double val5 ;
13987  int ecode5 = 0 ;
13988  double val6 ;
13989  int ecode6 = 0 ;
13990  PyArrayObject *tmp7 = NULL ;
13991  PyObject *swig_obj[7] ;
13992 
13993  if (!SWIG_Python_UnpackTuple(args, "plmapfill", 7, 7, swig_obj)) SWIG_fail;
13994  {
13995  // it must be a callable or none
13996  if ( swig_obj[0] == Py_None )
13997  {
13998  arg1 = NULL;
13999  }
14000  else
14001  {
14002  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14003  {
14004  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14005  return NULL;
14006  }
14007  arg1 = marshal_mapform( swig_obj[0] );
14008  }
14009  }
14010  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14011  if (!SWIG_IsOK(res2)) {
14012  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14013  }
14014  arg2 = (char *)(buf2);
14015  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14016  if (!SWIG_IsOK(ecode3)) {
14017  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14018  }
14019  arg3 = (PLFLT)(val3);
14020  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14021  if (!SWIG_IsOK(ecode4)) {
14022  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14023  }
14024  arg4 = (PLFLT)(val4);
14025  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14026  if (!SWIG_IsOK(ecode5)) {
14027  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14028  }
14029  arg5 = (PLFLT)(val5);
14030  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14031  if (!SWIG_IsOK(ecode6)) {
14032  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14033  }
14034  arg6 = (PLFLT)(val6);
14035  {
14036  if ( swig_obj[6] != Py_None )
14037  {
14038  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14039  if ( tmp7 == NULL )
14040  return NULL;
14041  arg7 = (PLINT *) PyArray_DATA( tmp7 );
14042  arg8 = PyArray_DIMS( tmp7 )[0];
14043  }
14044  else
14045  {
14046  arg7 = NULL;
14047  arg8 = 0;
14048  }
14049  }
14050  plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14051  resultobj = SWIG_Py_Void();
14052  {
14053  cleanup_mapform();
14054  }
14055  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14056  {
14057  Py_CLEAR( tmp7 );
14058  }
14059  return resultobj;
14060 fail:
14061  {
14062  cleanup_mapform();
14063  }
14064  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14065  {
14066  Py_CLEAR( tmp7 );
14067  }
14068  return NULL;
14069 }
14070 
14071 
14072 SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14073  PyObject *resultobj = 0;
14074  mapform_func arg1 = (mapform_func) 0 ;
14075  PLFLT arg2 ;
14076  PLFLT arg3 ;
14077  PLFLT arg4 ;
14078  PLFLT arg5 ;
14079  PLFLT arg6 ;
14080  PLFLT arg7 ;
14081  double val2 ;
14082  int ecode2 = 0 ;
14083  double val3 ;
14084  int ecode3 = 0 ;
14085  double val4 ;
14086  int ecode4 = 0 ;
14087  double val5 ;
14088  int ecode5 = 0 ;
14089  double val6 ;
14090  int ecode6 = 0 ;
14091  double val7 ;
14092  int ecode7 = 0 ;
14093  PyObject *swig_obj[7] ;
14094 
14095  if (!SWIG_Python_UnpackTuple(args, "plmeridians", 7, 7, swig_obj)) SWIG_fail;
14096  {
14097  // it must be a callable or none
14098  if ( swig_obj[0] == Py_None )
14099  {
14100  arg1 = NULL;
14101  }
14102  else
14103  {
14104  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14105  {
14106  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14107  return NULL;
14108  }
14109  arg1 = marshal_mapform( swig_obj[0] );
14110  }
14111  }
14112  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14113  if (!SWIG_IsOK(ecode2)) {
14114  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14115  }
14116  arg2 = (PLFLT)(val2);
14117  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14118  if (!SWIG_IsOK(ecode3)) {
14119  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14120  }
14121  arg3 = (PLFLT)(val3);
14122  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14123  if (!SWIG_IsOK(ecode4)) {
14124  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14125  }
14126  arg4 = (PLFLT)(val4);
14127  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14128  if (!SWIG_IsOK(ecode5)) {
14129  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14130  }
14131  arg5 = (PLFLT)(val5);
14132  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14133  if (!SWIG_IsOK(ecode6)) {
14134  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14135  }
14136  arg6 = (PLFLT)(val6);
14137  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14138  if (!SWIG_IsOK(ecode7)) {
14139  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14140  }
14141  arg7 = (PLFLT)(val7);
14142  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14143  resultobj = SWIG_Py_Void();
14144  {
14145  cleanup_mapform();
14146  }
14147  return resultobj;
14148 fail:
14149  {
14150  cleanup_mapform();
14151  }
14152  return NULL;
14153 }
14154 
14155 
14156 SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14157  PyObject *resultobj = 0;
14158  PLFLT **arg1 = (PLFLT **) 0 ;
14159  PLINT arg2 ;
14160  PLINT arg3 ;
14161  PLFLT arg4 ;
14162  PLFLT arg5 ;
14163  PLFLT arg6 ;
14164  PLFLT arg7 ;
14165  PLFLT arg8 ;
14166  PLFLT arg9 ;
14167  PLFLT arg10 ;
14168  PLFLT arg11 ;
14169  PLFLT arg12 ;
14170  PLFLT arg13 ;
14171  PyArrayObject *tmp1 = NULL ;
14172  double val4 ;
14173  int ecode4 = 0 ;
14174  double val5 ;
14175  int ecode5 = 0 ;
14176  double val6 ;
14177  int ecode6 = 0 ;
14178  double val7 ;
14179  int ecode7 = 0 ;
14180  double val8 ;
14181  int ecode8 = 0 ;
14182  double val9 ;
14183  int ecode9 = 0 ;
14184  double val10 ;
14185  int ecode10 = 0 ;
14186  double val11 ;
14187  int ecode11 = 0 ;
14188  double val12 ;
14189  int ecode12 = 0 ;
14190  double val13 ;
14191  int ecode13 = 0 ;
14192  PyObject *swig_obj[11] ;
14193 
14194  if (!SWIG_Python_UnpackTuple(args, "plimage", 11, 11, swig_obj)) SWIG_fail;
14195  {
14196  int i, size;
14197  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14198  if ( tmp1 == NULL )
14199  return NULL;
14200  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14201  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14202  size = arg3;
14203  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14204  for ( i = 0; i < arg2; i++ )
14205  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14206  }
14207  ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14208  if (!SWIG_IsOK(ecode4)) {
14209  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14210  }
14211  arg4 = (PLFLT)(val4);
14212  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14213  if (!SWIG_IsOK(ecode5)) {
14214  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14215  }
14216  arg5 = (PLFLT)(val5);
14217  ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14218  if (!SWIG_IsOK(ecode6)) {
14219  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14220  }
14221  arg6 = (PLFLT)(val6);
14222  ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14223  if (!SWIG_IsOK(ecode7)) {
14224  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14225  }
14226  arg7 = (PLFLT)(val7);
14227  ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14228  if (!SWIG_IsOK(ecode8)) {
14229  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14230  }
14231  arg8 = (PLFLT)(val8);
14232  ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14233  if (!SWIG_IsOK(ecode9)) {
14234  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14235  }
14236  arg9 = (PLFLT)(val9);
14237  ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14238  if (!SWIG_IsOK(ecode10)) {
14239  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14240  }
14241  arg10 = (PLFLT)(val10);
14242  ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
14243  if (!SWIG_IsOK(ecode11)) {
14244  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14245  }
14246  arg11 = (PLFLT)(val11);
14247  ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
14248  if (!SWIG_IsOK(ecode12)) {
14249  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14250  }
14251  arg12 = (PLFLT)(val12);
14252  ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
14253  if (!SWIG_IsOK(ecode13)) {
14254  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14255  }
14256  arg13 = (PLFLT)(val13);
14257  plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14258  resultobj = SWIG_Py_Void();
14259  {
14260  Py_CLEAR( tmp1 );
14261  free( arg1 );
14262  }
14263  return resultobj;
14264 fail:
14265  {
14266  Py_CLEAR( tmp1 );
14267  free( arg1 );
14268  }
14269  return NULL;
14270 }
14271 
14272 
14273 SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14274  PyObject *resultobj = 0;
14275  PLFLT **arg1 = (PLFLT **) 0 ;
14276  PLINT arg2 ;
14277  PLINT arg3 ;
14278  PLFLT arg4 ;
14279  PLFLT arg5 ;
14280  PLFLT arg6 ;
14281  PLFLT arg7 ;
14282  PLFLT arg8 ;
14283  PLFLT arg9 ;
14284  PLFLT arg10 ;
14285  PLFLT arg11 ;
14286  pltr_func arg12 = (pltr_func) 0 ;
14287  PLPointer arg13 = (PLPointer) 0 ;
14288  PyArrayObject *tmp1 = NULL ;
14289  double val4 ;
14290  int ecode4 = 0 ;
14291  double val5 ;
14292  int ecode5 = 0 ;
14293  double val6 ;
14294  int ecode6 = 0 ;
14295  double val7 ;
14296  int ecode7 = 0 ;
14297  double val8 ;
14298  int ecode8 = 0 ;
14299  double val9 ;
14300  int ecode9 = 0 ;
14301  double val10 ;
14302  int ecode10 = 0 ;
14303  double val11 ;
14304  int ecode11 = 0 ;
14305  PyObject *swig_obj[11] ;
14306 
14307  {
14308  python_pltr = 0;
14309  arg12 = NULL;
14310  }
14311  {
14312  arg13 = NULL;
14313  }
14314  if (!SWIG_Python_UnpackTuple(args, "plimagefr", 9, 11, swig_obj)) SWIG_fail;
14315  {
14316  int i, size;
14317  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14318  if ( tmp1 == NULL )
14319  return NULL;
14320  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14321  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14322  size = arg3;
14323  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14324  for ( i = 0; i < arg2; i++ )
14325  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14326  }
14327  ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14328  if (!SWIG_IsOK(ecode4)) {
14329  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14330  }
14331  arg4 = (PLFLT)(val4);
14332  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14333  if (!SWIG_IsOK(ecode5)) {
14334  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14335  }
14336  arg5 = (PLFLT)(val5);
14337  ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14338  if (!SWIG_IsOK(ecode6)) {
14339  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14340  }
14341  arg6 = (PLFLT)(val6);
14342  ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14343  if (!SWIG_IsOK(ecode7)) {
14344  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14345  }
14346  arg7 = (PLFLT)(val7);
14347  ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14348  if (!SWIG_IsOK(ecode8)) {
14349  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14350  }
14351  arg8 = (PLFLT)(val8);
14352  ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14353  if (!SWIG_IsOK(ecode9)) {
14354  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
14355  }
14356  arg9 = (PLFLT)(val9);
14357  ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14358  if (!SWIG_IsOK(ecode10)) {
14359  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
14360  }
14361  arg10 = (PLFLT)(val10);
14362  ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
14363  if (!SWIG_IsOK(ecode11)) {
14364  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
14365  }
14366  arg11 = (PLFLT)(val11);
14367  if (swig_obj[9]) {
14368  {
14369  // it must be a callable or None
14370  if ( swig_obj[9] == Py_None )
14371  {
14372  arg12 = NULL;
14373  }
14374  else
14375  {
14376  if ( !PyCallable_Check( (PyObject *) swig_obj[9] ) )
14377  {
14378  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
14379  return NULL;
14380  }
14381  arg12 = marshal_pltr( swig_obj[9] );
14382  }
14383  }
14384  }
14385  if (swig_obj[10]) {
14386  {
14387  if ( swig_obj[10] == Py_None )
14388  arg13 = NULL;
14389  else
14390  {
14391  arg13 = marshal_PLPointer( swig_obj[10], 1 );
14392  }
14393  }
14394  }
14395  plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14396  resultobj = SWIG_Py_Void();
14397  {
14398  Py_CLEAR( tmp1 );
14399  free( arg1 );
14400  }
14401  {
14402  cleanup_pltr();
14403  }
14404  {
14406  }
14407  return resultobj;
14408 fail:
14409  {
14410  Py_CLEAR( tmp1 );
14411  free( arg1 );
14412  }
14413  {
14414  cleanup_pltr();
14415  }
14416  {
14418  }
14419  return NULL;
14420 }
14421 
14422 
14423 SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14424  PyObject *resultobj = 0;
14425 
14426  if (!SWIG_Python_UnpackTuple(args, "plClearOpts", 0, 0, 0)) SWIG_fail;
14427  plClearOpts();
14428  resultobj = SWIG_Py_Void();
14429  return resultobj;
14430 fail:
14431  return NULL;
14432 }
14433 
14434 
14435 SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14436  PyObject *resultobj = 0;
14437 
14438  if (!SWIG_Python_UnpackTuple(args, "plResetOpts", 0, 0, 0)) SWIG_fail;
14439  plResetOpts();
14440  resultobj = SWIG_Py_Void();
14441  return resultobj;
14442 fail:
14443  return NULL;
14444 }
14445 
14446 
14447 SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14448  PyObject *resultobj = 0;
14449  char *arg1 = (char *) 0 ;
14450  char *arg2 = (char *) 0 ;
14451  int res1 ;
14452  char *buf1 = 0 ;
14453  int alloc1 = 0 ;
14454  int res2 ;
14455  char *buf2 = 0 ;
14456  int alloc2 = 0 ;
14457  PyObject *swig_obj[2] ;
14458 
14459  if (!SWIG_Python_UnpackTuple(args, "plSetUsage", 2, 2, swig_obj)) SWIG_fail;
14460  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
14461  if (!SWIG_IsOK(res1)) {
14462  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
14463  }
14464  arg1 = (char *)(buf1);
14465  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14466  if (!SWIG_IsOK(res2)) {
14467  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
14468  }
14469  arg2 = (char *)(buf2);
14470  plSetUsage((char const *)arg1,(char const *)arg2);
14471  resultobj = SWIG_Py_Void();
14472  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14473  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14474  return resultobj;
14475 fail:
14476  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14477  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14478  return NULL;
14479 }
14480 
14481 
14482 SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14483  PyObject *resultobj = 0;
14484 
14485  if (!SWIG_Python_UnpackTuple(args, "plOptUsage", 0, 0, 0)) SWIG_fail;
14486  plOptUsage();
14487  resultobj = SWIG_Py_Void();
14488  return resultobj;
14489 fail:
14490  return NULL;
14491 }
14492 
14493 
14494 SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14495  PyObject *resultobj = 0;
14496  PLFLT **arg1 = (PLFLT **) 0 ;
14497  PLINT arg2 ;
14498  PLINT arg3 ;
14499  PLFLT *arg4 = (PLFLT *) 0 ;
14500  PLFLT *arg5 = (PLFLT *) 0 ;
14501  PyArrayObject *tmp1 = NULL ;
14502  PLFLT temp4 ;
14503  int res4 = SWIG_TMPOBJ ;
14504  PLFLT temp5 ;
14505  int res5 = SWIG_TMPOBJ ;
14506  PyObject *swig_obj[1] ;
14507 
14508  arg4 = &temp4;
14509  arg5 = &temp5;
14510  if (!args) SWIG_fail;
14511  swig_obj[0] = args;
14512  {
14513  int i, size;
14514  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14515  if ( tmp1 == NULL )
14516  return NULL;
14517  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14518  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14519  size = arg3;
14520  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14521  for ( i = 0; i < arg2; i++ )
14522  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14523  }
14524  plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
14525  resultobj = SWIG_Py_Void();
14526  if (SWIG_IsTmpObj(res4)) {
14527  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
14528  } else {
14529  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14530  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14531  }
14532  if (SWIG_IsTmpObj(res5)) {
14533  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
14534  } else {
14535  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14536  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
14537  }
14538  {
14539  Py_CLEAR( tmp1 );
14540  free( arg1 );
14541  }
14542  return resultobj;
14543 fail:
14544  {
14545  Py_CLEAR( tmp1 );
14546  free( arg1 );
14547  }
14548  return NULL;
14549 }
14550 
14551 
14552 SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14553  PyObject *resultobj = 0;
14554  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14555  void *argp1 = 0 ;
14556  int res1 = 0 ;
14557  PyObject *swig_obj[1] ;
14558  PLINT result;
14559 
14560  if (!args) SWIG_fail;
14561  swig_obj[0] = args;
14562  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14563  if (!SWIG_IsOK(res1)) {
14564  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14565  }
14566  arg1 = (PLGraphicsIn *)(argp1);
14567  result = (PLINT)plGetCursor(arg1);
14568  resultobj = SWIG_From_int((int)(result));
14569  return resultobj;
14570 fail:
14571  return NULL;
14572 }
14573 
14574 
14575 static PyMethodDef SwigMethods[] = {
14576  { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
14577  { "pltr0", _wrap_pltr0, METH_VARARGS, NULL},
14578  { "pltr1", _wrap_pltr1, METH_VARARGS, NULL},
14579  { "pltr2", _wrap_pltr2, METH_VARARGS, NULL},
14580  { "PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
14581  { "PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_O, NULL},
14582  { "PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
14583  { "PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_O, NULL},
14584  { "PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
14585  { "PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_O, NULL},
14586  { "PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
14587  { "PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_O, NULL},
14588  { "PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
14589  { "PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_O, NULL},
14590  { "PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
14591  { "PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_O, NULL},
14592  { "PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
14593  { "PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_O, NULL},
14594  { "PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
14595  { "PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_O, NULL},
14596  { "PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
14597  { "PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_O, NULL},
14598  { "PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
14599  { "PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_O, NULL},
14600  { "PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
14601  { "PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_O, NULL},
14602  { "PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
14603  { "PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_O, NULL},
14604  { "new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_NOARGS, NULL},
14605  { "delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_O, NULL},
14606  { "PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_O, NULL},
14607  { "PLGraphicsIn_swiginit", PLGraphicsIn_swiginit, METH_VARARGS, NULL},
14608  { "plsxwin", _wrap_plsxwin, METH_O, NULL},
14609  { "pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, "\n"
14610  "Set format of numerical label for contours\n"
14611  "\n"
14612  "DESCRIPTION:\n"
14613  "\n"
14614  " Set format of numerical label for contours.\n"
14615  "\n"
14616  " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
14617  "\n"
14618  " This function is used example 9.\n"
14619  "\n"
14620  "\n"
14621  "\n"
14622  "SYNOPSIS:\n"
14623  "\n"
14624  "pl_setcontlabelformat(lexp, sigdig)\n"
14625  "\n"
14626  "ARGUMENTS:\n"
14627  "\n"
14628  " lexp (PLINT, input) : If the contour numerical label is greater\n"
14629  " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
14630  " format is used. Default value of lexp is 4.\n"
14631  "\n"
14632  " sigdig (PLINT, input) : Number of significant digits. Default\n"
14633  " value is 2.\n"
14634  "\n"
14635  ""},
14636  { "pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, "\n"
14637  "Set parameters of contour labelling other than format of numerical label\n"
14638  "\n"
14639  "DESCRIPTION:\n"
14640  "\n"
14641  " Set parameters of contour labelling other than those handled by\n"
14642  " pl_setcontlabelformat.\n"
14643  "\n"
14644  " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
14645  "\n"
14646  " This function is used in example 9.\n"
14647  "\n"
14648  "\n"
14649  "\n"
14650  "SYNOPSIS:\n"
14651  "\n"
14652  "pl_setcontlabelparam(offset, size, spacing, active)\n"
14653  "\n"
14654  "ARGUMENTS:\n"
14655  "\n"
14656  " offset (PLFLT, input) : Offset of label from contour line (if set\n"
14657  " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
14658  "\n"
14659  " size (PLFLT, input) : Font height for contour labels (normalized).\n"
14660  " Default value is 0.3.\n"
14661  "\n"
14662  " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
14663  " Default value is 0.1.\n"
14664  "\n"
14665  " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
14666  " contour labels on. Default is off (0).\n"
14667  "\n"
14668  ""},
14669  { "pladv", _wrap_pladv, METH_O, "\n"
14670  "Advance the (sub-)page\n"
14671  "\n"
14672  "DESCRIPTION:\n"
14673  "\n"
14674  " Advances to the next subpage if sub=0, performing a page advance if\n"
14675  " there are no remaining subpages on the current page. If subpages\n"
14676  " aren't being used, pladv(0) will always advance the page. If page>0,\n"
14677  " PLplot switches to the specified subpage. Note that this allows you\n"
14678  " to overwrite a plot on the specified subpage; if this is not what you\n"
14679  " intended, use pleop followed by plbop to first advance the page. This\n"
14680  " routine is called automatically (with page=0) by plenv, but if plenv\n"
14681  " is not used, pladv must be called after initializing PLplot but before\n"
14682  " defining the viewport.\n"
14683  "\n"
14684  " Redacted form: pladv(page)\n"
14685  "\n"
14686  " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
14687  " 29, and 31.\n"
14688  "\n"
14689  "\n"
14690  "\n"
14691  "SYNOPSIS:\n"
14692  "\n"
14693  "pladv(page)\n"
14694  "\n"
14695  "ARGUMENTS:\n"
14696  "\n"
14697  " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
14698  " in the top left corner and increasing along the rows) to which to\n"
14699  " advance. Set to zero to advance to the next subpage (or to the\n"
14700  " next page if subpages are not being used).\n"
14701  "\n"
14702  ""},
14703  { "plarc", _wrap_plarc, METH_VARARGS, "\n"
14704  "Draw a circular or elliptical arc\n"
14705  "\n"
14706  "DESCRIPTION:\n"
14707  "\n"
14708  " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
14709  " semiminor axis b, starting at angle1 and ending at angle2.\n"
14710  "\n"
14711  " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
14712  " fill)\n"
14713  "\n"
14714  "\n"
14715  " This function is used in examples 3 and 27.\n"
14716  "\n"
14717  "\n"
14718  "\n"
14719  "SYNOPSIS:\n"
14720  "\n"
14721  "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
14722  "\n"
14723  "ARGUMENTS:\n"
14724  "\n"
14725  " x (PLFLT, input) : X coordinate of arc center.\n"
14726  "\n"
14727  " y (PLFLT, input) : Y coordinate of arc center.\n"
14728  "\n"
14729  " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
14730  "\n"
14731  " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
14732  "\n"
14733  " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
14734  " semimajor axis.\n"
14735  "\n"
14736  " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
14737  " semimajor axis.\n"
14738  "\n"
14739  " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
14740  " X-axis.\n"
14741  "\n"
14742  " fill (PLBOOL, input) : Draw a filled arc.\n"
14743  "\n"
14744  ""},
14745  { "plaxes", _wrap_plaxes, METH_VARARGS, "\n"
14746  "Draw a box with axes, etc. with arbitrary origin\n"
14747  "\n"
14748  "DESCRIPTION:\n"
14749  "\n"
14750  " Draws a box around the currently defined viewport with arbitrary\n"
14751  " world-coordinate origin specified by x0 and y0 and labels it with\n"
14752  " world coordinate values appropriate to the window. Thus plaxes should\n"
14753  " only be called after defining both viewport and window. The ascii\n"
14754  " character strings xopt and yopt specify how the box should be drawn as\n"
14755  " described below. If ticks and/or subticks are to be drawn for a\n"
14756  " particular axis, the tick intervals and number of subintervals may be\n"
14757  " specified explicitly, or they may be defaulted by setting the\n"
14758  " appropriate arguments to zero.\n"
14759  "\n"
14760  " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
14761  " ytick, nysub)\n"
14762  "\n"
14763  "\n"
14764  " This function is not used in any examples.\n"
14765  "\n"
14766  "\n"
14767  "\n"
14768  "SYNOPSIS:\n"
14769  "\n"
14770  "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14771  "\n"
14772  "ARGUMENTS:\n"
14773  "\n"
14774  " x0 (PLFLT, input) : World X coordinate of origin.\n"
14775  "\n"
14776  " y0 (PLFLT, input) : World Y coordinate of origin.\n"
14777  "\n"
14778  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
14779  " options for the x axis. The string can include any combination of\n"
14780  " the following letters (upper or lower case) in any order: a: Draws\n"
14781  " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
14782  " (x=0).\n"
14783  " b: Draws bottom (X) or left (Y) edge of frame.\n"
14784  " c: Draws top (X) or right (Y) edge of frame.\n"
14785  " d: Plot labels as date / time. Values are assumed to be\n"
14786  " seconds since the epoch (as used by gmtime).\n"
14787  " f: Always use fixed point numeric labels.\n"
14788  " g: Draws a grid at the major tick interval.\n"
14789  " h: Draws a grid at the minor tick interval.\n"
14790  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14791  " inwards.\n"
14792  " l: Labels axis logarithmically. This only affects the labels,\n"
14793  " not the data, and so it is necessary to compute the logarithms\n"
14794  " of data points before passing them to any of the drawing\n"
14795  " routines.\n"
14796  " m: Writes numeric labels at major tick intervals in the\n"
14797  " unconventional location (above box for X, right of box for Y).\n"
14798  " n: Writes numeric labels at major tick intervals in the\n"
14799  " conventional location (below box for X, left of box for Y).\n"
14800  " o: Use custom labelling function to generate axis label text.\n"
14801  " The custom labelling function can be defined with the\n"
14802  " plslabelfunc command.\n"
14803  " s: Enables subticks between major ticks, only valid if t is\n"
14804  " also specified.\n"
14805  " t: Draws major ticks.\n"
14806  " u: Exactly like \"b\" except don't draw edge line.\n"
14807  " w: Exactly like \"c\" except don't draw edge line.\n"
14808  " x: Exactly like \"t\" (including the side effect of the\n"
14809  " numerical labels for the major ticks) except exclude drawing\n"
14810  " the major and minor tick marks.\n"
14811  "\n"
14812  "\n"
14813  " xtick (PLFLT, input) : World coordinate interval between major\n"
14814  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14815  " generates a suitable tick interval.\n"
14816  "\n"
14817  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14818  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14819  " generates a suitable minor tick interval.\n"
14820  "\n"
14821  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
14822  " options for the y axis. The string can include any combination of\n"
14823  " the letters defined above for xopt, and in addition may contain:\n"
14824  " v: Write numeric labels for the y axis parallel to the base of the\n"
14825  " graph, rather than parallel to the axis.\n"
14826  "\n"
14827  "\n"
14828  " ytick (PLFLT, input) : World coordinate interval between major\n"
14829  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
14830  " generates a suitable tick interval.\n"
14831  "\n"
14832  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
14833  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14834  " generates a suitable minor tick interval.\n"
14835  "\n"
14836  ""},
14837  { "plbin", _wrap_plbin, METH_VARARGS, "\n"
14838  "Plot a histogram from binned data\n"
14839  "\n"
14840  "DESCRIPTION:\n"
14841  "\n"
14842  " Plots a histogram consisting of nbin bins. The value associated with\n"
14843  " the i'th bin is placed in x[i], and the number of points in the bin is\n"
14844  " placed in y[i]. For proper operation, the values in x[i] must form a\n"
14845  " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
14846  " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
14847  " placed midway between the values in the x vector. Also see plhist for\n"
14848  " drawing histograms from unbinned data.\n"
14849  "\n"
14850  " Redacted form: General: plbin(x, y, opt)\n"
14851  " Python: plbin(nbin, x, y, opt)\n"
14852  "\n"
14853  "\n"
14854  " This function is not used in any examples.\n"
14855  "\n"
14856  "\n"
14857  "\n"
14858  "SYNOPSIS:\n"
14859  "\n"
14860  "plbin(nbin, x, y, opt)\n"
14861  "\n"
14862  "ARGUMENTS:\n"
14863  "\n"
14864  " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
14865  " and y vectors.)\n"
14866  "\n"
14867  " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
14868  " with bins. These must form a strictly increasing sequence.\n"
14869  "\n"
14870  " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
14871  " proportional to the number of points in each bin. This is a PLFLT\n"
14872  " (instead of PLINT) vector so as to allow histograms of\n"
14873  " probabilities, etc.\n"
14874  "\n"
14875  " opt (PLINT, input) : Is a combination of several flags:\n"
14876  " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
14877  " outer bins are expanded to fill up the entire x-axis and bins of\n"
14878  " zero height are simply drawn.\n"
14879  " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
14880  " between the x values. If the values in x are equally spaced,\n"
14881  " the values are the center values of the bins.\n"
14882  " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
14883  " size as the ones inside.\n"
14884  " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
14885  " (there is a gap for such bins).\n"
14886  "\n"
14887  ""},
14888  { "plbtime", _wrap_plbtime, METH_O, "\n"
14889  "Calculate broken-down time from continuous time for the current stream\n"
14890  "\n"
14891  "DESCRIPTION:\n"
14892  "\n"
14893  " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
14894  " continuous time, ctime for the current stream. This function is the\n"
14895  " inverse of plctime.\n"
14896  "\n"
14897  " The PLplot definition of broken-down time is a calendar time that\n"
14898  " completely ignores all time zone offsets, i.e., it is the user's\n"
14899  " responsibility to apply those offsets (if so desired) before using the\n"
14900  " PLplot time API. By default broken-down time is defined using the\n"
14901  " proleptic Gregorian calendar without the insertion of leap seconds and\n"
14902  " continuous time is defined as the number of seconds since the Unix\n"
14903  " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
14904  " broken-down and continuous time are possible, see plconfigtime.\n"
14905  "\n"
14906  " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
14907  " ctime)\n"
14908  "\n"
14909  "\n"
14910  " This function is used in example 29.\n"
14911  "\n"
14912  "\n"
14913  "\n"
14914  "SYNOPSIS:\n"
14915  "\n"
14916  "plbtime(year, month, day, hour, min, sec, ctime)\n"
14917  "\n"
14918  "ARGUMENTS:\n"
14919  "\n"
14920  " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
14921  " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
14922  " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
14923  " BCE, etc.)\n"
14924  "\n"
14925  " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
14926  " the year in the range from 0 (January) to 11 (December).\n"
14927  "\n"
14928  " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
14929  " month in the range from 1 to 31.\n"
14930  "\n"
14931  " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
14932  " day in the range from 0 to 23.\n"
14933  "\n"
14934  " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
14935  " hour in the range from 0 to 59\n"
14936  "\n"
14937  " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
14938  " minute in range from 0. to 60.\n"
14939  "\n"
14940  " ctime (PLFLT, input) : Continuous time from which the broken-down\n"
14941  " time is calculated.\n"
14942  "\n"
14943  ""},
14944  { "plbop", _wrap_plbop, METH_NOARGS, "\n"
14945  "Begin a new page\n"
14946  "\n"
14947  "DESCRIPTION:\n"
14948  "\n"
14949  " Begins a new page. For a file driver, the output file is opened if\n"
14950  " necessary. Advancing the page via pleop and plbop is useful when a\n"
14951  " page break is desired at a particular point when plotting to subpages.\n"
14952  " Another use for pleop and plbop is when plotting pages to different\n"
14953  " files, since you can manually set the file name by calling plsfnam\n"
14954  " after the call to pleop. (In fact some drivers may only support a\n"
14955  " single page per file, making this a necessity.) One way to handle\n"
14956  " this case automatically is to page advance via pladv, but enable\n"
14957  " familying (see plsfam) with a small limit on the file size so that a\n"
14958  " new family member file will be created on each page break.\n"
14959  "\n"
14960  " Redacted form: plbop()\n"
14961  "\n"
14962  " This function is used in examples 2 and 20.\n"
14963  "\n"
14964  "\n"
14965  "\n"
14966  "SYNOPSIS:\n"
14967  "\n"
14968  "plbop()\n"
14969  "\n"
14970  ""},
14971  { "plbox", _wrap_plbox, METH_VARARGS, "\n"
14972  "Draw a box with axes, etc\n"
14973  "\n"
14974  "DESCRIPTION:\n"
14975  "\n"
14976  " Draws a box around the currently defined viewport, and labels it with\n"
14977  " world coordinate values appropriate to the window. Thus plbox should\n"
14978  " only be called after defining both viewport and window. The ascii\n"
14979  " character strings xopt and yopt specify how the box should be drawn as\n"
14980  " described below. If ticks and/or subticks are to be drawn for a\n"
14981  " particular axis, the tick intervals and number of subintervals may be\n"
14982  " specified explicitly, or they may be defaulted by setting the\n"
14983  " appropriate arguments to zero.\n"
14984  "\n"
14985  " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14986  "\n"
14987  "\n"
14988  " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
14989  " and 29.\n"
14990  "\n"
14991  "\n"
14992  "\n"
14993  "SYNOPSIS:\n"
14994  "\n"
14995  "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14996  "\n"
14997  "ARGUMENTS:\n"
14998  "\n"
14999  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15000  " options for the x axis. The string can include any combination of\n"
15001  " the following letters (upper or lower case) in any order: a: Draws\n"
15002  " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15003  " (x=0).\n"
15004  " b: Draws bottom (X) or left (Y) edge of frame.\n"
15005  " c: Draws top (X) or right (Y) edge of frame.\n"
15006  " d: Plot labels as date / time. Values are assumed to be\n"
15007  " seconds since the epoch (as used by gmtime).\n"
15008  " f: Always use fixed point numeric labels.\n"
15009  " g: Draws a grid at the major tick interval.\n"
15010  " h: Draws a grid at the minor tick interval.\n"
15011  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15012  " inwards.\n"
15013  " l: Labels axis logarithmically. This only affects the labels,\n"
15014  " not the data, and so it is necessary to compute the logarithms\n"
15015  " of data points before passing them to any of the drawing\n"
15016  " routines.\n"
15017  " m: Writes numeric labels at major tick intervals in the\n"
15018  " unconventional location (above box for X, right of box for Y).\n"
15019  " n: Writes numeric labels at major tick intervals in the\n"
15020  " conventional location (below box for X, left of box for Y).\n"
15021  " o: Use custom labelling function to generate axis label text.\n"
15022  " The custom labelling function can be defined with the\n"
15023  " plslabelfunc command.\n"
15024  " s: Enables subticks between major ticks, only valid if t is\n"
15025  " also specified.\n"
15026  " t: Draws major ticks.\n"
15027  " u: Exactly like \"b\" except don't draw edge line.\n"
15028  " w: Exactly like \"c\" except don't draw edge line.\n"
15029  " x: Exactly like \"t\" (including the side effect of the\n"
15030  " numerical labels for the major ticks) except exclude drawing\n"
15031  " the major and minor tick marks.\n"
15032  "\n"
15033  "\n"
15034  " xtick (PLFLT, input) : World coordinate interval between major\n"
15035  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15036  " generates a suitable tick interval.\n"
15037  "\n"
15038  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15039  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15040  " generates a suitable minor tick interval.\n"
15041  "\n"
15042  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15043  " options for the y axis. The string can include any combination of\n"
15044  " the letters defined above for xopt, and in addition may contain:\n"
15045  " v: Write numeric labels for the y axis parallel to the base of the\n"
15046  " graph, rather than parallel to the axis.\n"
15047  "\n"
15048  "\n"
15049  " ytick (PLFLT, input) : World coordinate interval between major\n"
15050  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15051  " generates a suitable tick interval.\n"
15052  "\n"
15053  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15054  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15055  " generates a suitable minor tick interval.\n"
15056  "\n"
15057  ""},
15058  { "plbox3", _wrap_plbox3, METH_VARARGS, "\n"
15059  "Draw a box with axes, etc, in 3-d\n"
15060  "\n"
15061  "DESCRIPTION:\n"
15062  "\n"
15063  " Draws axes, numeric and text labels for a three-dimensional surface\n"
15064  " plot. For a more complete description of three-dimensional plotting\n"
15065  " see the PLplot documentation.\n"
15066  "\n"
15067  " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15068  " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15069  "\n"
15070  "\n"
15071  " This function is used in examples 8, 11, 18, and 21.\n"
15072  "\n"
15073  "\n"
15074  "\n"
15075  "SYNOPSIS:\n"
15076  "\n"
15077  "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15078  "\n"
15079  "ARGUMENTS:\n"
15080  "\n"
15081  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15082  " options for the x axis. The string can include any combination of\n"
15083  " the following letters (upper or lower case) in any order: b: Draws\n"
15084  " axis at base, at height z=\n"
15085  " zmin where zmin is defined by call to plw3d. This character must be\n"
15086  " specified in order to use any of the other options.\n"
15087  " d: Plot labels as date / time. Values are assumed to be\n"
15088  " seconds since the epoch (as used by gmtime).\n"
15089  " f: Always use fixed point numeric labels.\n"
15090  " i: Inverts tick marks, so they are drawn downwards, rather\n"
15091  " than upwards.\n"
15092  " l: Labels axis logarithmically. This only affects the labels,\n"
15093  " not the data, and so it is necessary to compute the logarithms\n"
15094  " of data points before passing them to any of the drawing\n"
15095  " routines.\n"
15096  " n: Writes numeric labels at major tick intervals.\n"
15097  " o: Use custom labelling function to generate axis label text.\n"
15098  " The custom labelling function can be defined with the\n"
15099  " plslabelfunc command.\n"
15100  " s: Enables subticks between major ticks, only valid if t is\n"
15101  " also specified.\n"
15102  " t: Draws major ticks.\n"
15103  " u: If this is specified, the text label for the axis is\n"
15104  " written under the axis.\n"
15105  "\n"
15106  "\n"
15107  " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15108  " the text label for the x axis. It is only drawn if u is in the\n"
15109  " xopt string.\n"
15110  "\n"
15111  " xtick (PLFLT, input) : World coordinate interval between major\n"
15112  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15113  " generates a suitable tick interval.\n"
15114  "\n"
15115  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15116  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15117  " generates a suitable minor tick interval.\n"
15118  "\n"
15119  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15120  " options for the y axis. The string is interpreted in the same way\n"
15121  " as xopt.\n"
15122  "\n"
15123  " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15124  " the text label for the y axis. It is only drawn if u is in the\n"
15125  " yopt string.\n"
15126  "\n"
15127  " ytick (PLFLT, input) : World coordinate interval between major\n"
15128  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15129  " generates a suitable tick interval.\n"
15130  "\n"
15131  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15132  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15133  " generates a suitable minor tick interval.\n"
15134  "\n"
15135  " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15136  " options for the z axis. The string can include any combination of\n"
15137  " the following letters (upper or lower case) in any order: b: Draws\n"
15138  " z axis to the left of the surface plot.\n"
15139  " c: Draws z axis to the right of the surface plot.\n"
15140  " d: Draws grid lines parallel to the x-y plane behind the\n"
15141  " figure. These lines are not drawn until after plot3d or\n"
15142  " plmesh are called because of the need for hidden line removal.\n"
15143  " e: Plot labels as date / time. Values are assumed to be\n"
15144  " seconds since the epoch (as used by gmtime). Note this\n"
15145  " suboption is interpreted the same as the d suboption for xopt\n"
15146  " and yopt, but it has to be identified as e for zopt since d\n"
15147  " has already been used for the different purpose above.\n"
15148  " f: Always use fixed point numeric labels.\n"
15149  " i: Inverts tick marks, so they are drawn away from the center.\n"
15150  " l: Labels axis logarithmically. This only affects the labels,\n"
15151  " not the data, and so it is necessary to compute the logarithms\n"
15152  " of data points before passing them to any of the drawing\n"
15153  " routines.\n"
15154  " m: Writes numeric labels at major tick intervals on the\n"
15155  " right-hand z axis.\n"
15156  " n: Writes numeric labels at major tick intervals on the\n"
15157  " left-hand z axis.\n"
15158  " o: Use custom labelling function to generate axis label text.\n"
15159  " The custom labelling function can be defined with the\n"
15160  " plslabelfunc command.\n"
15161  " s: Enables subticks between major ticks, only valid if t is\n"
15162  " also specified.\n"
15163  " t: Draws major ticks.\n"
15164  " u: If this is specified, the text label is written beside the\n"
15165  " left-hand axis.\n"
15166  " v: If this is specified, the text label is written beside the\n"
15167  " right-hand axis.\n"
15168  "\n"
15169  "\n"
15170  " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15171  " the text label for the z axis. It is only drawn if u or v are in\n"
15172  " the zopt string.\n"
15173  "\n"
15174  " ztick (PLFLT, input) : World coordinate interval between major\n"
15175  " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15176  " generates a suitable tick interval.\n"
15177  "\n"
15178  " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15179  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15180  " generates a suitable minor tick interval.\n"
15181  "\n"
15182  ""},
15183  { "plcalc_world", _wrap_plcalc_world, METH_VARARGS, "\n"
15184  "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15185  "\n"
15186  "DESCRIPTION:\n"
15187  "\n"
15188  " Calculate world coordinates, wx and wy, and corresponding window index\n"
15189  " from relative device coordinates, rx and ry.\n"
15190  "\n"
15191  " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15192  "\n"
15193  "\n"
15194  " This function is used in example 31.\n"
15195  "\n"
15196  "\n"
15197  "\n"
15198  "SYNOPSIS:\n"
15199  "\n"
15200  "plcalc_world(rx, ry, wx, wy, window)\n"
15201  "\n"
15202  "ARGUMENTS:\n"
15203  "\n"
15204  " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15205  " the x coordinate.\n"
15206  "\n"
15207  " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15208  " the y coordinate.\n"
15209  "\n"
15210  " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15211  " coordinate corresponding to the relative device coordinates rx and\n"
15212  " ry.\n"
15213  "\n"
15214  " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15215  " coordinate corresponding to the relative device coordinates rx and\n"
15216  " ry.\n"
15217  "\n"
15218  " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15219  " defined window index that corresponds to the input relative device\n"
15220  " coordinates (and the returned world coordinates). To give some\n"
15221  " background on the window index, for each page the initial window\n"
15222  " index is set to zero, and each time plwind is called within the\n"
15223  " page, world and device coordinates are stored for the window and\n"
15224  " the window index is incremented. Thus, for a simple page layout\n"
15225  " with non-overlapping viewports and one window per viewport, window\n"
15226  " corresponds to the viewport index (in the order which the\n"
15227  " viewport/windows were created) of the only viewport/window\n"
15228  " corresponding to rx and ry. However, for more complicated layouts\n"
15229  " with potentially overlapping viewports and possibly more than one\n"
15230  " window (set of world coordinates) per viewport, window and the\n"
15231  " corresponding output world coordinates corresponds to the last\n"
15232  " window created that fulfills the criterion that the relative\n"
15233  " device coordinates are inside it. Finally, in all cases where the\n"
15234  " input relative device coordinates are not inside any\n"
15235  " viewport/window, then the returned value of the last defined\n"
15236  " window index is set to -1.\n"
15237  "\n"
15238  ""},
15239  { "plclear", _wrap_plclear, METH_NOARGS, "\n"
15240  "Clear current (sub)page\n"
15241  "\n"
15242  "DESCRIPTION:\n"
15243  "\n"
15244  " Clears the current page, effectively erasing everything that have been\n"
15245  " drawn. This command only works with interactive drivers; if the\n"
15246  " driver does not support this, the page is filled with the background\n"
15247  " color in use. If the current page is divided into subpages, only the\n"
15248  " current subpage is erased. The nth subpage can be selected with\n"
15249  " pladv(n).\n"
15250  "\n"
15251  " Redacted form: General: plclear()\n"
15252  "\n"
15253  "\n"
15254  " This function is not used in any examples.\n"
15255  "\n"
15256  "\n"
15257  "\n"
15258  "SYNOPSIS:\n"
15259  "\n"
15260  "plclear()\n"
15261  "\n"
15262  ""},
15263  { "plcol0", _wrap_plcol0, METH_O, "\n"
15264  "Set color, cmap0\n"
15265  "\n"
15266  "DESCRIPTION:\n"
15267  "\n"
15268  " Sets the color index for cmap0 (see the PLplot documentation).\n"
15269  "\n"
15270  " Redacted form: plcol0(icol0)\n"
15271  "\n"
15272  " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
15273  "\n"
15274  "\n"
15275  "\n"
15276  "SYNOPSIS:\n"
15277  "\n"
15278  "plcol0(icol0)\n"
15279  "\n"
15280  "ARGUMENTS:\n"
15281  "\n"
15282  " icol0 (PLINT, input) : Integer representing the color. The\n"
15283  " defaults at present are (these may change):\n"
15284  " 0 black (default background)\n"
15285  " 1 red (default foreground)\n"
15286  " 2 yellow\n"
15287  " 3 green\n"
15288  " 4 aquamarine\n"
15289  " 5 pink\n"
15290  " 6 wheat\n"
15291  " 7 grey\n"
15292  " 8 brown\n"
15293  " 9 blue\n"
15294  " 10 BlueViolet\n"
15295  " 11 cyan\n"
15296  " 12 turquoise\n"
15297  " 13 magenta\n"
15298  " 14 salmon\n"
15299  " 15 white\n"
15300  "\n"
15301  " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
15302  " change an individual color in the cmap0 color palette.\n"
15303  "\n"
15304  ""},
15305  { "plcol1", _wrap_plcol1, METH_O, "\n"
15306  "Set color, cmap1\n"
15307  "\n"
15308  "DESCRIPTION:\n"
15309  "\n"
15310  " Sets the color for cmap1 (see the PLplot documentation).\n"
15311  "\n"
15312  " Redacted form: plcol1(col1)\n"
15313  "\n"
15314  " This function is used in examples 12 and 21.\n"
15315  "\n"
15316  "\n"
15317  "\n"
15318  "SYNOPSIS:\n"
15319  "\n"
15320  "plcol1(col1)\n"
15321  "\n"
15322  "ARGUMENTS:\n"
15323  "\n"
15324  " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
15325  " is mapped to color using the continuous cmap1 palette which by\n"
15326  " default ranges from blue to the background color to red. The\n"
15327  " cmap1 palette can also be straightforwardly changed by the user\n"
15328  " with plscmap1 or plscmap1l.\n"
15329  "\n"
15330  ""},
15331  { "plconfigtime", _wrap_plconfigtime, METH_VARARGS, "\n"
15332  "Configure the transformation between continuous and broken-down time for the current stream\n"
15333  "\n"
15334  "DESCRIPTION:\n"
15335  "\n"
15336  " Configure the transformation between continuous and broken-down time\n"
15337  " for the current stream. This transformation is used by both plbtime\n"
15338  " and plctime.\n"
15339  "\n"
15340  " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
15341  " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15342  "\n"
15343  "\n"
15344  " This function is used in example 29.\n"
15345  "\n"
15346  "\n"
15347  "\n"
15348  "SYNOPSIS:\n"
15349  "\n"
15350  "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15351  "\n"
15352  "ARGUMENTS:\n"
15353  "\n"
15354  " scale (PLFLT, input) : The number of days per continuous time unit.\n"
15355  " As a special case, if\n"
15356  " scale is 0., then all other arguments are ignored, and the result (the\n"
15357  " default used by PLplot) is the equivalent of a call to\n"
15358  " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
15359  " That is, for this special case broken-down time is calculated with\n"
15360  " the proleptic Gregorian calendar with no leap seconds inserted,\n"
15361  " and the continuous time is defined as the number of seconds since\n"
15362  " the Unix epoch of 1970-01-01T00:00:00Z.\n"
15363  "\n"
15364  " offset1 (PLFLT, input) : If\n"
15365  " ifbtime_offset is true, the parameters\n"
15366  " offset1 and\n"
15367  " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
15368  " (with units in days) specify the epoch of the continuous time\n"
15369  " relative to the MJD epoch corresponding to the Gregorian calendar\n"
15370  " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
15371  " are used to specify the origin to allow users (by specifying\n"
15372  " offset1 as an integer that can be exactly represented by a\n"
15373  " floating-point variable and specifying\n"
15374  " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
15375  " the numerical errors of the continuous time representation.\n"
15376  "\n"
15377  " offset2 (PLFLT, input) : See documentation of\n"
15378  " offset1.\n"
15379  "\n"
15380  " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
15381  " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
15382  " calendar is used for broken-down time rather than the proleptic\n"
15383  " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
15384  " have been historically used to define UTC are inserted into the\n"
15385  " broken-down time. Other possibilities for additional control bits\n"
15386  " for ccontrol exist such as making the historical time corrections\n"
15387  " in the broken-down time corresponding to ET (ephemeris time) or\n"
15388  " making the (slightly non-constant) corrections from international\n"
15389  " atomic time (TAI) to what astronomers define as terrestrial time\n"
15390  " (TT). But those additional possibilities have not been\n"
15391  " implemented yet in the qsastime library (one of the PLplot utility\n"
15392  " libraries).\n"
15393  "\n"
15394  " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
15395  " epoch of the continuous time scale is specified by the user. If\n"
15396  " ifbtime_offset is false, then\n"
15397  " offset1 and\n"
15398  " offset2 are used to specify the epoch, and the following broken-down\n"
15399  " time parameters are completely ignored. If\n"
15400  " ifbtime_offset is true, then\n"
15401  " offset1 and\n"
15402  " offset2 are completely ignored, and the following broken-down time\n"
15403  " parameters are used to specify the epoch.\n"
15404  "\n"
15405  " year (PLINT, input) : Year of epoch.\n"
15406  "\n"
15407  " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
15408  " 11 (December).\n"
15409  "\n"
15410  " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
15411  "\n"
15412  " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
15413  "\n"
15414  " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
15415  "\n"
15416  " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
15417  "\n"
15418  ""},
15419  { "plcont", _wrap_plcont, METH_VARARGS, "\n"
15420  "Contour plot\n"
15421  "\n"
15422  "DESCRIPTION:\n"
15423  "\n"
15424  " Draws a contour plot of the data in f[\n"
15425  " nx][\n"
15426  " ny], using the nlevel contour levels specified by clevel. Only the\n"
15427  " region of the matrix from kx to lx and from ky to ly is plotted out\n"
15428  " where all these index ranges are interpreted as one-based for\n"
15429  " historical reasons. A transformation routine pointed to by pltr with\n"
15430  " a generic pointer pltr_data for additional data required by the\n"
15431  " transformation routine is used to map indices within the matrix to the\n"
15432  " world coordinates.\n"
15433  "\n"
15434  " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
15435  " where (see above discussion) the pltr, pltr_data callback arguments\n"
15436  " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
15437  " vectors; or xg and yg matrices.\n"
15438  "\n"
15439  " This function is used in examples 9, 14, 16, and 22.\n"
15440  "\n"
15441  "\n"
15442  "\n"
15443  "SYNOPSIS:\n"
15444  "\n"
15445  "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
15446  "\n"
15447  "ARGUMENTS:\n"
15448  "\n"
15449  " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
15450  "\n"
15451  " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
15452  "\n"
15453  " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
15454  " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
15455  " zero-based for historical backwards-compatibility reasons.\n"
15456  "\n"
15457  " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
15458  " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
15459  " zero-based for historical backwards-compatibility reasons.\n"
15460  "\n"
15461  " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
15462  " which to draw contours.\n"
15463  "\n"
15464  " nlevel (PLINT, input) : Number of contour levels to draw.\n"
15465  "\n"
15466  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
15467  " defines the transformation between the zero-based indices of the\n"
15468  " matrix f and the world coordinates.For the C case, transformation\n"
15469  " functions are provided in the PLplot library: pltr0 for the\n"
15470  " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
15471  " respectively defined by vectors and matrices. In addition, C\n"
15472  " callback routines for the transformation can be supplied by the\n"
15473  " user such as the mypltr function in examples/c/x09c.c which\n"
15474  " provides a general linear transformation between index coordinates\n"
15475  " and world coordinates.For languages other than C you should\n"
15476  " consult the PLplot documentation for the details concerning how\n"
15477  " PLTRANSFORM_callback arguments are interfaced. However, in\n"
15478  " general, a particular pattern of callback-associated arguments\n"
15479  " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
15480  " yg matrices are respectively interfaced to a linear-transformation\n"
15481  " routine similar to the above mypltr function; pltr1; and pltr2.\n"
15482  " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
15483  " the PLplot documentation) support native language callbacks for\n"
15484  " handling index to world-coordinate transformations. Examples of\n"
15485  " these various approaches are given in examples/<language>x09*,\n"
15486  " examples/<language>x16*, examples/<language>x20*,\n"
15487  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
15488  " supported languages.\n"
15489  "\n"
15490  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
15491  " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
15492  " that is externally supplied.\n"
15493  "\n"
15494  ""},
15495  { "plctime", _wrap_plctime, METH_VARARGS, "\n"
15496  "Calculate continuous time from broken-down time for the current stream\n"
15497  "\n"
15498  "DESCRIPTION:\n"
15499  "\n"
15500  " Calculate continuous time, ctime, from broken-down time for the\n"
15501  " current stream. The broken-down\n"
15502  " time is specified by the following parameters: year, month, day, hour,\n"
15503  " min, and sec. This function is the inverse of plbtime.\n"
15504  "\n"
15505  " The PLplot definition of broken-down time is a calendar time that\n"
15506  " completely ignores all time zone offsets, i.e., it is the user's\n"
15507  " responsibility to apply those offsets (if so desired) before using the\n"
15508  " PLplot time API. By default broken-down time is defined using the\n"
15509  " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15510  " continuous time is defined as the number of seconds since the Unix\n"
15511  " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15512  " broken-down and continuous time are possible, see plconfigtime which\n"
15513  " specifies that transformation for the current stream.\n"
15514  "\n"
15515  " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
15516  " ctime)\n"
15517  "\n"
15518  "\n"
15519  " This function is used in example 29.\n"
15520  "\n"
15521  "\n"
15522  "\n"
15523  "SYNOPSIS:\n"
15524  "\n"
15525  "plctime(year, month, day, hour, min, sec, ctime)\n"
15526  "\n"
15527  "ARGUMENTS:\n"
15528  "\n"
15529  " year (PLINT, input) : Input year.\n"
15530  "\n"
15531  " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
15532  " (December).\n"
15533  "\n"
15534  " day (PLINT, input) : Input day in range from 1 to 31.\n"
15535  "\n"
15536  " hour (PLINT, input) : Input hour in range from 0 to 23\n"
15537  "\n"
15538  " min (PLINT, input) : Input minute in range from 0 to 59.\n"
15539  "\n"
15540  " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
15541  "\n"
15542  " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n"
15543  " time calculated from the broken-down time specified by the\n"
15544  " previous parameters.\n"
15545  "\n"
15546  ""},
15547  { "plcpstrm", _wrap_plcpstrm, METH_VARARGS, "\n"
15548  "Copy state parameters from the reference stream to the current stream\n"
15549  "\n"
15550  "DESCRIPTION:\n"
15551  "\n"
15552  " Copies state parameters from the reference stream to the current\n"
15553  " stream. Tell driver interface to map device coordinates unless flags\n"
15554  " == 1.\n"
15555  "\n"
15556  " This function is used for making save files of selected plots (e.g.\n"
15557  " from the TK driver). After initializing, you can get a copy of the\n"
15558  " current plot to the specified device by switching to this stream and\n"
15559  " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
15560  " appropriate. The plot buffer must have previously been enabled (done\n"
15561  " automatically by some display drivers, such as X).\n"
15562  "\n"
15563  " Redacted form: plcpstrm(iplsr, flags)\n"
15564  "\n"
15565  " This function is used in example 1,20.\n"
15566  "\n"
15567  "\n"
15568  "\n"
15569  "SYNOPSIS:\n"
15570  "\n"
15571  "plcpstrm(iplsr, flags)\n"
15572  "\n"
15573  "ARGUMENTS:\n"
15574  "\n"
15575  " iplsr (PLINT, input) : Number of reference stream.\n"
15576  "\n"
15577  " flags (PLBOOL, input) : If flags is set to true the device\n"
15578  " coordinates are not copied from the reference to current stream.\n"
15579  "\n"
15580  ""},
15581  { "plend", _wrap_plend, METH_NOARGS, "\n"
15582  "End plotting session\n"
15583  "\n"
15584  "DESCRIPTION:\n"
15585  "\n"
15586  " Ends a plotting session, tidies up all the output files, switches\n"
15587  " interactive devices back into text mode and frees up any memory that\n"
15588  " was allocated. Must be called before end of program.\n"
15589  "\n"
15590  " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
15591  " wait state after a call to plend or other functions which trigger the\n"
15592  " end of a plot page. To avoid this, use the plspause function.\n"
15593  "\n"
15594  " Redacted form: plend()\n"
15595  "\n"
15596  " This function is used in all of the examples.\n"
15597  "\n"
15598  "\n"
15599  "\n"
15600  "SYNOPSIS:\n"
15601  "\n"
15602  "plend()\n"
15603  "\n"
15604  ""},
15605  { "plend1", _wrap_plend1, METH_NOARGS, "\n"
15606  "End plotting session for current stream\n"
15607  "\n"
15608  "DESCRIPTION:\n"
15609  "\n"
15610  " Ends a plotting session for the current output stream only. See\n"
15611  " plsstrm for more info.\n"
15612  "\n"
15613  " Redacted form: plend1()\n"
15614  "\n"
15615  " This function is used in examples 1 and 20.\n"
15616  "\n"
15617  "\n"
15618  "\n"
15619  "SYNOPSIS:\n"
15620  "\n"
15621  "plend1()\n"
15622  "\n"
15623  ""},
15624  { "plenv", _wrap_plenv, METH_VARARGS, "\n"
15625  "Set up standard window and draw box\n"
15626  "\n"
15627  "DESCRIPTION:\n"
15628  "\n"
15629  " Sets up plotter environment for simple graphs by calling pladv and\n"
15630  " setting up viewport and window to sensible default values. plenv\n"
15631  " leaves a standard margin (left-hand margin of eight character heights,\n"
15632  " and a margin around the other three sides of five character heights)\n"
15633  " around most graphs for axis labels and a title. When these defaults\n"
15634  " are not suitable, use the individual routines plvpas, plvpor, or\n"
15635  " plvasp for setting up the viewport, plwind for defining the window,\n"
15636  " and plbox for drawing the box.\n"
15637  "\n"
15638  " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15639  "\n"
15640  " This function is used in example 1,3,9,13,14,19-22,29.\n"
15641  "\n"
15642  "\n"
15643  "\n"
15644  "SYNOPSIS:\n"
15645  "\n"
15646  "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15647  "\n"
15648  "ARGUMENTS:\n"
15649  "\n"
15650  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15651  " world coordinates).\n"
15652  "\n"
15653  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15654  " world coordinates).\n"
15655  "\n"
15656  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15657  " coordinates).\n"
15658  "\n"
15659  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15660  " coordinates).\n"
15661  "\n"
15662  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15663  " scales will not be set, the user must set up the scale before\n"
15664  " calling plenv using plsvpa, plvasp or other.\n"
15665  " 0: the x and y axes are scaled independently to use as much of\n"
15666  " the screen as possible.\n"
15667  " 1: the scales of the x and y axes are made equal.\n"
15668  " 2: the axis of the x and y axes are made equal, and the plot\n"
15669  " box will be square.\n"
15670  "\n"
15671  "\n"
15672  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15673  " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
15674  " -1: draw box only.\n"
15675  " 0: draw box, ticks, and numeric tick labels.\n"
15676  " 1: also draw coordinate axes at x=0 and y=0.\n"
15677  " 2: also draw a grid at major tick positions in both\n"
15678  " coordinates.\n"
15679  " 3: also draw a grid at minor tick positions in both\n"
15680  " coordinates.\n"
15681  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15682  " have to be converted to logarithms separately.)\n"
15683  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15684  " have to be converted to logarithms separately.)\n"
15685  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15686  " have to be converted to logarithms separately.)\n"
15687  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15688  " have to be converted to logarithms separately.)\n"
15689  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15690  " have to be converted to logarithms separately.)\n"
15691  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15692  " have to be converted to logarithms separately.)\n"
15693  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15694  " have to be converted to logarithms separately.)\n"
15695  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15696  " have to be converted to logarithms separately.)\n"
15697  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15698  " and y data have to be converted to logarithms separately.)\n"
15699  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15700  " and y data have to be converted to logarithms separately.)\n"
15701  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15702  " and y data have to be converted to logarithms separately.)\n"
15703  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15704  " and y data have to be converted to logarithms separately.)\n"
15705  " 40: same as 0 except date / time x labels.\n"
15706  " 41: same as 1 except date / time x labels.\n"
15707  " 42: same as 2 except date / time x labels.\n"
15708  " 43: same as 3 except date / time x labels.\n"
15709  " 50: same as 0 except date / time y labels.\n"
15710  " 51: same as 1 except date / time y labels.\n"
15711  " 52: same as 2 except date / time y labels.\n"
15712  " 53: same as 3 except date / time y labels.\n"
15713  " 60: same as 0 except date / time x and y labels.\n"
15714  " 61: same as 1 except date / time x and y labels.\n"
15715  " 62: same as 2 except date / time x and y labels.\n"
15716  " 63: same as 3 except date / time x and y labels.\n"
15717  " 70: same as 0 except custom x and y labels.\n"
15718  " 71: same as 1 except custom x and y labels.\n"
15719  " 72: same as 2 except custom x and y labels.\n"
15720  " 73: same as 3 except custom x and y labels.\n"
15721  "\n"
15722  ""},
15723  { "plenv0", _wrap_plenv0, METH_VARARGS, "\n"
15724  "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
15725  "\n"
15726  "DESCRIPTION:\n"
15727  "\n"
15728  " Sets up plotter environment for simple graphs by calling pladv and\n"
15729  " setting up viewport and window to sensible default values. plenv0\n"
15730  " leaves a standard margin (left-hand margin of eight character heights,\n"
15731  " and a margin around the other three sides of five character heights)\n"
15732  " around most graphs for axis labels and a title. When these defaults\n"
15733  " are not suitable, use the individual routines plvpas, plvpor, or\n"
15734  " plvasp for setting up the viewport, plwind for defining the window,\n"
15735  " and plbox for drawing the box.\n"
15736  "\n"
15737  " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15738  "\n"
15739  " This function is used in example 21.\n"
15740  "\n"
15741  "\n"
15742  "\n"
15743  "SYNOPSIS:\n"
15744  "\n"
15745  "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15746  "\n"
15747  "ARGUMENTS:\n"
15748  "\n"
15749  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15750  " world coordinates).\n"
15751  "\n"
15752  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15753  " world coordinates).\n"
15754  "\n"
15755  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15756  " coordinates).\n"
15757  "\n"
15758  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15759  " coordinates).\n"
15760  "\n"
15761  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15762  " scales will not be set, the user must set up the scale before\n"
15763  " calling plenv0 using plsvpa, plvasp or other.\n"
15764  " 0: the x and y axes are scaled independently to use as much of\n"
15765  " the screen as possible.\n"
15766  " 1: the scales of the x and y axes are made equal.\n"
15767  " 2: the axis of the x and y axes are made equal, and the plot\n"
15768  " box will be square.\n"
15769  "\n"
15770  "\n"
15771  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15772  " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
15773  " -1: draw box only.\n"
15774  " 0: draw box, ticks, and numeric tick labels.\n"
15775  " 1: also draw coordinate axes at x=0 and y=0.\n"
15776  " 2: also draw a grid at major tick positions in both\n"
15777  " coordinates.\n"
15778  " 3: also draw a grid at minor tick positions in both\n"
15779  " coordinates.\n"
15780  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15781  " have to be converted to logarithms separately.)\n"
15782  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15783  " have to be converted to logarithms separately.)\n"
15784  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15785  " have to be converted to logarithms separately.)\n"
15786  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15787  " have to be converted to logarithms separately.)\n"
15788  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15789  " have to be converted to logarithms separately.)\n"
15790  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15791  " have to be converted to logarithms separately.)\n"
15792  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15793  " have to be converted to logarithms separately.)\n"
15794  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15795  " have to be converted to logarithms separately.)\n"
15796  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15797  " and y data have to be converted to logarithms separately.)\n"
15798  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15799  " and y data have to be converted to logarithms separately.)\n"
15800  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15801  " and y data have to be converted to logarithms separately.)\n"
15802  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15803  " and y data have to be converted to logarithms separately.)\n"
15804  " 40: same as 0 except date / time x labels.\n"
15805  " 41: same as 1 except date / time x labels.\n"
15806  " 42: same as 2 except date / time x labels.\n"
15807  " 43: same as 3 except date / time x labels.\n"
15808  " 50: same as 0 except date / time y labels.\n"
15809  " 51: same as 1 except date / time y labels.\n"
15810  " 52: same as 2 except date / time y labels.\n"
15811  " 53: same as 3 except date / time y labels.\n"
15812  " 60: same as 0 except date / time x and y labels.\n"
15813  " 61: same as 1 except date / time x and y labels.\n"
15814  " 62: same as 2 except date / time x and y labels.\n"
15815  " 63: same as 3 except date / time x and y labels.\n"
15816  " 70: same as 0 except custom x and y labels.\n"
15817  " 71: same as 1 except custom x and y labels.\n"
15818  " 72: same as 2 except custom x and y labels.\n"
15819  " 73: same as 3 except custom x and y labels.\n"
15820  "\n"
15821  ""},
15822  { "pleop", _wrap_pleop, METH_NOARGS, "\n"
15823  "Eject current page\n"
15824  "\n"
15825  "DESCRIPTION:\n"
15826  "\n"
15827  " Clears the graphics screen of an interactive device, or ejects a page\n"
15828  " on a plotter. See plbop for more information.\n"
15829  "\n"
15830  " Redacted form: pleop()\n"
15831  "\n"
15832  " This function is used in example 2,14.\n"
15833  "\n"
15834  "\n"
15835  "\n"
15836  "SYNOPSIS:\n"
15837  "\n"
15838  "pleop()\n"
15839  "\n"
15840  ""},
15841  { "plerrx", _wrap_plerrx, METH_VARARGS, "\n"
15842  "Draw error bars in x direction\n"
15843  "\n"
15844  "DESCRIPTION:\n"
15845  "\n"
15846  " Draws a set of n error bars in x direction, the i'th error bar\n"
15847  " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
15848  " of the error bars are of length equal to the minor tick length\n"
15849  " (settable using plsmin).\n"
15850  "\n"
15851  " Redacted form: General: plerrx(xmin, ymax, y)\n"
15852  "\n"
15853  "\n"
15854  " This function is used in example 29.\n"
15855  "\n"
15856  "\n"
15857  "\n"
15858  "SYNOPSIS:\n"
15859  "\n"
15860  "plerrx(n, xmin, xmax, y)\n"
15861  "\n"
15862  "ARGUMENTS:\n"
15863  "\n"
15864  " n (PLINT, input) : Number of error bars to draw.\n"
15865  "\n"
15866  " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
15867  " of the left-hand endpoints of the error bars.\n"
15868  "\n"
15869  " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
15870  " of the right-hand endpoints of the error bars.\n"
15871  "\n"
15872  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
15873  " the error bars.\n"
15874  "\n"
15875  ""},
15876  { "plerry", _wrap_plerry, METH_VARARGS, "\n"
15877  "Draw error bars in the y direction\n"
15878  "\n"
15879  "DESCRIPTION:\n"
15880  "\n"
15881  " Draws a set of n error bars in the y direction, the i'th error bar\n"
15882  " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
15883  " of the error bars are of length equal to the minor tick length\n"
15884  " (settable using plsmin).\n"
15885  "\n"
15886  " Redacted form: General: plerry(x, ymin, ymax)\n"
15887  "\n"
15888  "\n"
15889  " This function is used in example 29.\n"
15890  "\n"
15891  "\n"
15892  "\n"
15893  "SYNOPSIS:\n"
15894  "\n"
15895  "plerry(n, x, ymin, ymax)\n"
15896  "\n"
15897  "ARGUMENTS:\n"
15898  "\n"
15899  " n (PLINT, input) : Number of error bars to draw.\n"
15900  "\n"
15901  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
15902  " the error bars.\n"
15903  "\n"
15904  " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
15905  " of the lower endpoints of the error bars.\n"
15906  "\n"
15907  " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
15908  " of the upper endpoints of the error bars.\n"
15909  "\n"
15910  ""},
15911  { "plfamadv", _wrap_plfamadv, METH_NOARGS, "\n"
15912  "Advance to the next family file on the next new page\n"
15913  "\n"
15914  "DESCRIPTION:\n"
15915  "\n"
15916  " Advance to the next family file on the next new page.\n"
15917  "\n"
15918  " Redacted form: plfamadv()\n"
15919  "\n"
15920  " This function is not used in any examples.\n"
15921  "\n"
15922  "\n"
15923  "\n"
15924  "SYNOPSIS:\n"
15925  "\n"
15926  "plfamadv()\n"
15927  "\n"
15928  ""},
15929  { "plfill", _wrap_plfill, METH_VARARGS, "\n"
15930  "Draw filled polygon\n"
15931  "\n"
15932  "DESCRIPTION:\n"
15933  "\n"
15934  " Fills the polygon defined by the n points (\n"
15935  " x[i],\n"
15936  " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
15937  " style is a solid fill. The routine will automatically close the\n"
15938  " polygon between the last and first vertices. If multiple closed\n"
15939  " polygons are passed in x and y then plfill will fill in between them.\n"
15940  "\n"
15941  " Redacted form: plfill(x,y)\n"
15942  "\n"
15943  " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
15944  "\n"
15945  "\n"
15946  "\n"
15947  "SYNOPSIS:\n"
15948  "\n"
15949  "plfill(n, x, y)\n"
15950  "\n"
15951  "ARGUMENTS:\n"
15952  "\n"
15953  " n (PLINT, input) : Number of vertices in polygon.\n"
15954  "\n"
15955  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
15956  " vertices.\n"
15957  "\n"
15958  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
15959  " vertices.\n"
15960  "\n"
15961  ""},
15962  { "plfill3", _wrap_plfill3, METH_VARARGS, "\n"
15963  "Draw filled polygon in 3D\n"
15964  "\n"
15965  "DESCRIPTION:\n"
15966  "\n"
15967  " Fills the 3D polygon defined by the n points in the x, y, and z\n"
15968  " vectors using the pattern defined by plpsty or plpat. The routine\n"
15969  " will automatically close the polygon between the last and first\n"
15970  " vertices. If multiple closed polygons are passed in x, y, and z then\n"
15971  " plfill3 will fill in between them.\n"
15972  "\n"
15973  " Redacted form: General: plfill3(x, y, z)\n"
15974  "\n"
15975  "\n"
15976  " This function is used in example 15.\n"
15977  "\n"
15978  "\n"
15979  "\n"
15980  "SYNOPSIS:\n"
15981  "\n"
15982  "plfill3(n, x, y, z)\n"
15983  "\n"
15984  "ARGUMENTS:\n"
15985  "\n"
15986  " n (PLINT, input) : Number of vertices in polygon.\n"
15987  "\n"
15988  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
15989  " vertices.\n"
15990  "\n"
15991  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
15992  " vertices.\n"
15993  "\n"
15994  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
15995  " vertices.\n"
15996  "\n"
15997  ""},
15998  { "plgradient", _wrap_plgradient, METH_VARARGS, "\n"
15999  "Draw linear gradient inside polygon\n"
16000  "\n"
16001  "DESCRIPTION:\n"
16002  "\n"
16003  " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
16004  " points (\n"
16005  " x[i],\n"
16006  " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16007  " polygon coordinates and the gradient angle are all expressed in world\n"
16008  " coordinates. The angle from the x axis for both the rotated\n"
16009  " coordinate system and the gradient vector is specified by angle. The\n"
16010  " magnitude of the gradient vector is the difference between the maximum\n"
16011  " and minimum values of x for the vertices in the rotated coordinate\n"
16012  " system. The origin of the gradient vector can be interpreted as being\n"
16013  " anywhere on the line corresponding to the minimum x value for the\n"
16014  " vertices in the rotated coordinate system. The distance along the\n"
16015  " gradient vector is linearly transformed to the independent variable of\n"
16016  " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16017  " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16018  " color corresponding to the independent variable of cmap1. For more\n"
16019  " information about cmap1 (see the PLplot documentation).\n"
16020  "\n"
16021  " Redacted form: plgradient(x,y,angle)\n"
16022  "\n"
16023  " This function is used in examples 25 and 30.\n"
16024  "\n"
16025  "\n"
16026  "\n"
16027  "SYNOPSIS:\n"
16028  "\n"
16029  "plgradient(n, x, y, angle)\n"
16030  "\n"
16031  "ARGUMENTS:\n"
16032  "\n"
16033  " n (PLINT, input) : Number of vertices in polygon.\n"
16034  "\n"
16035  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16036  " vertices.\n"
16037  "\n"
16038  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16039  " vertices.\n"
16040  "\n"
16041  " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16042  " axis.\n"
16043  "\n"
16044  ""},
16045  { "plflush", _wrap_plflush, METH_NOARGS, "\n"
16046  "Flushes the output stream\n"
16047  "\n"
16048  "DESCRIPTION:\n"
16049  "\n"
16050  " Flushes the output stream. Use sparingly, if at all.\n"
16051  "\n"
16052  " Redacted form: plflush()\n"
16053  "\n"
16054  " This function is used in examples 1 and 14.\n"
16055  "\n"
16056  "\n"
16057  "\n"
16058  "SYNOPSIS:\n"
16059  "\n"
16060  "plflush()\n"
16061  "\n"
16062  ""},
16063  { "plfont", _wrap_plfont, METH_O, "\n"
16064  "Set font\n"
16065  "\n"
16066  "DESCRIPTION:\n"
16067  "\n"
16068  " Sets the font used for subsequent text and symbols. For devices that\n"
16069  " still use Hershey fonts this routine has no effect unless the Hershey\n"
16070  " fonts with extended character set are loaded (see plfontld). For\n"
16071  " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16072  " this routine calls the plsfci routine with argument set up\n"
16073  " appropriately for the various cases below. However, this method of\n"
16074  " specifying the font for unicode-aware devices is deprecated, and the\n"
16075  " much more flexible method of calling plsfont directly is recommended\n"
16076  " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16077  "\n"
16078  " Redacted form: plfont(ifont)\n"
16079  "\n"
16080  " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16081  "\n"
16082  "\n"
16083  "\n"
16084  "SYNOPSIS:\n"
16085  "\n"
16086  "plfont(ifont)\n"
16087  "\n"
16088  "ARGUMENTS:\n"
16089  "\n"
16090  " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16091  " (simplest and fastest)\n"
16092  " 2: Serif font\n"
16093  " 3: Italic font\n"
16094  " 4: Script font\n"
16095  "\n"
16096  ""},
16097  { "plfontld", _wrap_plfontld, METH_O, "\n"
16098  "Load Hershey fonts\n"
16099  "\n"
16100  "DESCRIPTION:\n"
16101  "\n"
16102  " Loads the Hershey fonts used for text and symbols. This routine may\n"
16103  " be called before or after initializing PLplot. If not explicitly\n"
16104  " called before PLplot initialization, then by default that\n"
16105  " initialization loads Hershey fonts with the extended character set.\n"
16106  " This routine only has a practical effect for devices that still use\n"
16107  " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16108  " system fonts instead of Hershey fonts).\n"
16109  "\n"
16110  " Redacted form: plfontld(fnt)\n"
16111  "\n"
16112  " This function is used in examples 1 and 7.\n"
16113  "\n"
16114  "\n"
16115  "\n"
16116  "SYNOPSIS:\n"
16117  "\n"
16118  "plfontld(fnt)\n"
16119  "\n"
16120  "ARGUMENTS:\n"
16121  "\n"
16122  " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16123  " A zero value specifies Hershey fonts with the standard character\n"
16124  " set and a non-zero value (the default assumed if plfontld is never\n"
16125  " called) specifies Hershey fonts with the extended character set.\n"
16126  "\n"
16127  ""},
16128  { "plgchr", _wrap_plgchr, METH_NOARGS, "\n"
16129  "Get character default height and current (scaled) height\n"
16130  "\n"
16131  "DESCRIPTION:\n"
16132  "\n"
16133  " Get character default height and current (scaled) height.\n"
16134  "\n"
16135  " Redacted form: plgchr(p_def, p_ht)\n"
16136  "\n"
16137  " This function is used in example 23.\n"
16138  "\n"
16139  "\n"
16140  "\n"
16141  "SYNOPSIS:\n"
16142  "\n"
16143  "plgchr(p_def, p_ht)\n"
16144  "\n"
16145  "ARGUMENTS:\n"
16146  "\n"
16147  " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16148  " character height (mm).\n"
16149  "\n"
16150  " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16151  " character height (mm).\n"
16152  "\n"
16153  ""},
16154  { "plgcol0", _wrap_plgcol0, METH_O, "\n"
16155  "Returns 8-bit RGB values for given color index from cmap0\n"
16156  "\n"
16157  "DESCRIPTION:\n"
16158  "\n"
16159  " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16160  " PLplot documentation). Values are negative if an invalid color id is\n"
16161  " given.\n"
16162  "\n"
16163  " Redacted form: plgcol0(icol0, r, g, b)\n"
16164  "\n"
16165  " This function is used in example 2.\n"
16166  "\n"
16167  "\n"
16168  "\n"
16169  "SYNOPSIS:\n"
16170  "\n"
16171  "plgcol0(icol0, r, g, b)\n"
16172  "\n"
16173  "ARGUMENTS:\n"
16174  "\n"
16175  " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16176  "\n"
16177  " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16178  " value.\n"
16179  "\n"
16180  " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16181  " value.\n"
16182  "\n"
16183  " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16184  " value.\n"
16185  "\n"
16186  ""},
16187  { "plgcol0a", _wrap_plgcol0a, METH_O, "\n"
16188  "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16189  "\n"
16190  "DESCRIPTION:\n"
16191  "\n"
16192  " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16193  " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16194  " Values are negative if an invalid color id is given.\n"
16195  "\n"
16196  " Redacted form: plgcola(r, g, b)\n"
16197  "\n"
16198  " This function is used in example 30.\n"
16199  "\n"
16200  "\n"
16201  "\n"
16202  "SYNOPSIS:\n"
16203  "\n"
16204  "plgcol0a(icol0, r, g, b, alpha)\n"
16205  "\n"
16206  "ARGUMENTS:\n"
16207  "\n"
16208  " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16209  "\n"
16210  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16211  " in the range from 0 to 255.\n"
16212  "\n"
16213  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16214  " in the range from 0 to 255.\n"
16215  "\n"
16216  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16217  " in the range from 0 to 255.\n"
16218  "\n"
16219  " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16220  " transparency in the range from (0.0-1.0).\n"
16221  "\n"
16222  ""},
16223  { "plgcolbg", _wrap_plgcolbg, METH_NOARGS, "\n"
16224  "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16225  "\n"
16226  "DESCRIPTION:\n"
16227  "\n"
16228  " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16229  "\n"
16230  " Redacted form: plgcolbg(r, g, b)\n"
16231  "\n"
16232  " This function is used in example 31.\n"
16233  "\n"
16234  "\n"
16235  "\n"
16236  "SYNOPSIS:\n"
16237  "\n"
16238  "plgcolbg(r, g, b)\n"
16239  "\n"
16240  "ARGUMENTS:\n"
16241  "\n"
16242  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16243  " in the range from 0 to 255.\n"
16244  "\n"
16245  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16246  " in the range from 0 to 255.\n"
16247  "\n"
16248  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16249  " in the range from 0 to 255.\n"
16250  "\n"
16251  ""},
16252  { "plgcolbga", _wrap_plgcolbga, METH_NOARGS, "\n"
16253  "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
16254  "\n"
16255  "DESCRIPTION:\n"
16256  "\n"
16257  " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
16258  " alpha transparency value.\n"
16259  "\n"
16260  " This function is used in example 31.\n"
16261  "\n"
16262  "\n"
16263  "\n"
16264  "SYNOPSIS:\n"
16265  "\n"
16266  "plgcolbga(r, g, b, alpha)\n"
16267  "\n"
16268  "ARGUMENTS:\n"
16269  "\n"
16270  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16271  " in the range from 0 to 255.\n"
16272  "\n"
16273  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16274  " in the range from 0 to 255.\n"
16275  "\n"
16276  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16277  " in the range from 0 to 255.\n"
16278  "\n"
16279  " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16280  " transparency in the range (0.0-1.0).\n"
16281  "\n"
16282  ""},
16283  { "plgcompression", _wrap_plgcompression, METH_NOARGS, "\n"
16284  "Get the current device-compression setting\n"
16285  "\n"
16286  "DESCRIPTION:\n"
16287  "\n"
16288  " Get the current device-compression setting. This parameter is only\n"
16289  " used for drivers that provide compression.\n"
16290  "\n"
16291  " Redacted form: plgcompression(compression)\n"
16292  "\n"
16293  " This function is used in example 31.\n"
16294  "\n"
16295  "\n"
16296  "\n"
16297  "SYNOPSIS:\n"
16298  "\n"
16299  "plgcompression(compression)\n"
16300  "\n"
16301  "ARGUMENTS:\n"
16302  "\n"
16303  " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
16304  " compression setting for the current device.\n"
16305  "\n"
16306  ""},
16307  { "plgdev", _wrap_plgdev, METH_NOARGS, "\n"
16308  "Get the current device (keyword) name\n"
16309  "\n"
16310  "DESCRIPTION:\n"
16311  "\n"
16312  " Get the current device (keyword) name. Note: you must have allocated\n"
16313  " space for this (80 characters is safe).\n"
16314  "\n"
16315  " Redacted form: plgdev(p_dev)\n"
16316  "\n"
16317  " This function is used in example 14.\n"
16318  "\n"
16319  "\n"
16320  "\n"
16321  "SYNOPSIS:\n"
16322  "\n"
16323  "plgdev(p_dev)\n"
16324  "\n"
16325  "ARGUMENTS:\n"
16326  "\n"
16327  " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16328  " (with preallocated length of 80 characters or more) containing the\n"
16329  " device (keyword) name.\n"
16330  "\n"
16331  ""},
16332  { "plgdidev", _wrap_plgdidev, METH_NOARGS, "\n"
16333  "Get parameters that define current device-space window\n"
16334  "\n"
16335  "DESCRIPTION:\n"
16336  "\n"
16337  " Get relative margin width, aspect ratio, and relative justification\n"
16338  " that define current device-space window. If plsdidev has not been\n"
16339  " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
16340  " p_jy will all be 0.\n"
16341  "\n"
16342  " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16343  "\n"
16344  " This function is used in example 31.\n"
16345  "\n"
16346  "\n"
16347  "\n"
16348  "SYNOPSIS:\n"
16349  "\n"
16350  "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16351  "\n"
16352  "ARGUMENTS:\n"
16353  "\n"
16354  " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16355  " margin width.\n"
16356  "\n"
16357  " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
16358  " ratio.\n"
16359  "\n"
16360  " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16361  " justification in x.\n"
16362  "\n"
16363  " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16364  " justification in y.\n"
16365  "\n"
16366  ""},
16367  { "plgdiori", _wrap_plgdiori, METH_NOARGS, "\n"
16368  "Get plot orientation\n"
16369  "\n"
16370  "DESCRIPTION:\n"
16371  "\n"
16372  " Get plot orientation parameter which is multiplied by 90 degrees to\n"
16373  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
16374  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
16375  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
16376  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
16377  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
16378  " not been called the default value pointed to by p_rot will be 0.\n"
16379  "\n"
16380  " Redacted form: plgdiori(p_rot)\n"
16381  "\n"
16382  " This function is not used in any examples.\n"
16383  "\n"
16384  "\n"
16385  "\n"
16386  "SYNOPSIS:\n"
16387  "\n"
16388  "plgdiori(p_rot)\n"
16389  "\n"
16390  "ARGUMENTS:\n"
16391  "\n"
16392  " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
16393  " parameter.\n"
16394  "\n"
16395  ""},
16396  { "plgdiplt", _wrap_plgdiplt, METH_NOARGS, "\n"
16397  "Get parameters that define current plot-space window\n"
16398  "\n"
16399  "DESCRIPTION:\n"
16400  "\n"
16401  " Get relative minima and maxima that define current plot-space window.\n"
16402  " If plsdiplt has not been called the default values pointed to by\n"
16403  " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
16404  "\n"
16405  " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16406  "\n"
16407  " This function is used in example 31.\n"
16408  "\n"
16409  "\n"
16410  "\n"
16411  "SYNOPSIS:\n"
16412  "\n"
16413  "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16414  "\n"
16415  "ARGUMENTS:\n"
16416  "\n"
16417  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16418  " minimum in x.\n"
16419  "\n"
16420  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16421  " minimum in y.\n"
16422  "\n"
16423  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16424  " maximum in x.\n"
16425  "\n"
16426  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16427  " maximum in y.\n"
16428  "\n"
16429  ""},
16430  { "plgfam", _wrap_plgfam, METH_NOARGS, "\n"
16431  "Get family file parameters\n"
16432  "\n"
16433  "DESCRIPTION:\n"
16434  "\n"
16435  " Gets information about current family file, if familying is enabled.\n"
16436  " See the PLplot documentation for more information.\n"
16437  "\n"
16438  " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
16439  "\n"
16440  " This function is used in examples 14 and 31.\n"
16441  "\n"
16442  "\n"
16443  "\n"
16444  "SYNOPSIS:\n"
16445  "\n"
16446  "plgfam(p_fam, p_num, p_bmax)\n"
16447  "\n"
16448  "ARGUMENTS:\n"
16449  "\n"
16450  " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16451  " family flag value. If nonzero, familying is enabled for the\n"
16452  " current device.\n"
16453  "\n"
16454  " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16455  " family file number.\n"
16456  "\n"
16457  " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16458  " file size (in bytes) for a family file.\n"
16459  "\n"
16460  ""},
16461  { "plgfci", _wrap_plgfci, METH_NOARGS, "\n"
16462  "Get FCI (font characterization integer)\n"
16463  "\n"
16464  "DESCRIPTION:\n"
16465  "\n"
16466  " Gets information about the current font using the FCI approach. See\n"
16467  " the PLplot documentation for more information.\n"
16468  "\n"
16469  " Redacted form: plgfci(p_fci)\n"
16470  "\n"
16471  " This function is used in example 23.\n"
16472  "\n"
16473  "\n"
16474  "\n"
16475  "SYNOPSIS:\n"
16476  "\n"
16477  "plgfci(p_fci)\n"
16478  "\n"
16479  "ARGUMENTS:\n"
16480  "\n"
16481  " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
16482  " FCI value.\n"
16483  "\n"
16484  ""},
16485  { "plgfnam", _wrap_plgfnam, METH_NOARGS, "\n"
16486  "Get output file name\n"
16487  "\n"
16488  "DESCRIPTION:\n"
16489  "\n"
16490  " Gets the current output file name, if applicable.\n"
16491  "\n"
16492  " Redacted form: plgfnam(fnam)\n"
16493  "\n"
16494  " This function is used in example 31.\n"
16495  "\n"
16496  "\n"
16497  "\n"
16498  "SYNOPSIS:\n"
16499  "\n"
16500  "plgfnam(fnam)\n"
16501  "\n"
16502  "ARGUMENTS:\n"
16503  "\n"
16504  " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16505  " (with preallocated length of 80 characters or more) containing the\n"
16506  " file name.\n"
16507  "\n"
16508  ""},
16509  { "plgfont", _wrap_plgfont, METH_NOARGS, "\n"
16510  "Get family, style and weight of the current font\n"
16511  "\n"
16512  "DESCRIPTION:\n"
16513  "\n"
16514  " Gets information about current font. See the PLplot documentation for\n"
16515  " more information on font selection.\n"
16516  "\n"
16517  " Redacted form: plgfont(p_family, p_style, p_weight)\n"
16518  "\n"
16519  " This function is used in example 23.\n"
16520  "\n"
16521  "\n"
16522  "\n"
16523  "SYNOPSIS:\n"
16524  "\n"
16525  "plgfont(p_family, p_style, p_weight)\n"
16526  "\n"
16527  "ARGUMENTS:\n"
16528  "\n"
16529  " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16530  " font family. The available values are given by the PL_FCI_*\n"
16531  " constants in plplot.h. Current options are PL_FCI_SANS,\n"
16532  " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
16533  " p_family is NULL then the font family is not returned.\n"
16534  "\n"
16535  " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16536  " font style. The available values are given by the PL_FCI_*\n"
16537  " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
16538  " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
16539  " style is not returned.\n"
16540  "\n"
16541  " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16542  " font weight. The available values are given by the PL_FCI_*\n"
16543  " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
16544  " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
16545  " returned.\n"
16546  "\n"
16547  ""},
16548  { "plglevel", _wrap_plglevel, METH_NOARGS, "\n"
16549  "Get the (current) run level\n"
16550  "\n"
16551  "DESCRIPTION:\n"
16552  "\n"
16553  " Get the (current) run level. Valid settings are: 0, uninitialized\n"
16554  " 1, initialized\n"
16555  " 2, viewport defined\n"
16556  " 3, world coordinates defined\n"
16557  "\n"
16558  "\n"
16559  " Redacted form: plglevel(p_level)\n"
16560  "\n"
16561  " This function is used in example 31.\n"
16562  "\n"
16563  "\n"
16564  "\n"
16565  "SYNOPSIS:\n"
16566  "\n"
16567  "plglevel(p_level)\n"
16568  "\n"
16569  "ARGUMENTS:\n"
16570  "\n"
16571  " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
16572  " level.\n"
16573  "\n"
16574  ""},
16575  { "plgpage", _wrap_plgpage, METH_NOARGS, "\n"
16576  "Get page parameters\n"
16577  "\n"
16578  "DESCRIPTION:\n"
16579  "\n"
16580  " Gets the current page configuration. The length and offset values are\n"
16581  " expressed in units that are specific to the current driver. For\n"
16582  " instance: screen drivers will usually interpret them as number of\n"
16583  " pixels, whereas printer drivers will usually use mm.\n"
16584  "\n"
16585  " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
16586  "\n"
16587  " This function is used in examples 14 and 31.\n"
16588  "\n"
16589  "\n"
16590  "\n"
16591  "SYNOPSIS:\n"
16592  "\n"
16593  "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
16594  "\n"
16595  "ARGUMENTS:\n"
16596  "\n"
16597  " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
16598  " pixels/inch (DPI) in x.\n"
16599  "\n"
16600  " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
16601  " pixels/inch (DPI) in y.\n"
16602  "\n"
16603  " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
16604  " length.\n"
16605  "\n"
16606  " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
16607  " length.\n"
16608  "\n"
16609  " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
16610  " offset.\n"
16611  "\n"
16612  " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
16613  " offset.\n"
16614  "\n"
16615  ""},
16616  { "plgra", _wrap_plgra, METH_NOARGS, "\n"
16617  "Switch to graphics screen\n"
16618  "\n"
16619  "DESCRIPTION:\n"
16620  "\n"
16621  " Sets an interactive device to graphics mode, used in conjunction with\n"
16622  " pltext to allow graphics and text to be interspersed. On a device\n"
16623  " which supports separate text and graphics windows, this command causes\n"
16624  " control to be switched to the graphics window. If already in graphics\n"
16625  " mode, this command is ignored. It is also ignored on devices which\n"
16626  " only support a single window or use a different method for shifting\n"
16627  " focus. See also pltext.\n"
16628  "\n"
16629  " Redacted form: plgra()\n"
16630  "\n"
16631  " This function is used in example 1.\n"
16632  "\n"
16633  "\n"
16634  "\n"
16635  "SYNOPSIS:\n"
16636  "\n"
16637  "plgra()\n"
16638  "\n"
16639  ""},
16640  { "plgriddata", _wrap_plgriddata, METH_VARARGS, "\n"
16641  "Grid data from irregularly sampled data\n"
16642  "\n"
16643  "DESCRIPTION:\n"
16644  "\n"
16645  " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
16646  " require data organized as a grid, i.e., with x sample point values\n"
16647  " independent of y coordinate and vice versa. This function takes\n"
16648  " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
16649  " vectors; reads the desired grid location from the input vectors\n"
16650  " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
16651  " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
16652  " interpolate the data to the grid is specified with the argument type\n"
16653  " which can have one parameter specified in argument data.\n"
16654  "\n"
16655  " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
16656  " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
16657  "\n"
16658  "\n"
16659  " This function is used in example 21.\n"
16660  "\n"
16661  "\n"
16662  "\n"
16663  "SYNOPSIS:\n"
16664  "\n"
16665  "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
16666  "\n"
16667  "ARGUMENTS:\n"
16668  "\n"
16669  " x (PLFLT_VECTOR, input) : The input x vector.\n"
16670  "\n"
16671  " y (PLFLT_VECTOR, input) : The input y vector.\n"
16672  "\n"
16673  " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
16674  " y[i], z[i] represents one data sample coordinate.\n"
16675  "\n"
16676  " npts (PLINT, input) : The number of data samples in the x, y and z\n"
16677  " vectors.\n"
16678  "\n"
16679  " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
16680  " in the x direction. Usually xg has nptsx equally spaced values\n"
16681  " from the minimum to the maximum values of the x input vector.\n"
16682  "\n"
16683  " nptsx (PLINT, input) : The number of points in the xg vector.\n"
16684  "\n"
16685  " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
16686  " in the y direction. Similar to the xg parameter.\n"
16687  "\n"
16688  " nptsy (PLINT, input) : The number of points in the yg vector.\n"
16689  "\n"
16690  " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
16691  " where data lies in the grid specified by xg and yg. Therefore the\n"
16692  " zg matrix must be dimensioned\n"
16693  " nptsx by\n"
16694  " nptsy.\n"
16695  "\n"
16696  " type (PLINT, input) : The type of grid interpolation algorithm to\n"
16697  " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
16698  " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
16699  " GRID_NNI: Natural Neighbors Interpolation\n"
16700  " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
16701  " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
16702  " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
16703  " Weighted\n"
16704  " For details of the algorithms read the source file plgridd.c.\n"
16705  "\n"
16706  " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
16707  " which can be specified through this argument. Currently, for\n"
16708  " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
16709  " use, the lower the value, the noisier (more local) the\n"
16710  " approximation is.\n"
16711  " GRID_NNLI, data specifies what a thin triangle is, in the\n"
16712  " range [1. .. 2.]. High values enable the usage of very thin\n"
16713  " triangles for interpolation, possibly resulting in error in\n"
16714  " the approximation.\n"
16715  " GRID_NNI, only weights greater than data will be accepted. If\n"
16716  " 0, all weights will be accepted.\n"
16717  "\n"
16718  ""},
16719  { "plgspa", _wrap_plgspa, METH_NOARGS, "\n"
16720  "Get current subpage parameters\n"
16721  "\n"
16722  "DESCRIPTION:\n"
16723  "\n"
16724  " Gets the size of the current subpage in millimeters measured from the\n"
16725  " bottom left hand corner of the output device page or screen. Can be\n"
16726  " used in conjunction with plsvpa for setting the size of a viewport in\n"
16727  " absolute coordinates (millimeters).\n"
16728  "\n"
16729  " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
16730  "\n"
16731  " This function is used in example 23.\n"
16732  "\n"
16733  "\n"
16734  "\n"
16735  "SYNOPSIS:\n"
16736  "\n"
16737  "plgspa(xmin, xmax, ymin, ymax)\n"
16738  "\n"
16739  "ARGUMENTS:\n"
16740  "\n"
16741  " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16742  " the left hand edge of the subpage in millimeters.\n"
16743  "\n"
16744  " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16745  " the right hand edge of the subpage in millimeters.\n"
16746  "\n"
16747  " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16748  " the bottom edge of the subpage in millimeters.\n"
16749  "\n"
16750  " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16751  " the top edge of the subpage in millimeters.\n"
16752  "\n"
16753  ""},
16754  { "plgstrm", _wrap_plgstrm, METH_NOARGS, "\n"
16755  "Get current stream number\n"
16756  "\n"
16757  "DESCRIPTION:\n"
16758  "\n"
16759  " Gets the number of the current output stream. See also plsstrm.\n"
16760  "\n"
16761  " Redacted form: plgstrm(p_strm)\n"
16762  "\n"
16763  " This function is used in example 1,20.\n"
16764  "\n"
16765  "\n"
16766  "\n"
16767  "SYNOPSIS:\n"
16768  "\n"
16769  "plgstrm(p_strm)\n"
16770  "\n"
16771  "ARGUMENTS:\n"
16772  "\n"
16773  " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16774  " stream value.\n"
16775  "\n"
16776  ""},
16777  { "plgver", _wrap_plgver, METH_NOARGS, "\n"
16778  "Get the current library version number\n"
16779  "\n"
16780  "DESCRIPTION:\n"
16781  "\n"
16782  " Get the current library version number. Note: you must have allocated\n"
16783  " space for this (80 characters is safe).\n"
16784  "\n"
16785  " Redacted form: plgver(p_ver)\n"
16786  "\n"
16787  " This function is used in example 1.\n"
16788  "\n"
16789  "\n"
16790  "\n"
16791  "SYNOPSIS:\n"
16792  "\n"
16793  "plgver(p_ver)\n"
16794  "\n"
16795  "ARGUMENTS:\n"
16796  "\n"
16797  " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16798  " (with preallocated length of 80 characters or more) containing the\n"
16799  " PLplot version number.\n"
16800  "\n"
16801  ""},
16802  { "plgvpd", _wrap_plgvpd, METH_NOARGS, "\n"
16803  "Get viewport limits in normalized device coordinates\n"
16804  "\n"
16805  "DESCRIPTION:\n"
16806  "\n"
16807  " Get viewport limits in normalized device coordinates.\n"
16808  "\n"
16809  " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16810  "\n"
16811  "\n"
16812  " This function is used in example 31.\n"
16813  "\n"
16814  "\n"
16815  "\n"
16816  "SYNOPSIS:\n"
16817  "\n"
16818  "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16819  "\n"
16820  "ARGUMENTS:\n"
16821  "\n"
16822  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16823  " viewport limit of the normalized device coordinate in x.\n"
16824  "\n"
16825  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16826  " viewport limit of the normalized device coordinate in x.\n"
16827  "\n"
16828  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16829  " viewport limit of the normalized device coordinate in y.\n"
16830  "\n"
16831  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16832  " viewport limit of the normalized device coordinate in y.\n"
16833  "\n"
16834  ""},
16835  { "plgvpw", _wrap_plgvpw, METH_NOARGS, "\n"
16836  "Get viewport limits in world coordinates\n"
16837  "\n"
16838  "DESCRIPTION:\n"
16839  "\n"
16840  " Get viewport limits in world coordinates.\n"
16841  "\n"
16842  " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16843  "\n"
16844  "\n"
16845  " This function is used in example 31.\n"
16846  "\n"
16847  "\n"
16848  "\n"
16849  "SYNOPSIS:\n"
16850  "\n"
16851  "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16852  "\n"
16853  "ARGUMENTS:\n"
16854  "\n"
16855  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16856  " viewport limit of the world coordinate in x.\n"
16857  "\n"
16858  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16859  " viewport limit of the world coordinate in x.\n"
16860  "\n"
16861  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16862  " viewport limit of the world coordinate in y.\n"
16863  "\n"
16864  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16865  " viewport limit of the world coordinate in y.\n"
16866  "\n"
16867  ""},
16868  { "plgxax", _wrap_plgxax, METH_NOARGS, "\n"
16869  "Get x axis parameters\n"
16870  "\n"
16871  "DESCRIPTION:\n"
16872  "\n"
16873  " Returns current values of the p_digmax and p_digits flags for the x\n"
16874  " axis. p_digits is updated after the plot is drawn, so this routine\n"
16875  " should only be called after the call to plbox (or plbox3) is complete.\n"
16876  " See the PLplot documentation for more information.\n"
16877  "\n"
16878  " Redacted form: plgxax(p_digmax, p_digits)\n"
16879  "\n"
16880  " This function is used in example 31.\n"
16881  "\n"
16882  "\n"
16883  "\n"
16884  "SYNOPSIS:\n"
16885  "\n"
16886  "plgxax(p_digmax, p_digits)\n"
16887  "\n"
16888  "ARGUMENTS:\n"
16889  "\n"
16890  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16891  " number of digits for the x axis. If nonzero, the printed label\n"
16892  " has been switched to a floating-point representation when the\n"
16893  " number of digits exceeds this value.\n"
16894  "\n"
16895  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
16896  " number of digits for the numeric labels (x axis) from the last\n"
16897  " plot.\n"
16898  "\n"
16899  ""},
16900  { "plgyax", _wrap_plgyax, METH_NOARGS, "\n"
16901  "Get y axis parameters\n"
16902  "\n"
16903  "DESCRIPTION:\n"
16904  "\n"
16905  " Identical to plgxax, except that arguments are flags for y axis. See\n"
16906  " the description of plgxax for more detail.\n"
16907  "\n"
16908  " Redacted form: plgyax(p_digmax, p_digits)\n"
16909  "\n"
16910  " This function is used in example 31.\n"
16911  "\n"
16912  "\n"
16913  "\n"
16914  "SYNOPSIS:\n"
16915  "\n"
16916  "plgyax(p_digmax, p_digits)\n"
16917  "\n"
16918  "ARGUMENTS:\n"
16919  "\n"
16920  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16921  " number of digits for the y axis. If nonzero, the printed label\n"
16922  " has been switched to a floating-point representation when the\n"
16923  " number of digits exceeds this value.\n"
16924  "\n"
16925  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
16926  " number of digits for the numeric labels (y axis) from the last\n"
16927  " plot.\n"
16928  "\n"
16929  ""},
16930  { "plgzax", _wrap_plgzax, METH_NOARGS, "\n"
16931  "Get z axis parameters\n"
16932  "\n"
16933  "DESCRIPTION:\n"
16934  "\n"
16935  " Identical to plgxax, except that arguments are flags for z axis. See\n"
16936  " the description of plgxax for more detail.\n"
16937  "\n"
16938  " Redacted form: plgzax(p_digmax, p_digits)\n"
16939  "\n"
16940  " This function is used in example 31.\n"
16941  "\n"
16942  "\n"
16943  "\n"
16944  "SYNOPSIS:\n"
16945  "\n"
16946  "plgzax(p_digmax, p_digits)\n"
16947  "\n"
16948  "ARGUMENTS:\n"
16949  "\n"
16950  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16951  " number of digits for the z axis. If nonzero, the printed label\n"
16952  " has been switched to a floating-point representation when the\n"
16953  " number of digits exceeds this value.\n"
16954  "\n"
16955  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
16956  " number of digits for the numeric labels (z axis) from the last\n"
16957  " plot.\n"
16958  "\n"
16959  ""},
16960  { "plhist", _wrap_plhist, METH_VARARGS, "\n"
16961  "Plot a histogram from unbinned data\n"
16962  "\n"
16963  "DESCRIPTION:\n"
16964  "\n"
16965  " Plots a histogram from n data points stored in the data vector. This\n"
16966  " routine bins the data into nbin bins equally spaced between datmin and\n"
16967  " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
16968  " opt allows, among other things, the histogram either to be plotted in\n"
16969  " an existing window or causes plhist to call plenv with suitable limits\n"
16970  " before plotting the histogram.\n"
16971  "\n"
16972  " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
16973  "\n"
16974  " This function is used in example 5.\n"
16975  "\n"
16976  "\n"
16977  "\n"
16978  "SYNOPSIS:\n"
16979  "\n"
16980  "plhist(n, data, datmin, datmax, nbin, opt)\n"
16981  "\n"
16982  "ARGUMENTS:\n"
16983  "\n"
16984  " n (PLINT, input) : Number of data points.\n"
16985  "\n"
16986  " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
16987  " n data points.\n"
16988  "\n"
16989  " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
16990  "\n"
16991  " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
16992  "\n"
16993  " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
16994  " divide the interval xmin to xmax.\n"
16995  "\n"
16996  " opt (PLINT, input) : Is a combination of several flags:\n"
16997  " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
16998  " the histogram data, the outer bins are expanded to fill up the\n"
16999  " entire x-axis, data outside the given extremes are assigned to the\n"
17000  " outer bins and bins of zero height are simply drawn.\n"
17001  " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17002  " to fit the histogram data, without this flag, plenv is called\n"
17003  " to set the world coordinates.\n"
17004  " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17005  " extremes are not taken into account. This option should\n"
17006  " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17007  " properly present the data.\n"
17008  " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17009  " size as the ones inside.\n"
17010  " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17011  " (there is a gap for such bins).\n"
17012  "\n"
17013  ""},
17014  { "plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, "\n"
17015  "Convert HLS color to RGB\n"
17016  "\n"
17017  "DESCRIPTION:\n"
17018  "\n"
17019  " Convert HLS color coordinates to RGB.\n"
17020  "\n"
17021  " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17022  "\n"
17023  "\n"
17024  " This function is used in example 2.\n"
17025  "\n"
17026  "\n"
17027  "\n"
17028  "SYNOPSIS:\n"
17029  "\n"
17030  "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17031  "\n"
17032  "ARGUMENTS:\n"
17033  "\n"
17034  " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17035  " cylinder.\n"
17036  "\n"
17037  " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17038  " the axis of the color cylinder.\n"
17039  "\n"
17040  " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17041  " the radius of the color cylinder.\n"
17042  "\n"
17043  " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17044  " (0.0-1.0) of the color.\n"
17045  "\n"
17046  " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17047  " intensity (0.0-1.0) of the color.\n"
17048  "\n"
17049  " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17050  " intensity (0.0-1.0) of the color.\n"
17051  "\n"
17052  ""},
17053  { "plinit", _wrap_plinit, METH_NOARGS, "\n"
17054  "Initialize PLplot\n"
17055  "\n"
17056  "DESCRIPTION:\n"
17057  "\n"
17058  " Initializing the plotting package. The program prompts for the device\n"
17059  " keyword or number of the desired output device. Hitting a RETURN in\n"
17060  " response to the prompt is the same as selecting the first device.\n"
17061  " plinit will issue no prompt if either the device was specified\n"
17062  " previously (via command line flag, the plsetopt function, or the\n"
17063  " plsdev function), or if only one device is enabled when PLplot is\n"
17064  " installed. If subpages have been specified, the output device is\n"
17065  " divided into nx by ny subpages, each of which may be used\n"
17066  " independently. If plinit is called again during a program, the\n"
17067  " previously opened file will be closed. The subroutine pladv is used\n"
17068  " to advance from one subpage to the next.\n"
17069  "\n"
17070  " Redacted form: plinit()\n"
17071  "\n"
17072  " This function is used in all of the examples.\n"
17073  "\n"
17074  "\n"
17075  "\n"
17076  "SYNOPSIS:\n"
17077  "\n"
17078  "plinit()\n"
17079  "\n"
17080  ""},
17081  { "pljoin", _wrap_pljoin, METH_VARARGS, "\n"
17082  "Draw a line between two points\n"
17083  "\n"
17084  "DESCRIPTION:\n"
17085  "\n"
17086  " Joins the point (\n"
17087  " x1,\n"
17088  " y1) to (\n"
17089  " x2,\n"
17090  " y2).\n"
17091  "\n"
17092  " Redacted form: pljoin(x1,y1,x2,y2)\n"
17093  "\n"
17094  " This function is used in examples 3 and 14.\n"
17095  "\n"
17096  "\n"
17097  "\n"
17098  "SYNOPSIS:\n"
17099  "\n"
17100  "pljoin(x1, y1, x2, y2)\n"
17101  "\n"
17102  "ARGUMENTS:\n"
17103  "\n"
17104  " x1 (PLFLT, input) : x coordinate of first point.\n"
17105  "\n"
17106  " y1 (PLFLT, input) : y coordinate of first point.\n"
17107  "\n"
17108  " x2 (PLFLT, input) : x coordinate of second point.\n"
17109  "\n"
17110  " y2 (PLFLT, input) : y coordinate of second point.\n"
17111  "\n"
17112  ""},
17113  { "pllab", _wrap_pllab, METH_VARARGS, "\n"
17114  "Simple routine to write labels\n"
17115  "\n"
17116  "DESCRIPTION:\n"
17117  "\n"
17118  " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17119  "\n"
17120  " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17121  "\n"
17122  " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17123  "\n"
17124  "\n"
17125  "\n"
17126  "SYNOPSIS:\n"
17127  "\n"
17128  "pllab(xlabel, ylabel, tlabel)\n"
17129  "\n"
17130  "ARGUMENTS:\n"
17131  "\n"
17132  " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17133  " the label for the x axis.\n"
17134  "\n"
17135  " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17136  " the label for the y axis.\n"
17137  "\n"
17138  " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17139  " the title of the plot.\n"
17140  "\n"
17141  ""},
17142  { "pllegend", _wrap_pllegend, METH_VARARGS, "\n"
17143  "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17144  "\n"
17145  "DESCRIPTION:\n"
17146  "\n"
17147  " Routine for creating a discrete plot legend with a plotted filled box,\n"
17148  " line, and/or line of symbols for each annotated legend entry. (See\n"
17149  " plcolorbar for similar functionality for creating continuous color\n"
17150  " bars.) The arguments of pllegend provide control over the location\n"
17151  " and size of the legend as well as the location and characteristics of\n"
17152  " the elements (most of which are optional) within that legend. The\n"
17153  " resulting legend is clipped at the boundaries of the current subpage.\n"
17154  " (N.B. the adopted coordinate system used for some of the parameters is\n"
17155  " defined in the documentation of the position parameter.)\n"
17156  "\n"
17157  " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17158  " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17159  " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17160  " test_justification, text_colors, text, box_colors, box_patterns,\n"
17161  " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17162  " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17163  "\n"
17164  " This function is used in examples 4, 26, and 33.\n"
17165  "\n"
17166  "\n"
17167  "\n"
17168  "SYNOPSIS:\n"
17169  "\n"
17170  "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"
17171  "\n"
17172  "ARGUMENTS:\n"
17173  "\n"
17174  " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17175  " legend width in adopted coordinates. This quantity is calculated\n"
17176  " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17177  " the routine depending on nlegend and nrow), and the length\n"
17178  " (calculated internally) of the longest text string.\n"
17179  "\n"
17180  " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17181  " legend height in adopted coordinates. This quantity is calculated\n"
17182  " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17183  " the routine depending on nlegend and nrow).\n"
17184  "\n"
17185  " opt (PLINT, input) : opt contains bits controlling the overall\n"
17186  " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17187  " on the left of the legend and the plotted area on the right.\n"
17188  " Otherwise, put the text area on the right of the legend and the\n"
17189  " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17190  " plot a (semitransparent) background for the legend. If the\n"
17191  " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17192  " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17193  " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17194  " plot the resulting array of legend entries in row-major order.\n"
17195  " Otherwise, plot the legend entries in column-major order.\n"
17196  "\n"
17197  " position (PLINT, input) : position contains bits which control the\n"
17198  " overall position of the legend and the definition of the adopted\n"
17199  " coordinates used for positions just like what is done for the\n"
17200  " position argument for plcolorbar. However, note that the defaults\n"
17201  " for the position bits (see below) are different than the\n"
17202  " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17203  " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17204  " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17205  " the 16 possible standard positions (the 4 corners and centers of\n"
17206  " the 4 sides for both the inside and outside cases) of the legend\n"
17207  " relative to the adopted coordinate system. The corner positions\n"
17208  " are specified by the appropriate combination of two of the\n"
17209  " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17210  " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17211  " value of one of those bits. The adopted coordinates are\n"
17212  " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17213  " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17214  " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17215  " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17216  " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17217  " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17218  " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17219  " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17220  "\n"
17221  " x (PLFLT, input) : X offset of the legend position in adopted\n"
17222  " coordinates from the specified standard position of the legend.\n"
17223  " For positive x, the direction of motion away from the standard\n"
17224  " position is inward/outward from the standard corner positions or\n"
17225  " standard left or right positions if the\n"
17226  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17227  " For the standard top or bottom positions, the direction of motion\n"
17228  " is toward positive X.\n"
17229  "\n"
17230  " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17231  " coordinates from the specified standard position of the legend.\n"
17232  " For positive y, the direction of motion away from the standard\n"
17233  " position is inward/outward from the standard corner positions or\n"
17234  " standard top or bottom positions if the\n"
17235  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
17236  " the standard left or right positions, the direction of motion is\n"
17237  " toward positive Y.\n"
17238  "\n"
17239  " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17240  " of the plot area (where the colored boxes, lines, and/or lines of\n"
17241  " symbols are drawn) of the legend.\n"
17242  "\n"
17243  " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17244  " legend (PL_LEGEND_BACKGROUND).\n"
17245  "\n"
17246  " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17247  " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
17248  "\n"
17249  " bb_style (PLINT, input) : The pllsty style number for the\n"
17250  " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
17251  "\n"
17252  " nrow (PLINT, input) : The number of rows in the matrix used to\n"
17253  " render the\n"
17254  " nlegend legend entries. For internal transformations of\n"
17255  " nrow, see further remarks under\n"
17256  " nlegend.\n"
17257  "\n"
17258  " ncolumn (PLINT, input) : The number of columns in the matrix used\n"
17259  " to render the\n"
17260  " nlegend legend entries. For internal transformations of\n"
17261  " ncolumn, see further remarks under\n"
17262  " nlegend.\n"
17263  "\n"
17264  " nlegend (PLINT, input) : Number of legend entries. The above\n"
17265  " nrow and\n"
17266  " ncolumn values are transformed internally to be consistent with\n"
17267  " nlegend. If either\n"
17268  " nrow or\n"
17269  " ncolumn is non-positive it is replaced by 1. If the resulting product\n"
17270  " of\n"
17271  " nrow and\n"
17272  " ncolumn is less than\n"
17273  " nlegend, the smaller of the two (or\n"
17274  " nrow, if\n"
17275  " nrow ==\n"
17276  " ncolumn) is increased so the product is >=\n"
17277  " nlegend. Thus, for example, the common\n"
17278  " nrow = 0,\n"
17279  " ncolumn = 0 case is transformed internally to\n"
17280  " nrow =\n"
17281  " nlegend,\n"
17282  " ncolumn = 1; i.e., the usual case of a legend rendered as a single\n"
17283  " column.\n"
17284  "\n"
17285  " opt_array (PLINT_VECTOR, input) : A vector of\n"
17286  " nlegend values of options to control each individual plotted area\n"
17287  " corresponding to a legend entry. If the\n"
17288  " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
17289  " area. If the\n"
17290  " PL_LEGEND_COLOR_BOX,\n"
17291  " PL_LEGEND_LINE, and/or\n"
17292  " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
17293  " entry is plotted with a colored box; a line; and/or a line of\n"
17294  " symbols.\n"
17295  "\n"
17296  " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
17297  " area in units of character width.\n"
17298  "\n"
17299  " text_scale (PLFLT, input) : Character height scale for text\n"
17300  " annotations.\n"
17301  "\n"
17302  " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
17303  " character height from one legend entry to the next.\n"
17304  "\n"
17305  " text_justification (PLFLT, input) : Justification parameter used\n"
17306  " for text justification. The most common values of\n"
17307  " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
17308  " is left justified, centred, or right justified within the text\n"
17309  " area, but other values are allowed as well.\n"
17310  "\n"
17311  " text_colors (PLINT_VECTOR, input) : A vector containing\n"
17312  " nlegend cmap0 text colors.\n"
17313  "\n"
17314  " text (PLCHAR_MATRIX, input) : A vector of\n"
17315  " nlegend UTF-8 character strings containing the legend annotations.\n"
17316  "\n"
17317  " box_colors (PLINT_VECTOR, input) : A vector containing\n"
17318  " nlegend cmap0 colors for the discrete colored boxes (\n"
17319  " PL_LEGEND_COLOR_BOX).\n"
17320  "\n"
17321  " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
17322  " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
17323  " PL_LEGEND_COLOR_BOX).\n"
17324  "\n"
17325  " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
17326  " nlegend scales (units of fraction of character height) for the height\n"
17327  " of the discrete colored boxes (\n"
17328  " PL_LEGEND_COLOR_BOX).\n"
17329  "\n"
17330  " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
17331  " nlegend line widths for the patterns specified by box_patterns (\n"
17332  " PL_LEGEND_COLOR_BOX).\n"
17333  "\n"
17334  " line_colors (PLINT_VECTOR, input) : A vector containing\n"
17335  " nlegend cmap0 line colors (\n"
17336  " PL_LEGEND_LINE).\n"
17337  "\n"
17338  " line_styles (PLINT_VECTOR, input) : A vector containing\n"
17339  " nlegend line styles (plsty indices) (\n"
17340  " PL_LEGEND_LINE).\n"
17341  "\n"
17342  " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
17343  " nlegend line widths (\n"
17344  " PL_LEGEND_LINE).\n"
17345  "\n"
17346  " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
17347  " nlegend cmap0 symbol colors (\n"
17348  " PL_LEGEND_SYMBOL).\n"
17349  "\n"
17350  " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
17351  " nlegend scale values for the symbol height (\n"
17352  " PL_LEGEND_SYMBOL).\n"
17353  "\n"
17354  " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
17355  " nlegend numbers of symbols to be drawn across the width of the plotted\n"
17356  " area (\n"
17357  " PL_LEGEND_SYMBOL).\n"
17358  "\n"
17359  " symbols (PLCHAR_MATRIX, input) : A vector of\n"
17360  " nlegend UTF-8 character strings containing the legend symbols. (\n"
17361  " PL_LEGEND_SYMBOL).\n"
17362  "\n"
17363  ""},
17364  { "plcolorbar", _wrap_plcolorbar, METH_VARARGS, "\n"
17365  "Plot color bar for image, shade or gradient plots\n"
17366  "\n"
17367  "DESCRIPTION:\n"
17368  "\n"
17369  " Routine for creating a continuous color bar for image, shade, or\n"
17370  " gradient plots. (See pllegend for similar functionality for creating\n"
17371  " legends with discrete elements). The arguments of plcolorbar provide\n"
17372  " control over the location and size of the color bar as well as the\n"
17373  " location and characteristics of the elements (most of which are\n"
17374  " optional) within that color bar. The resulting color bar is clipped\n"
17375  " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
17376  " system used for some of the parameters is defined in the documentation\n"
17377  " of the position parameter.)\n"
17378  "\n"
17379  " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
17380  " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
17381  " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
17382  " labels, axis_opts, ticks, sub_ticks, values)\n"
17383  "\n"
17384  " This function is used in examples 16 and 33.\n"
17385  "\n"
17386  "\n"
17387  "\n"
17388  "SYNOPSIS:\n"
17389  "\n"
17390  "plcolorbar(p_colorbar_width, p_colorbar_height, opt, position, x, y, x_length, y_length, bg_color, bb_color, bb_style, low_cap_color, high_cap_color, cont_color, cont_width, n_labels, label_opts, labels, naxes, axis_opts, ticks, sub_ticks, n_values, values)\n"
17391  "\n"
17392  "ARGUMENTS:\n"
17393  "\n"
17394  " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17395  " labelled and decorated color bar width in adopted coordinates.\n"
17396  "\n"
17397  " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17398  " labelled and decorated color bar height in adopted coordinates.\n"
17399  "\n"
17400  " opt (PLINT, input) : opt contains bits controlling the overall\n"
17401  " color bar. The orientation (direction of the maximum value) of\n"
17402  " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
17403  " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
17404  " specified, the default orientation is toward the top if the\n"
17405  " colorbar is placed on the left or right of the viewport or toward\n"
17406  " the right if the colorbar is placed on the top or bottom of the\n"
17407  " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
17408  " (semitransparent) background for the color bar. If the\n"
17409  " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17410  " color bar. The type of color bar must be specified with one of\n"
17411  " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
17412  " more than one of those bits is set only the first one in the above\n"
17413  " list is honored. The position of the (optional) label/title can be\n"
17414  " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
17415  " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
17416  " will be drawn. If more than one of this list of bits is specified,\n"
17417  " only the first one on the list is honored. End-caps for the color\n"
17418  " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
17419  " If a particular color bar cap option is not specified then no cap\n"
17420  " will be drawn for that end. As a special case for\n"
17421  " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
17422  " specified. If this option is provided then any tick marks and tick\n"
17423  " labels will be placed at the breaks between shaded segments. TODO:\n"
17424  " This should be expanded to support custom placement of tick marks\n"
17425  " and tick labels at custom value locations for any color bar type.\n"
17426  "\n"
17427  " position (PLINT, input) : position contains bits which control the\n"
17428  " overall position of the color bar and the definition of the\n"
17429  " adopted coordinates used for positions just like what is done for\n"
17430  " the position argument for pllegend. However, note that the\n"
17431  " defaults for the position bits (see below) are different than the\n"
17432  " pllegend case. The combination of the PL_POSITION_LEFT,\n"
17433  " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17434  " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17435  " the 16 possible standard positions (the 4 corners and centers of\n"
17436  " the 4 sides for both the inside and outside cases) of the color\n"
17437  " bar relative to the adopted coordinate system. The corner\n"
17438  " positions are specified by the appropriate combination of two of\n"
17439  " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17440  " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17441  " value of one of those bits. The adopted coordinates are\n"
17442  " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17443  " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17444  " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17445  " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17446  " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
17447  " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
17448  " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
17449  " PL_POSITION_VIEWPORT.\n"
17450  "\n"
17451  " x (PLFLT, input) : X offset of the color bar position in adopted\n"
17452  " coordinates from the specified standard position of the color bar.\n"
17453  " For positive x, the direction of motion away from the standard\n"
17454  " position is inward/outward from the standard corner positions or\n"
17455  " standard left or right positions if the\n"
17456  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17457  " For the standard top or bottom positions, the direction of motion\n"
17458  " is toward positive X.\n"
17459  "\n"
17460  " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
17461  " coordinates from the specified standard position of the color bar.\n"
17462  " For positive y, the direction of motion away from the standard\n"
17463  " position is inward/outward from the standard corner positions or\n"
17464  " standard top or bottom positions if the\n"
17465  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17466  " For the standard left or right positions, the direction of motion\n"
17467  " is toward positive Y.\n"
17468  "\n"
17469  " x_length (PLFLT, input) : Length of the body of the color bar in\n"
17470  " the X direction in adopted coordinates.\n"
17471  "\n"
17472  " y_length (PLFLT, input) : Length of the body of the color bar in\n"
17473  " the Y direction in adopted coordinates.\n"
17474  "\n"
17475  " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17476  " color bar (PL_COLORBAR_BACKGROUND).\n"
17477  "\n"
17478  " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17479  " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
17480  "\n"
17481  " bb_style (PLINT, input) : The pllsty style number for the\n"
17482  " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
17483  "\n"
17484  " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
17485  " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
17486  "\n"
17487  " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
17488  " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
17489  "\n"
17490  " cont_color (PLINT, input) : The cmap0 contour color for\n"
17491  " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
17492  " it will be interpreted according to the design of plshades.\n"
17493  "\n"
17494  " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
17495  " plots. This is passed directly to plshades, so it will be\n"
17496  " interpreted according to the design of plshades.\n"
17497  "\n"
17498  " n_labels (PLINT, input) : Number of labels to place around the\n"
17499  " color bar.\n"
17500  "\n"
17501  " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
17502  " n_labels labels.\n"
17503  "\n"
17504  " labels (PLCHAR_MATRIX, input) : A vector of\n"
17505  " n_labels UTF-8 character strings containing the labels for the color\n"
17506  " bar. Ignored if no label position is specified with one of the\n"
17507  " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
17508  " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
17509  " corresponding label_opts field.\n"
17510  "\n"
17511  " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
17512  " value must be greater than 0. It is typically 1 (numerical axis\n"
17513  " labels are provided for one of the long edges of the color bar),\n"
17514  " but it can be larger if multiple numerical axis labels for the\n"
17515  " long edges of the color bar are desired.\n"
17516  "\n"
17517  " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
17518  " n_axes ascii character strings containing options (interpreted as for\n"
17519  " plbox) for the color bar's axis definitions.\n"
17520  "\n"
17521  " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
17522  " spacing of the major tick marks (interpreted as for plbox) for the\n"
17523  " color bar's axis definitions.\n"
17524  "\n"
17525  " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
17526  " number of subticks (interpreted as for plbox) for the color bar's\n"
17527  " axis definitions.\n"
17528  "\n"
17529  " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
17530  " elements in each of the n_axes rows of the values matrix.\n"
17531  "\n"
17532  " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
17533  " values for the data range represented by the color bar. For a row\n"
17534  " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
17535  " elements in the row is specified by n_values[i_axis]. For\n"
17536  " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
17537  " is 2, and the corresponding row elements of the values matrix are\n"
17538  " the minimum and maximum value represented by the colorbar. For\n"
17539  " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
17540  " of the values matrix is interpreted the same as the nlevel and\n"
17541  " clevel arguments of plshades.\n"
17542  "\n"
17543  ""},
17544  { "pllightsource", _wrap_pllightsource, METH_VARARGS, "\n"
17545  "Sets the 3D position of the light source\n"
17546  "\n"
17547  "DESCRIPTION:\n"
17548  "\n"
17549  " Sets the 3D position of the light source for use with plsurf3d and\n"
17550  " plsurf3dl\n"
17551  "\n"
17552  " Redacted form: pllightsource(x, y, z)\n"
17553  "\n"
17554  " This function is used in example 8.\n"
17555  "\n"
17556  "\n"
17557  "\n"
17558  "SYNOPSIS:\n"
17559  "\n"
17560  "pllightsource(x, y, z)\n"
17561  "\n"
17562  "ARGUMENTS:\n"
17563  "\n"
17564  " x (PLFLT, input) : X-coordinate of the light source.\n"
17565  "\n"
17566  " y (PLFLT, input) : Y-coordinate of the light source.\n"
17567  "\n"
17568  " z (PLFLT, input) : Z-coordinate of the light source.\n"
17569  "\n"
17570  ""},
17571  { "plline", _wrap_plline, METH_VARARGS, "\n"
17572  "Draw a line\n"
17573  "\n"
17574  "DESCRIPTION:\n"
17575  "\n"
17576  " Draws line defined by n points in x and y.\n"
17577  "\n"
17578  " Redacted form: plline(x, y)\n"
17579  "\n"
17580  " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
17581  " 25-27, and 29.\n"
17582  "\n"
17583  "\n"
17584  "\n"
17585  "SYNOPSIS:\n"
17586  "\n"
17587  "plline(n, x, y)\n"
17588  "\n"
17589  "ARGUMENTS:\n"
17590  "\n"
17591  " n (PLINT, input) : Number of points defining line.\n"
17592  "\n"
17593  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
17594  " points.\n"
17595  "\n"
17596  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
17597  " points.\n"
17598  "\n"
17599  ""},
17600  { "plline3", _wrap_plline3, METH_VARARGS, "\n"
17601  "Draw a line in 3 space\n"
17602  "\n"
17603  "DESCRIPTION:\n"
17604  "\n"
17605  " Draws line in 3 space defined by n points in x, y, and z. You must\n"
17606  " first set up the viewport, the 2d viewing window (in world\n"
17607  " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
17608  " more info.\n"
17609  "\n"
17610  " Redacted form: plline3(x, y, z)\n"
17611  "\n"
17612  " This function is used in example 18.\n"
17613  "\n"
17614  "\n"
17615  "\n"
17616  "SYNOPSIS:\n"
17617  "\n"
17618  "plline3(n, x, y, z)\n"
17619  "\n"
17620  "ARGUMENTS:\n"
17621  "\n"
17622  " n (PLINT, input) : Number of points defining line.\n"
17623  "\n"
17624  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
17625  " points.\n"
17626  "\n"
17627  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
17628  " points.\n"
17629  "\n"
17630  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
17631  " points.\n"
17632  "\n"
17633  ""},
17634  { "pllsty", _wrap_pllsty, METH_O, "\n"
17635  "Select line style\n"
17636  "\n"
17637  "DESCRIPTION:\n"
17638  "\n"
17639  " This sets the line style according to one of eight predefined patterns\n"
17640  " (also see plstyl).\n"
17641  "\n"
17642  " Redacted form: pllsty(lin)\n"
17643  "\n"
17644  " This function is used in examples 9, 12, 22, and 25.\n"
17645  "\n"
17646  "\n"
17647  "\n"
17648  "SYNOPSIS:\n"
17649  "\n"
17650  "pllsty(lin)\n"
17651  "\n"
17652  "ARGUMENTS:\n"
17653  "\n"
17654  " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
17655  " a continuous line, line style 2 is a line with short dashes and\n"
17656  " gaps, line style 3 is a line with long dashes and gaps, line style\n"
17657  " 4 has long dashes and short gaps and so on.\n"
17658  "\n"
17659  ""},
17660  { "plmesh", _wrap_plmesh, METH_VARARGS, "\n"
17661  "Plot surface mesh\n"
17662  "\n"
17663  "DESCRIPTION:\n"
17664  "\n"
17665  " Plots a surface mesh within the environment set up by plw3d. The\n"
17666  " surface is defined by the matrix z[\n"
17667  " nx][\n"
17668  " ny] , the point z[i][j] being the value of the function at (\n"
17669  " x[i],\n"
17670  " y[j]). Note that the points in vectors x and y do not need to be\n"
17671  " equally spaced, but must be stored in ascending order. The parameter\n"
17672  " opt controls the way in which the surface is displayed. For further\n"
17673  " details see the PLplot documentation.\n"
17674  "\n"
17675  " Redacted form: plmesh(x, y, z, opt)\n"
17676  "\n"
17677  " This function is used in example 11.\n"
17678  "\n"
17679  "\n"
17680  "\n"
17681  "SYNOPSIS:\n"
17682  "\n"
17683  "plmesh(x, y, z, nx, ny, opt)\n"
17684  "\n"
17685  "ARGUMENTS:\n"
17686  "\n"
17687  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
17688  " which the function is evaluated.\n"
17689  "\n"
17690  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
17691  " which the function is evaluated.\n"
17692  "\n"
17693  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
17694  " plot. Should have dimensions of\n"
17695  " nx by\n"
17696  " ny.\n"
17697  "\n"
17698  " nx (PLINT, input) : Number of x values at which function has been\n"
17699  " evaluated.\n"
17700  "\n"
17701  " ny (PLINT, input) : Number of y values at which function has been\n"
17702  " evaluated.\n"
17703  "\n"
17704  " opt (PLINT, input) : Determines the way in which the surface is\n"
17705  " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
17706  " function of x for each value of y[j] .\n"
17707  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
17708  " for each value of x[i] .\n"
17709  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
17710  " at which function is defined.\n"
17711  "\n"
17712  ""},
17713  { "plmeshc", _wrap_plmeshc, METH_VARARGS, "\n"
17714  "Magnitude colored plot surface mesh with contour\n"
17715  "\n"
17716  "DESCRIPTION:\n"
17717  "\n"
17718  " A more powerful form of plmesh: the surface mesh can be colored\n"
17719  " accordingly to the current z value being plotted, a contour plot can\n"
17720  " be drawn at the base XY plane, and a curtain can be drawn between the\n"
17721  " plotted function border and the base XY plane.\n"
17722  "\n"
17723  " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
17724  "\n"
17725  " This function is used in example 11.\n"
17726  "\n"
17727  "\n"
17728  "\n"
17729  "SYNOPSIS:\n"
17730  "\n"
17731  "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17732  "\n"
17733  "ARGUMENTS:\n"
17734  "\n"
17735  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
17736  " which the function is evaluated.\n"
17737  "\n"
17738  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
17739  " which the function is evaluated.\n"
17740  "\n"
17741  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
17742  " plot. Should have dimensions of\n"
17743  " nx by\n"
17744  " ny.\n"
17745  "\n"
17746  " nx (PLINT, input) : Number of x values at which function is\n"
17747  " evaluated.\n"
17748  "\n"
17749  " ny (PLINT, input) : Number of y values at which function is\n"
17750  " evaluated.\n"
17751  "\n"
17752  " opt (PLINT, input) : Determines the way in which the surface is\n"
17753  " represented. To specify more than one option just add the options,\n"
17754  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
17755  " showing z as a function of x for each value of y[j] .\n"
17756  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
17757  " for each value of x[i] .\n"
17758  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
17759  " at which function is defined.\n"
17760  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
17761  " the z value being plotted. The color is used from the current\n"
17762  " cmap1.\n"
17763  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
17764  " using parameters\n"
17765  " nlevel and\n"
17766  " clevel.\n"
17767  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
17768  " the borders of the plotted function.\n"
17769  "\n"
17770  "\n"
17771  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
17772  " levels.\n"
17773  "\n"
17774  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
17775  "\n"
17776  ""},
17777  { "plmkstrm", _wrap_plmkstrm, METH_NOARGS, "\n"
17778  "Creates a new stream and makes it the default\n"
17779  "\n"
17780  "DESCRIPTION:\n"
17781  "\n"
17782  " Creates a new stream and makes it the default. Differs from using\n"
17783  " plsstrm, in that a free stream number is found, and returned.\n"
17784  " Unfortunately, I have to start at stream 1 and work upward, since\n"
17785  " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
17786  " that no initial, library-opening call is required. So stream 0 must\n"
17787  " be preallocated, and there is no simple way of determining whether it\n"
17788  " is already in use or not.\n"
17789  "\n"
17790  " Redacted form: plmkstrm(p_strm)\n"
17791  "\n"
17792  " This function is used in examples 1 and 20.\n"
17793  "\n"
17794  "\n"
17795  "\n"
17796  "SYNOPSIS:\n"
17797  "\n"
17798  "plmkstrm(p_strm)\n"
17799  "\n"
17800  "ARGUMENTS:\n"
17801  "\n"
17802  " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
17803  " number of the created stream.\n"
17804  "\n"
17805  ""},
17806  { "plmtex", _wrap_plmtex, METH_VARARGS, "\n"
17807  "Write text relative to viewport boundaries\n"
17808  "\n"
17809  "DESCRIPTION:\n"
17810  "\n"
17811  " Writes text at a specified position relative to the viewport\n"
17812  " boundaries. Text may be written inside or outside the viewport, but\n"
17813  " is clipped at the subpage boundaries. The reference point of a string\n"
17814  " lies along a line passing through the string at half the height of a\n"
17815  " capital letter. The position of the reference point along this line\n"
17816  " is determined by just, and the position of the reference point\n"
17817  " relative to the viewport is set by disp and pos.\n"
17818  "\n"
17819  " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
17820  "\n"
17821  "\n"
17822  " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
17823  " 26.\n"
17824  "\n"
17825  "\n"
17826  "\n"
17827  "SYNOPSIS:\n"
17828  "\n"
17829  "plmtex(side, disp, pos, just, text)\n"
17830  "\n"
17831  "ARGUMENTS:\n"
17832  "\n"
17833  " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
17834  " the side of the viewport along which the text is to be written.\n"
17835  " The string must be one of: b: Bottom of viewport, text written\n"
17836  " parallel to edge.\n"
17837  " bv: Bottom of viewport, text written at right angles to edge.\n"
17838  " l: Left of viewport, text written parallel to edge.\n"
17839  " lv: Left of viewport, text written at right angles to edge.\n"
17840  " r: Right of viewport, text written parallel to edge.\n"
17841  " rv: Right of viewport, text written at right angles to edge.\n"
17842  " t: Top of viewport, text written parallel to edge.\n"
17843  " tv: Top of viewport, text written at right angles to edge.\n"
17844  "\n"
17845  "\n"
17846  " disp (PLFLT, input) : Position of the reference point of string,\n"
17847  " measured outwards from the specified viewport edge in units of the\n"
17848  " current character height. Use negative disp to write within the\n"
17849  " viewport.\n"
17850  "\n"
17851  " pos (PLFLT, input) : Position of the reference point of string\n"
17852  " along the specified edge, expressed as a fraction of the length of\n"
17853  " the edge.\n"
17854  "\n"
17855  " just (PLFLT, input) : Specifies the position of the string relative\n"
17856  " to its reference point. If just=0. , the reference point is at\n"
17857  " the left and if just=1. , it is at the right of the string. Other\n"
17858  " values of just give intermediate justifications.\n"
17859  "\n"
17860  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
17861  " written out.\n"
17862  "\n"
17863  ""},
17864  { "plmtex3", _wrap_plmtex3, METH_VARARGS, "\n"
17865  "Write text relative to viewport boundaries in 3D plots\n"
17866  "\n"
17867  "DESCRIPTION:\n"
17868  "\n"
17869  " Writes text at a specified position relative to the viewport\n"
17870  " boundaries. Text may be written inside or outside the viewport, but\n"
17871  " is clipped at the subpage boundaries. The reference point of a string\n"
17872  " lies along a line passing through the string at half the height of a\n"
17873  " capital letter. The position of the reference point along this line\n"
17874  " is determined by just, and the position of the reference point\n"
17875  " relative to the viewport is set by disp and pos.\n"
17876  "\n"
17877  " Redacted form: plmtex3(side, disp, pos, just, text)\n"
17878  "\n"
17879  " This function is used in example 28.\n"
17880  "\n"
17881  "\n"
17882  "\n"
17883  "SYNOPSIS:\n"
17884  "\n"
17885  "plmtex3(side, disp, pos, just, text)\n"
17886  "\n"
17887  "ARGUMENTS:\n"
17888  "\n"
17889  " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
17890  " the side of the viewport along which the text is to be written.\n"
17891  " The string should contain one or more of the following characters:\n"
17892  " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
17893  " only label the X axis, not both the X and Y axes. x: Label the X\n"
17894  " axis.\n"
17895  " y: Label the Y axis.\n"
17896  " z: Label the Z axis.\n"
17897  " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
17898  " For X it is the axis that starts at y-min. For Y it is the\n"
17899  " axis that starts at x-min.\n"
17900  " s: Label the secondary axis.\n"
17901  " v: Draw the text perpendicular to the axis.\n"
17902  "\n"
17903  "\n"
17904  " disp (PLFLT, input) : Position of the reference point of string,\n"
17905  " measured outwards from the specified viewport edge in units of the\n"
17906  " current character height. Use negative disp to write within the\n"
17907  " viewport.\n"
17908  "\n"
17909  " pos (PLFLT, input) : Position of the reference point of string\n"
17910  " along the specified edge, expressed as a fraction of the length of\n"
17911  " the edge.\n"
17912  "\n"
17913  " just (PLFLT, input) : Specifies the position of the string relative\n"
17914  " to its reference point. If just=0. , the reference point is at\n"
17915  " the left and if just=1. , it is at the right of the string. Other\n"
17916  " values of just give intermediate justifications.\n"
17917  "\n"
17918  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
17919  " written out.\n"
17920  "\n"
17921  ""},
17922  { "plot3d", _wrap_plot3d, METH_VARARGS, "\n"
17923  "Plot 3-d surface plot\n"
17924  "\n"
17925  "DESCRIPTION:\n"
17926  "\n"
17927  " Plots a three-dimensional surface plot within the environment set up\n"
17928  " by plw3d. The surface is defined by the matrix z[\n"
17929  " nx][\n"
17930  " ny] , the point z[i][j] being the value of the function at (\n"
17931  " x[i],\n"
17932  " y[j]). Note that the points in vectors x and y do not need to be\n"
17933  " equally spaced, but must be stored in ascending order. The parameter\n"
17934  " opt controls the way in which the surface is displayed. For further\n"
17935  " details see the PLplot documentation. The only difference between\n"
17936  " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
17937  " while plot3d only draws the surface as viewed from the top.\n"
17938  "\n"
17939  " Redacted form: plot3d(x, y, z, opt, side)\n"
17940  "\n"
17941  " This function is used in examples 11 and 21.\n"
17942  "\n"
17943  "\n"
17944  "\n"
17945  "SYNOPSIS:\n"
17946  "\n"
17947  "plot3d(x, y, z, nx, ny, opt, side)\n"
17948  "\n"
17949  "ARGUMENTS:\n"
17950  "\n"
17951  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
17952  " which the function is evaluated.\n"
17953  "\n"
17954  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
17955  " which the function is evaluated.\n"
17956  "\n"
17957  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
17958  " plot. Should have dimensions of\n"
17959  " nx by\n"
17960  " ny.\n"
17961  "\n"
17962  " nx (PLINT, input) : Number of x values at which function is\n"
17963  " evaluated.\n"
17964  "\n"
17965  " ny (PLINT, input) : Number of y values at which function is\n"
17966  " evaluated.\n"
17967  "\n"
17968  " opt (PLINT, input) : Determines the way in which the surface is\n"
17969  " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
17970  " function of x for each value of y[j] .\n"
17971  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
17972  " for each value of x[i] .\n"
17973  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
17974  " at which function is defined.\n"
17975  "\n"
17976  "\n"
17977  " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
17978  " should be draw on the figure. If side is true sides are drawn,\n"
17979  " otherwise no sides are drawn.\n"
17980  "\n"
17981  ""},
17982  { "plot3dc", _wrap_plot3dc, METH_VARARGS, "\n"
17983  "Magnitude colored plot surface with contour\n"
17984  "\n"
17985  "DESCRIPTION:\n"
17986  "\n"
17987  " Aside from dropping the\n"
17988  " side functionality this is a more powerful form of plot3d: the surface\n"
17989  " mesh can be colored accordingly to the current z value being plotted,\n"
17990  " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
17991  " drawn between the plotted function border and the base XY plane. The\n"
17992  " arguments are identical to those of plmeshc. The only difference\n"
17993  " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
17994  " the surface, while plot3dc only draws the surface as viewed from the\n"
17995  " top.\n"
17996  "\n"
17997  " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
17998  "\n"
17999  "\n"
18000  " This function is used in example 21.\n"
18001  "\n"
18002  "\n"
18003  "\n"
18004  "SYNOPSIS:\n"
18005  "\n"
18006  "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18007  "\n"
18008  "ARGUMENTS:\n"
18009  "\n"
18010  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18011  " which the function is evaluated.\n"
18012  "\n"
18013  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18014  " which the function is evaluated.\n"
18015  "\n"
18016  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18017  " plot. Should have dimensions of\n"
18018  " nx by\n"
18019  " ny.\n"
18020  "\n"
18021  " nx (PLINT, input) : Number of x values at which function is\n"
18022  " evaluated.\n"
18023  "\n"
18024  " ny (PLINT, input) : Number of y values at which function is\n"
18025  " evaluated.\n"
18026  "\n"
18027  " opt (PLINT, input) : Determines the way in which the surface is\n"
18028  " represented. To specify more than one option just add the options,\n"
18029  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18030  " showing z as a function of x for each value of y[j] .\n"
18031  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18032  " for each value of x[i] .\n"
18033  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18034  " at which function is defined.\n"
18035  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18036  " the z value being plotted. The color is used from the current\n"
18037  " cmap1.\n"
18038  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18039  " using parameters\n"
18040  " nlevel and\n"
18041  " clevel.\n"
18042  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18043  " the borders of the plotted function.\n"
18044  "\n"
18045  "\n"
18046  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18047  " levels.\n"
18048  "\n"
18049  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18050  "\n"
18051  ""},
18052  { "plot3dcl", _wrap_plot3dcl, METH_VARARGS, "\n"
18053  "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18054  "\n"
18055  "DESCRIPTION:\n"
18056  "\n"
18057  " When the implementation is completed this variant of plot3dc (see that\n"
18058  " function's documentation for more details) should be suitable for the\n"
18059  " case where the area of the x, y coordinate grid where z is defined can\n"
18060  " be non-rectangular. The implementation is incomplete so the last 4\n"
18061  " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18062  " indexymax; are currently ignored and the functionality is otherwise\n"
18063  " identical to that of plot3dc.\n"
18064  "\n"
18065  " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18066  " indexymin, indexymax)\n"
18067  "\n"
18068  "\n"
18069  " This function is not used in any example.\n"
18070  "\n"
18071  "\n"
18072  "\n"
18073  "SYNOPSIS:\n"
18074  "\n"
18075  "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18076  "\n"
18077  "ARGUMENTS:\n"
18078  "\n"
18079  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18080  " which the function is evaluated.\n"
18081  "\n"
18082  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18083  " which the function is evaluated.\n"
18084  "\n"
18085  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18086  " plot. Should have dimensions of\n"
18087  " nx by\n"
18088  " ny.\n"
18089  "\n"
18090  " nx (PLINT, input) : Number of x values at which the function is\n"
18091  " evaluated.\n"
18092  "\n"
18093  " ny (PLINT, input) : Number of y values at which the function is\n"
18094  " evaluated.\n"
18095  "\n"
18096  " opt (PLINT, input) : Determines the way in which the surface is\n"
18097  " represented. To specify more than one option just add the options,\n"
18098  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18099  " showing z as a function of x for each value of y[j] .\n"
18100  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18101  " for each value of x[i] .\n"
18102  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18103  " at which function is defined.\n"
18104  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18105  " the z value being plotted. The color is used from the current\n"
18106  " cmap1.\n"
18107  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18108  " using parameters\n"
18109  " nlevel and\n"
18110  " clevel.\n"
18111  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18112  " the borders of the plotted function.\n"
18113  "\n"
18114  "\n"
18115  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18116  " levels.\n"
18117  "\n"
18118  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18119  "\n"
18120  " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18121  " corresponds to the first x index where z is defined.\n"
18122  "\n"
18123  " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18124  " which corresponds (by convention) to one more than the last x\n"
18125  " index value where z is defined.\n"
18126  "\n"
18127  " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18128  " values which all must be ≥ 0. These values are the first y index\n"
18129  " where z is defined for a particular x index in the range from\n"
18130  " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18131  " indexxmax.\n"
18132  "\n"
18133  " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18134  " values which all must be ≤ ny. These values correspond (by\n"
18135  " convention) to one more than the last y index where z is defined\n"
18136  " for a particular x index in the range from indexxmin to indexxmax\n"
18137  " - 1. The dimension of indexymax is indexxmax.\n"
18138  "\n"
18139  ""},
18140  { "plsurf3d", _wrap_plsurf3d, METH_VARARGS, "\n"
18141  "Plot shaded 3-d surface plot\n"
18142  "\n"
18143  "DESCRIPTION:\n"
18144  "\n"
18145  " Plots a three-dimensional shaded surface plot within the environment\n"
18146  " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18147  " z[\n"
18148  " nx][\n"
18149  " ny], the point z[i][j] being the value of the function at (\n"
18150  " x[i],\n"
18151  " y[j]). Note that the points in vectors x and y do not need to be\n"
18152  " equally spaced, but must be stored in ascending order. For further\n"
18153  " details see the PLplot documentation.\n"
18154  "\n"
18155  " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18156  "\n"
18157  " This function is not used in any examples.\n"
18158  "\n"
18159  "\n"
18160  "\n"
18161  "SYNOPSIS:\n"
18162  "\n"
18163  "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18164  "\n"
18165  "ARGUMENTS:\n"
18166  "\n"
18167  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18168  " which the function is evaluated.\n"
18169  "\n"
18170  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18171  " which the function is evaluated.\n"
18172  "\n"
18173  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18174  " plot. Should have dimensions of\n"
18175  " nx by\n"
18176  " ny.\n"
18177  "\n"
18178  " nx (PLINT, input) : Number of x values at which function is\n"
18179  " evaluated.\n"
18180  "\n"
18181  " ny (PLINT, input) : Number of y values at which function is\n"
18182  " evaluated.\n"
18183  "\n"
18184  " opt (PLINT, input) : Determines the way in which the surface is\n"
18185  " represented. To specify more than one option just add the options,\n"
18186  " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18187  " connecting points at which function is defined.\n"
18188  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18189  " using parameters\n"
18190  " nlevel and\n"
18191  " clevel.\n"
18192  " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18193  " using parameters\n"
18194  " nlevel and\n"
18195  " clevel.\n"
18196  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18197  " the borders of the plotted function.\n"
18198  " opt=MAG_COLOR : the surface is colored according to the value\n"
18199  " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18200  " according to the intensity of the reflected light in the\n"
18201  " surface from a light source whose position is set using\n"
18202  " pllightsource.\n"
18203  "\n"
18204  "\n"
18205  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18206  " levels.\n"
18207  "\n"
18208  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18209  "\n"
18210  ""},
18211  { "plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, "\n"
18212  "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18213  "\n"
18214  "DESCRIPTION:\n"
18215  "\n"
18216  " This variant of plsurf3d (see that function's documentation for more\n"
18217  " details) should be suitable for the case where the area of the x, y\n"
18218  " coordinate grid where z is defined can be non-rectangular. The limits\n"
18219  " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18220  " indexymin, and indexymax.\n"
18221  "\n"
18222  " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18223  " indexymax)\n"
18224  "\n"
18225  " This function is used in example 8.\n"
18226  "\n"
18227  "\n"
18228  "\n"
18229  "SYNOPSIS:\n"
18230  "\n"
18231  "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18232  "\n"
18233  "ARGUMENTS:\n"
18234  "\n"
18235  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18236  " which the function is evaluated.\n"
18237  "\n"
18238  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18239  " which the function is evaluated.\n"
18240  "\n"
18241  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18242  " plot. Should have dimensions of\n"
18243  " nx by\n"
18244  " ny.\n"
18245  "\n"
18246  " nx (PLINT, input) : Number of x values at which function is\n"
18247  " evaluated.\n"
18248  "\n"
18249  " ny (PLINT, input) : Number of y values at which function is\n"
18250  " evaluated.\n"
18251  "\n"
18252  " opt (PLINT, input) : Determines the way in which the surface is\n"
18253  " represented. To specify more than one option just add the options,\n"
18254  " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18255  " connecting points at which function is defined.\n"
18256  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18257  " using parameters\n"
18258  " nlevel and\n"
18259  " clevel.\n"
18260  " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18261  " using parameters\n"
18262  " nlevel and\n"
18263  " clevel.\n"
18264  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18265  " the borders of the plotted function.\n"
18266  " opt=MAG_COLOR : the surface is colored according to the value\n"
18267  " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18268  " according to the intensity of the reflected light in the\n"
18269  " surface from a light source whose position is set using\n"
18270  " pllightsource.\n"
18271  "\n"
18272  "\n"
18273  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18274  " levels.\n"
18275  "\n"
18276  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18277  "\n"
18278  " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18279  " corresponds to the first x index where z is defined.\n"
18280  "\n"
18281  " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18282  " which corresponds (by convention) to one more than the last x\n"
18283  " index value where z is defined.\n"
18284  "\n"
18285  " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
18286  " values which all must be ≥ 0. These values are the first y index\n"
18287  " where z is defined for a particular x index in the range from\n"
18288  " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18289  " indexxmax.\n"
18290  "\n"
18291  " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
18292  " values which all must be ≤ ny. These values correspond (by\n"
18293  " convention) to one more than the last y index where z is defined\n"
18294  " for a particular x index in the range from indexxmin to indexxmax\n"
18295  " - 1. The dimension of indexymax is indexxmax.\n"
18296  "\n"
18297  ""},
18298  { "plparseopts", _wrap_plparseopts, METH_VARARGS, "\n"
18299  "Parse command-line arguments\n"
18300  "\n"
18301  "DESCRIPTION:\n"
18302  "\n"
18303  " Parse command-line arguments.\n"
18304  "\n"
18305  " plparseopts removes all recognized flags (decreasing argc\n"
18306  " accordingly), so that invalid input may be readily detected. It can\n"
18307  " also be used to process user command line flags. The user can merge\n"
18308  " an option table of type PLOptionTable into the internal option table\n"
18309  " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
18310  " the external table(s) be parsed by calling plClearOpts before\n"
18311  " plMergeOpts.\n"
18312  "\n"
18313  " The default action taken by plparseopts is as follows:\n"
18314  " Returns with an error if an unrecognized option or badly formed\n"
18315  " option-value pair are encountered.\n"
18316  " Returns immediately (return code 0) when the first non-option command\n"
18317  " line argument is found.\n"
18318  " Returns with the return code of the option handler, if one was called.\n"
18319  "\n"
18320  " Deletes command line arguments from argv list as they are found, and\n"
18321  " decrements argc accordingly.\n"
18322  " Does not show \"invisible\" options in usage or help messages.\n"
18323  " Assumes the program name is contained in argv[0].\n"
18324  "\n"
18325  " These behaviors may be controlled through the\n"
18326  " mode argument.\n"
18327  "\n"
18328  " Redacted form: General: plparseopts(argv, mode)\n"
18329  "\n"
18330  "\n"
18331  " This function is used in all of the examples.\n"
18332  "\n"
18333  "\n"
18334  "\n"
18335  "SYNOPSIS:\n"
18336  "\n"
18337  "PLINT plparseopts(p_argc, argv, mode)\n"
18338  "\n"
18339  "ARGUMENTS:\n"
18340  "\n"
18341  " p_argc (int *, input/output) : Number of arguments.\n"
18342  "\n"
18343  " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
18344  " strings containing *p_argc command-line arguments.\n"
18345  "\n"
18346  " mode (PLINT, input) : Parsing mode with the following\n"
18347  " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
18348  " and all error messages enabled, including program exit when an\n"
18349  " error occurs. Anything on the command line that isn't recognized\n"
18350  " as a valid option or option argument is flagged as an error.\n"
18351  " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
18352  " of errors.\n"
18353  " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
18354  " arguments.\n"
18355  " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
18356  " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
18357  " pointer to the program name.\n"
18358  " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
18359  " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
18360  " unrecognized arguments.\n"
18361  "\n"
18362  ""},
18363  { "plpat", _wrap_plpat, METH_VARARGS, "\n"
18364  "Set area line fill pattern\n"
18365  "\n"
18366  "DESCRIPTION:\n"
18367  "\n"
18368  " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
18369  " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
18370  " inclinations and spacings. The arguments to this routine are the\n"
18371  " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
18372  " elements) specifying the inclinations in tenths of a degree and the\n"
18373  " spacing in micrometers. (See also plpsty)\n"
18374  "\n"
18375  " Redacted form: General: plpat(inc, del)\n"
18376  "\n"
18377  "\n"
18378  " This function is used in example 15.\n"
18379  "\n"
18380  "\n"
18381  "\n"
18382  "SYNOPSIS:\n"
18383  "\n"
18384  "plpat(nlin, inc, del)\n"
18385  "\n"
18386  "ARGUMENTS:\n"
18387  "\n"
18388  " nlin (PLINT, input) : Number of sets of lines making up the\n"
18389  " pattern, either 1 or 2.\n"
18390  "\n"
18391  " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
18392  " inclination in tenths of a degree. (Should be between -900 and\n"
18393  " 900).\n"
18394  "\n"
18395  " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
18396  " spacing in micrometers between the lines making up the pattern.\n"
18397  "\n"
18398  ""},
18399  { "plpath", _wrap_plpath, METH_VARARGS, "\n"
18400  "Draw a line between two points, accounting for coordinate transforms\n"
18401  "\n"
18402  "DESCRIPTION:\n"
18403  "\n"
18404  " Joins the point (\n"
18405  " x1,\n"
18406  " y1) to (\n"
18407  " x2,\n"
18408  " y2) . If a global coordinate transform is defined then the line is\n"
18409  " broken in to n segments to approximate the path. If no transform is\n"
18410  " defined then this simply acts like a call to pljoin.\n"
18411  "\n"
18412  " Redacted form: plpath(n,x1,y1,x2,y2)\n"
18413  "\n"
18414  " This function is used in example 22.\n"
18415  "\n"
18416  "\n"
18417  "\n"
18418  "SYNOPSIS:\n"
18419  "\n"
18420  "plpath(n, x1, y1, x2, y2)\n"
18421  "\n"
18422  "ARGUMENTS:\n"
18423  "\n"
18424  " n (PLINT, input) : number of points to use to approximate the path.\n"
18425  "\n"
18426  " x1 (PLFLT, input) : x coordinate of first point.\n"
18427  "\n"
18428  " y1 (PLFLT, input) : y coordinate of first point.\n"
18429  "\n"
18430  " x2 (PLFLT, input) : x coordinate of second point.\n"
18431  "\n"
18432  " y2 (PLFLT, input) : y coordinate of second point.\n"
18433  "\n"
18434  ""},
18435  { "plpoin", _wrap_plpoin, METH_VARARGS, "\n"
18436  "Plot a glyph at the specified points\n"
18437  "\n"
18438  "DESCRIPTION:\n"
18439  "\n"
18440  " Plot a glyph at the specified points. (This function is largely\n"
18441  " superseded by plstring which gives access to many[!] more glyphs.)\n"
18442  " code=-1 means try to just draw a point. Right now it's just a move\n"
18443  " and a draw at the same place. Not ideal, since a sufficiently\n"
18444  " intelligent output device may optimize it away, or there may be faster\n"
18445  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18446  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18447  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18448  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18449  " code <= 127 the corresponding printable ASCII character is plotted.\n"
18450  "\n"
18451  " Redacted form: plpoin(x, y, code)\n"
18452  "\n"
18453  " This function is used in examples 1, 6, 14, and 29.\n"
18454  "\n"
18455  "\n"
18456  "\n"
18457  "SYNOPSIS:\n"
18458  "\n"
18459  "plpoin(n, x, y, code)\n"
18460  "\n"
18461  "ARGUMENTS:\n"
18462  "\n"
18463  " n (PLINT, input) : Number of points in the x and y vectors.\n"
18464  "\n"
18465  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18466  " points.\n"
18467  "\n"
18468  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18469  " points.\n"
18470  "\n"
18471  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
18472  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18473  " each of the n points.\n"
18474  "\n"
18475  ""},
18476  { "plpoin3", _wrap_plpoin3, METH_VARARGS, "\n"
18477  "Plot a glyph at the specified 3D points\n"
18478  "\n"
18479  "DESCRIPTION:\n"
18480  "\n"
18481  " Plot a glyph at the specified 3D points. (This function is largely\n"
18482  " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
18483  " Set up the call to this function similar to what is done for plline3.\n"
18484  " code=-1 means try to just draw a point. Right now it's just a move\n"
18485  " and a draw at the same place. Not ideal, since a sufficiently\n"
18486  " intelligent output device may optimize it away, or there may be faster\n"
18487  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18488  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18489  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18490  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18491  " code <= 127 the corresponding printable ASCII character is plotted.\n"
18492  "\n"
18493  " Redacted form: plpoin3(x, y, z, code)\n"
18494  "\n"
18495  " This function is not used in any example.\n"
18496  "\n"
18497  "\n"
18498  "\n"
18499  "SYNOPSIS:\n"
18500  "\n"
18501  "plpoin3(n, x, y, z, code)\n"
18502  "\n"
18503  "ARGUMENTS:\n"
18504  "\n"
18505  " n (PLINT, input) : Number of points in the x and y vectors.\n"
18506  "\n"
18507  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18508  " points.\n"
18509  "\n"
18510  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18511  " points.\n"
18512  "\n"
18513  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18514  " points.\n"
18515  "\n"
18516  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
18517  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18518  " each of the n points.\n"
18519  "\n"
18520  ""},
18521  { "plpoly3", _wrap_plpoly3, METH_VARARGS, "\n"
18522  "Draw a polygon in 3 space\n"
18523  "\n"
18524  "DESCRIPTION:\n"
18525  "\n"
18526  " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
18527  " like plline3, but differs from that function in that plpoly3 attempts\n"
18528  " to determine if the polygon is viewable depending on the order of the\n"
18529  " points within the vector and the value of ifcc. If the back of\n"
18530  " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
18531  " you want, then use plline3 instead.\n"
18532  "\n"
18533  " The points are assumed to be in a plane, and the directionality of the\n"
18534  " plane is determined from the first three points. Additional points do\n"
18535  " not have to lie on the plane defined by the first three, but if they\n"
18536  " do not, then the determination of visibility obviously can't be 100%\n"
18537  " accurate... So if you're 3 space polygons are too far from planar,\n"
18538  " consider breaking them into smaller polygons. 3 points define a plane\n"
18539  " :-).\n"
18540  "\n"
18541  " Bugs: If one of the first two segments is of zero length, or if they\n"
18542  " are co-linear, the calculation of visibility has a 50/50 chance of\n"
18543  " being correct. Avoid such situations :-). See x18c.c for an example\n"
18544  " of this problem. (Search for 20.1).\n"
18545  "\n"
18546  " Redacted form: plpoly3(x, y, z, code)\n"
18547  "\n"
18548  " This function is used in example 18.\n"
18549  "\n"
18550  "\n"
18551  "\n"
18552  "SYNOPSIS:\n"
18553  "\n"
18554  "plpoly3(n, x, y, z, draw, ifcc)\n"
18555  "\n"
18556  "ARGUMENTS:\n"
18557  "\n"
18558  " n (PLINT, input) : Number of points defining line.\n"
18559  "\n"
18560  " x (PLFLT_VECTOR, input) : A vector containing\n"
18561  " n x coordinates of points.\n"
18562  "\n"
18563  " y (PLFLT_VECTOR, input) : A vector containing\n"
18564  " n y coordinates of points.\n"
18565  "\n"
18566  " z (PLFLT_VECTOR, input) : A vector containing\n"
18567  " n z coordinates of points.\n"
18568  "\n"
18569  " draw (PLBOOL_VECTOR, input) : A vector containing\n"
18570  " n-1 Boolean values which control drawing the segments of the polygon.\n"
18571  " If draw[i] is true, then the polygon segment from index [i] to\n"
18572  " [i+1] is drawn, otherwise, not.\n"
18573  "\n"
18574  " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
18575  " polygon is determined by assuming the points are laid out in a\n"
18576  " counter-clockwise order. Otherwise, the directionality of the\n"
18577  " polygon is determined by assuming the points are laid out in a\n"
18578  " clockwise order.\n"
18579  "\n"
18580  ""},
18581  { "plprec", _wrap_plprec, METH_VARARGS, "\n"
18582  "Set precision in numeric labels\n"
18583  "\n"
18584  "DESCRIPTION:\n"
18585  "\n"
18586  " Sets the number of places after the decimal point in numeric labels.\n"
18587  "\n"
18588  " Redacted form: plprec(setp, prec)\n"
18589  "\n"
18590  " This function is used in example 29.\n"
18591  "\n"
18592  "\n"
18593  "\n"
18594  "SYNOPSIS:\n"
18595  "\n"
18596  "plprec(setp, prec)\n"
18597  "\n"
18598  "ARGUMENTS:\n"
18599  "\n"
18600  " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
18601  " automatically determines the number of places to use after the\n"
18602  " decimal point in numeric labels (like those used to label axes).\n"
18603  " If setp is 1 then prec sets the number of places.\n"
18604  "\n"
18605  " prec (PLINT, input) : The number of characters to draw after the\n"
18606  " decimal point in numeric labels.\n"
18607  "\n"
18608  ""},
18609  { "plpsty", _wrap_plpsty, METH_O, "\n"
18610  "Select area fill pattern\n"
18611  "\n"
18612  "DESCRIPTION:\n"
18613  "\n"
18614  " If\n"
18615  " patt is zero or less use either a hardware solid fill if the drivers\n"
18616  " have that capability (virtually all do) or fall back to a software\n"
18617  " emulation of a solid fill using the eighth area line fill pattern. If\n"
18618  " 0 <\n"
18619  " patt <= 8, then select one of eight predefined area line fill patterns\n"
18620  " to use (see plpat if you desire other patterns).\n"
18621  "\n"
18622  " Redacted form: plpsty(patt)\n"
18623  "\n"
18624  " This function is used in examples 12, 13, 15, 16, and 25.\n"
18625  "\n"
18626  "\n"
18627  "\n"
18628  "SYNOPSIS:\n"
18629  "\n"
18630  "plpsty(patt)\n"
18631  "\n"
18632  "ARGUMENTS:\n"
18633  "\n"
18634  " patt (PLINT, input) : The desired pattern index. If\n"
18635  " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
18636  " above) used. For\n"
18637  " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
18638  " line fill capability itself (most deliberately do not so that line\n"
18639  " fill patterns look identical for those drivers), the patterns\n"
18640  " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
18641  " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
18642  " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
18643  " (8) lines at both 45 degrees and -45 degrees.\n"
18644  "\n"
18645  ""},
18646  { "plptex", _wrap_plptex, METH_VARARGS, "\n"
18647  "Write text inside the viewport\n"
18648  "\n"
18649  "DESCRIPTION:\n"
18650  "\n"
18651  " Writes text at a specified position and inclination within the\n"
18652  " viewport. Text is clipped at the viewport boundaries. The reference\n"
18653  " point of a string lies along a line passing through the string at half\n"
18654  " the height of a capital letter. The position of the reference point\n"
18655  " along this line is determined by just, the reference point is placed\n"
18656  " at world coordinates (\n"
18657  " x,\n"
18658  " y) within the viewport. The inclination of the string is specified\n"
18659  " in terms of differences of world coordinates making it easy to write\n"
18660  " text parallel to a line in a graph.\n"
18661  "\n"
18662  " Redacted form: plptex(x, y, dx, dy, just, text)\n"
18663  "\n"
18664  " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
18665  "\n"
18666  "\n"
18667  "\n"
18668  "SYNOPSIS:\n"
18669  "\n"
18670  "plptex(x, y, dx, dy, just, text)\n"
18671  "\n"
18672  "ARGUMENTS:\n"
18673  "\n"
18674  " x (PLFLT, input) : x coordinate of reference point of string.\n"
18675  "\n"
18676  " y (PLFLT, input) : y coordinate of reference point of string.\n"
18677  "\n"
18678  " dx (PLFLT, input) : Together with dy, this specifies the\n"
18679  " inclination of the string. The baseline of the string is parallel\n"
18680  " to a line joining (\n"
18681  " x,\n"
18682  " y) to (\n"
18683  " x+\n"
18684  " dx,\n"
18685  " y+\n"
18686  " dy) .\n"
18687  "\n"
18688  " dy (PLFLT, input) : Together with dx, this specifies the\n"
18689  " inclination of the string.\n"
18690  "\n"
18691  " just (PLFLT, input) : Specifies the position of the string relative\n"
18692  " to its reference point. If just=0. , the reference point is at\n"
18693  " the left and if just=1. , it is at the right of the string. Other\n"
18694  " values of just give intermediate justifications.\n"
18695  "\n"
18696  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18697  " written out.\n"
18698  "\n"
18699  ""},
18700  { "plptex3", _wrap_plptex3, METH_VARARGS, "\n"
18701  "Write text inside the viewport of a 3D plot\n"
18702  "\n"
18703  "DESCRIPTION:\n"
18704  "\n"
18705  " Writes text at a specified position and inclination and with a\n"
18706  " specified shear within the viewport. Text is clipped at the viewport\n"
18707  " boundaries. The reference point of a string lies along a line passing\n"
18708  " through the string at half the height of a capital letter. The\n"
18709  " position of the reference point along this line is determined by just,\n"
18710  " and the reference point is placed at world coordinates (\n"
18711  " wx,\n"
18712  " wy,\n"
18713  " wz) within the viewport. The inclination and shear of the string is\n"
18714  " specified in terms of differences of world coordinates making it easy\n"
18715  " to write text parallel to a line in a graph.\n"
18716  "\n"
18717  " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
18718  "\n"
18719  " This function is used in example 28.\n"
18720  "\n"
18721  "\n"
18722  "\n"
18723  "SYNOPSIS:\n"
18724  "\n"
18725  "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
18726  "\n"
18727  "ARGUMENTS:\n"
18728  "\n"
18729  " wx (PLFLT, input) : x world coordinate of reference point of\n"
18730  " string.\n"
18731  "\n"
18732  " wy (PLFLT, input) : y world coordinate of reference point of\n"
18733  " string.\n"
18734  "\n"
18735  " wz (PLFLT, input) : z world coordinate of reference point of\n"
18736  " string.\n"
18737  "\n"
18738  " dx (PLFLT, input) : Together with dy and\n"
18739  " dz , this specifies the inclination of the string. The baseline of\n"
18740  " the string is parallel to a line joining (\n"
18741  " x,\n"
18742  " y,\n"
18743  " z) to (\n"
18744  " x+\n"
18745  " dx,\n"
18746  " y+\n"
18747  " dy,\n"
18748  " z+\n"
18749  " dz) .\n"
18750  "\n"
18751  " dy (PLFLT, input) : Together with dx and\n"
18752  " dz, this specifies the inclination of the string.\n"
18753  "\n"
18754  " dz (PLFLT, input) : Together with dx and\n"
18755  " dy, this specifies the inclination of the string.\n"
18756  "\n"
18757  " sx (PLFLT, input) : Together with sy and\n"
18758  " sz , this specifies the shear of the string. The string is sheared so\n"
18759  " that the characters are vertically parallel to a line joining (\n"
18760  " x,\n"
18761  " y,\n"
18762  " z) to (\n"
18763  " x+\n"
18764  " sx,\n"
18765  " y+\n"
18766  " sy,\n"
18767  " z+\n"
18768  " sz) . If sx =\n"
18769  " sy =\n"
18770  " sz = 0.) then the text is not sheared.\n"
18771  "\n"
18772  " sy (PLFLT, input) : Together with sx and\n"
18773  " sz, this specifies shear of the string.\n"
18774  "\n"
18775  " sz (PLFLT, input) : Together with sx and\n"
18776  " sy, this specifies shear of the string.\n"
18777  "\n"
18778  " just (PLFLT, input) : Specifies the position of the string relative\n"
18779  " to its reference point. If just=0. , the reference point is at\n"
18780  " the left and if just=1. , it is at the right of the string. Other\n"
18781  " values of just give intermediate justifications.\n"
18782  "\n"
18783  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18784  " written out.\n"
18785  "\n"
18786  ""},
18787  { "plrandd", _wrap_plrandd, METH_NOARGS, "\n"
18788  "Random number generator returning a real random number in the range [0,1]\n"
18789  "\n"
18790  "DESCRIPTION:\n"
18791  "\n"
18792  " Random number generator returning a real random number in the range\n"
18793  " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
18794  " / compilers provide their own random number generator, and so this is\n"
18795  " provided purely for convenience and to give a consistent random number\n"
18796  " generator across all languages supported by PLplot. This is\n"
18797  " particularly useful for comparing results from the test suite of\n"
18798  " examples.\n"
18799  "\n"
18800  " Redacted form: plrandd()\n"
18801  "\n"
18802  " This function is used in examples 17 and 21.\n"
18803  "\n"
18804  "\n"
18805  "\n"
18806  "SYNOPSIS:\n"
18807  "\n"
18808  "plrandd()\n"
18809  "\n"
18810  ""},
18811  { "plreplot", _wrap_plreplot, METH_NOARGS, "\n"
18812  "Replays contents of plot buffer to current device/file\n"
18813  "\n"
18814  "DESCRIPTION:\n"
18815  "\n"
18816  " Replays contents of plot buffer to current device/file.\n"
18817  "\n"
18818  " Redacted form: plreplot()\n"
18819  "\n"
18820  " This function is used in example 1,20.\n"
18821  "\n"
18822  "\n"
18823  "\n"
18824  "SYNOPSIS:\n"
18825  "\n"
18826  "plreplot()\n"
18827  "\n"
18828  ""},
18829  { "plrgbhls", _wrap_plrgbhls, METH_VARARGS, "\n"
18830  "Convert RGB color to HLS\n"
18831  "\n"
18832  "DESCRIPTION:\n"
18833  "\n"
18834  " Convert RGB color coordinates to HLS\n"
18835  "\n"
18836  " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18837  "\n"
18838  "\n"
18839  " This function is used in example 2.\n"
18840  "\n"
18841  "\n"
18842  "\n"
18843  "SYNOPSIS:\n"
18844  "\n"
18845  "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18846  "\n"
18847  "ARGUMENTS:\n"
18848  "\n"
18849  " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
18850  "\n"
18851  " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
18852  "\n"
18853  " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
18854  "\n"
18855  " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
18856  " degrees (0.0-360.0) on the color cylinder.\n"
18857  "\n"
18858  " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
18859  " expressed as a fraction (0.0-1.0) of the axis of the color\n"
18860  " cylinder.\n"
18861  "\n"
18862  " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
18863  " expressed as a fraction (0.0-1.0) of the radius of the color\n"
18864  " cylinder.\n"
18865  "\n"
18866  ""},
18867  { "plschr", _wrap_plschr, METH_VARARGS, "\n"
18868  "Set character size\n"
18869  "\n"
18870  "DESCRIPTION:\n"
18871  "\n"
18872  " This sets up the size of all subsequent characters drawn. The actual\n"
18873  " height of a character is the product of the default character size and\n"
18874  " a scaling factor.\n"
18875  "\n"
18876  " Redacted form: plschr(def, scale)\n"
18877  "\n"
18878  " This function is used in examples 2, 13, 23, and 24.\n"
18879  "\n"
18880  "\n"
18881  "\n"
18882  "SYNOPSIS:\n"
18883  "\n"
18884  "plschr(def, scale)\n"
18885  "\n"
18886  "ARGUMENTS:\n"
18887  "\n"
18888  " def (PLFLT, input) : The default height of a character in\n"
18889  " millimeters, should be set to zero if the default height is to\n"
18890  " remain unchanged. For rasterized drivers the dx and dy values\n"
18891  " specified in plspage are used to convert from mm to pixels (note\n"
18892  " the different unit systems used). This dpi aware scaling is not\n"
18893  " implemented for all drivers yet.\n"
18894  "\n"
18895  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
18896  " actual character height.\n"
18897  "\n"
18898  ""},
18899  { "plscmap0", _wrap_plscmap0, METH_VARARGS, "\n"
18900  "Set cmap0 colors by 8-bit RGB values\n"
18901  "\n"
18902  "DESCRIPTION:\n"
18903  "\n"
18904  " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
18905  " documentation). This sets the entire color map -- only as many colors\n"
18906  " as specified will be allocated.\n"
18907  "\n"
18908  " Redacted form: plscmap0(r, g, b)\n"
18909  "\n"
18910  " This function is used in examples 2 and 24.\n"
18911  "\n"
18912  "\n"
18913  "\n"
18914  "SYNOPSIS:\n"
18915  "\n"
18916  "plscmap0(r, g, b, ncol0)\n"
18917  "\n"
18918  "ARGUMENTS:\n"
18919  "\n"
18920  " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18921  " integers (0-255) representing the degree of red in the color.\n"
18922  "\n"
18923  " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18924  " integers (0-255) representing the degree of green in the color.\n"
18925  "\n"
18926  " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18927  " integers (0-255) representing the degree of blue in the color.\n"
18928  "\n"
18929  " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
18930  "\n"
18931  ""},
18932  { "plscmap0a", _wrap_plscmap0a, METH_VARARGS, "\n"
18933  "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
18934  "\n"
18935  "DESCRIPTION:\n"
18936  "\n"
18937  " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
18938  " and PLFLT alpha transparency value. This sets the entire color map --\n"
18939  " only as many colors as specified will be allocated.\n"
18940  "\n"
18941  " Redacted form: plscmap0a(r, g, b, alpha)\n"
18942  "\n"
18943  " This function is used in examples 30.\n"
18944  "\n"
18945  "\n"
18946  "\n"
18947  "SYNOPSIS:\n"
18948  "\n"
18949  "plscmap0a(r, g, b, alpha, ncol0)\n"
18950  "\n"
18951  "ARGUMENTS:\n"
18952  "\n"
18953  " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18954  " integers (0-255) representing the degree of red in the color.\n"
18955  "\n"
18956  " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18957  " integers (0-255) representing the degree of green in the color.\n"
18958  "\n"
18959  " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18960  " integers (0-255) representing the degree of blue in the color.\n"
18961  "\n"
18962  " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
18963  " representing the alpha transparency of the color.\n"
18964  "\n"
18965  " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
18966  " vectors.\n"
18967  "\n"
18968  ""},
18969  { "plscmap0n", _wrap_plscmap0n, METH_O, "\n"
18970  "Set number of colors in cmap0\n"
18971  "\n"
18972  "DESCRIPTION:\n"
18973  "\n"
18974  " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
18975  " (or reallocate) cmap0, and fill with default values for those colors\n"
18976  " not previously allocated. The first 16 default colors are given in\n"
18977  " the plcol0 documentation. For larger indices the default color is\n"
18978  " red.\n"
18979  "\n"
18980  " The drivers are not guaranteed to support more than 16 colors.\n"
18981  "\n"
18982  " Redacted form: plscmap0n(ncol0)\n"
18983  "\n"
18984  " This function is used in examples 15, 16, and 24.\n"
18985  "\n"
18986  "\n"
18987  "\n"
18988  "SYNOPSIS:\n"
18989  "\n"
18990  "plscmap0n(ncol0)\n"
18991  "\n"
18992  "ARGUMENTS:\n"
18993  "\n"
18994  " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
18995  " the cmap0 palette. If this number is zero or less, then the value\n"
18996  " from the previous call to plscmap0n is used and if there is no\n"
18997  " previous call, then a default value is used.\n"
18998  "\n"
18999  ""},
19000  { "plscmap1", _wrap_plscmap1, METH_VARARGS, "\n"
19001  "Set opaque RGB cmap1 colors values\n"
19002  "\n"
19003  "DESCRIPTION:\n"
19004  "\n"
19005  " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
19006  " vector values. This function also sets the number of cmap1 colors.\n"
19007  " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19008  " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19009  " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19010  " to\n"
19011  " ncol1-1. So in order for this continuous color model to work\n"
19012  " properly, it is the responsibility of the user of plscmap1 to insure\n"
19013  " that these RGB vectors are continuous functions of their integer\n"
19014  " indices.\n"
19015  "\n"
19016  " Redacted form: plscmap1(r, g, b)\n"
19017  "\n"
19018  " This function is used in example 31.\n"
19019  "\n"
19020  "\n"
19021  "\n"
19022  "SYNOPSIS:\n"
19023  "\n"
19024  "plscmap1(r, g, b, ncol1)\n"
19025  "\n"
19026  "ARGUMENTS:\n"
19027  "\n"
19028  " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19029  " 8-bit integers in the range from 0-255) the degree of red in the\n"
19030  " color as a continuous function of the integer index of the vector.\n"
19031  "\n"
19032  " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19033  " 8-bit integers in the range from 0-255) the degree of green in the\n"
19034  " color as a continuous function of the integer index of the vector.\n"
19035  "\n"
19036  " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19037  " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19038  " color as a continuous function of the integer index of the vector.\n"
19039  "\n"
19040  " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19041  "\n"
19042  ""},
19043  { "plscmap1a", _wrap_plscmap1a, METH_VARARGS, "\n"
19044  "Set semitransparent cmap1 RGBA colors.\n"
19045  "\n"
19046  "DESCRIPTION:\n"
19047  "\n"
19048  " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19049  " RGBA vector values. This function also sets the number of cmap1\n"
19050  " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19051  " floating-point index in the range from 0.0-1.0 which is linearly\n"
19052  " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19053  " vectors in the range from 0 to\n"
19054  " ncol1-1. So in order for this continuous color model to work\n"
19055  " properly, it is the responsibility of the user of plscmap1 to insure\n"
19056  " that these RGBA vectors are continuous functions of their integer\n"
19057  " indices.\n"
19058  "\n"
19059  " Redacted form: plscmap1a(r, g, b, alpha)\n"
19060  "\n"
19061  " This function is used in example 31.\n"
19062  "\n"
19063  "\n"
19064  "\n"
19065  "SYNOPSIS:\n"
19066  "\n"
19067  "plscmap1a(r, g, b, alpha, ncol1)\n"
19068  "\n"
19069  "ARGUMENTS:\n"
19070  "\n"
19071  " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19072  " 8-bit integers in the range from 0-255) the degree of red in the\n"
19073  " color as a continuous function of the integer index of the vector.\n"
19074  "\n"
19075  " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19076  " 8-bit integers in the range from 0-255) the degree of green in the\n"
19077  " color as a continuous function of the integer index of the vector.\n"
19078  "\n"
19079  " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19080  " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19081  " color as a continuous function of the integer index of the vector.\n"
19082  "\n"
19083  " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19084  " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19085  " completely transparent and 1.0 corresponds to completely opaque)\n"
19086  " the alpha transparency of the color as a continuous function of\n"
19087  " the integer index of the vector.\n"
19088  "\n"
19089  " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19090  " vectors.\n"
19091  "\n"
19092  ""},
19093  { "plscmap1l", _wrap_plscmap1l, METH_VARARGS, "\n"
19094  "Set cmap1 colors using a piece-wise linear relationship\n"
19095  "\n"
19096  "DESCRIPTION:\n"
19097  "\n"
19098  " Set cmap1 colors using a piece-wise linear relationship between the\n"
19099  " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19100  " (see the PLplot documentation). May be called at any time.\n"
19101  "\n"
19102  " The idea here is to specify a number of control points that define the\n"
19103  " mapping between input cmap1 intensity indices and HLS or RGB. Between\n"
19104  " these points, linear interpolation is used which gives a smooth\n"
19105  " variation of color with intensity index. Any number of control points\n"
19106  " may be specified, located at arbitrary positions, although typically 2\n"
19107  " - 4 are enough. Another way of stating this is that we are traversing\n"
19108  " a given number of lines through HLS or RGB space as we move through\n"
19109  " cmap1 intensity indices. The control points at the minimum and\n"
19110  " maximum position (0 and 1) must always be specified. By adding more\n"
19111  " control points you can get more variation. One good technique for\n"
19112  " plotting functions that vary about some expected average is to use an\n"
19113  " additional 2 control points in the center (position ~= 0.5) that are\n"
19114  " the same lightness as the background (typically white for paper\n"
19115  " output, black for crt), and same hue as the boundary control points.\n"
19116  " This allows the highs and lows to be very easily distinguished.\n"
19117  "\n"
19118  " Each control point must specify the cmap1 intensity index and the\n"
19119  " associated three coordinates in HLS or RGB space. The first point\n"
19120  " must correspond to position = 0, and the last to position = 1.\n"
19121  "\n"
19122  " If RGB colors are provided then the interpolation takes place in RGB\n"
19123  " space and is trivial. However if HLS colors are provided then, because\n"
19124  " of the circular nature of the color wheel for the hue coordinate, the\n"
19125  " interpolation could be performed in either direction around the color\n"
19126  " wheel. The default behaviour is for the hue to be linearly\n"
19127  " interpolated ignoring this circular property of hue. So for example,\n"
19128  " the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n"
19129  " green and cyan. If instead you wish to interpolate the other way\n"
19130  " around the color wheel you have two options. You may provide hues\n"
19131  " outside the range [0, 360), so by using a hue of -120 for blue or 360\n"
19132  " for red the interpolation will proceed via magenta. Alternatively you\n"
19133  " can utilise the alt_hue_path variable to reverse the direction of\n"
19134  " interpolation if you need to provide hues within the [0-360) range.\n"
19135  "\n"
19136  " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19137  " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19138  " -120]falsegreen-yellow-red-magenta-blue[240\n"
19139  " 480]falseblue-magenta-red-yellow-green[120\n"
19140  " 240]truegreen-yellow-red-magenta-blue[240\n"
19141  " 120]trueblue-magenta-red-yellow-green\n"
19142  "\n"
19143  " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19144  " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19145  " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19146  "\n"
19147  " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19148  " alt_hue_path)\n"
19149  "\n"
19150  " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19151  "\n"
19152  "\n"
19153  "\n"
19154  "SYNOPSIS:\n"
19155  "\n"
19156  "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19157  "\n"
19158  "ARGUMENTS:\n"
19159  "\n"
19160  " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19161  "\n"
19162  " npts (PLINT, input) : number of control points\n"
19163  "\n"
19164  " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19165  " intensity index (0.0-1.0) in ascending order for each control\n"
19166  " point.\n"
19167  "\n"
19168  " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19169  " coordinate (H or R) for each control point.\n"
19170  "\n"
19171  " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19172  " coordinate (L or G) for each control point.\n"
19173  "\n"
19174  " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19175  " coordinate (S or B) for each control point.\n"
19176  "\n"
19177  " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19178  " npts - 1 elements), each containing either true to use the reversed\n"
19179  " HLS interpolation or false to use the regular HLS interpolation.\n"
19180  " (alt_hue_path[i] refers to the interpolation interval between the\n"
19181  " i and i + 1 control points). This parameter is not used for RGB\n"
19182  " colors (\n"
19183  " itype = true).\n"
19184  "\n"
19185  ""},
19186  { "plscmap1la", _wrap_plscmap1la, METH_VARARGS, "\n"
19187  "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19188  "\n"
19189  "DESCRIPTION:\n"
19190  "\n"
19191  " This is a variant of plscmap1l that supports alpha channel\n"
19192  " transparency. It sets cmap1 colors using a piece-wise linear\n"
19193  " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19194  " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19195  " transparency value (0.0-1.0). It may be called at any time.\n"
19196  "\n"
19197  " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19198  " alpha, alt_hue_path)\n"
19199  "\n"
19200  " This function is used in example 30.\n"
19201  "\n"
19202  "\n"
19203  "\n"
19204  "SYNOPSIS:\n"
19205  "\n"
19206  "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19207  "\n"
19208  "ARGUMENTS:\n"
19209  "\n"
19210  " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19211  "\n"
19212  " npts (PLINT, input) : number of control points.\n"
19213  "\n"
19214  " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19215  " intensity index (0.0-1.0) in ascending order for each control\n"
19216  " point.\n"
19217  "\n"
19218  " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19219  " coordinate (H or R) for each control point.\n"
19220  "\n"
19221  " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19222  " coordinate (L or G) for each control point.\n"
19223  "\n"
19224  " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19225  " coordinate (S or B) for each control point.\n"
19226  "\n"
19227  " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19228  " transparency value (0.0-1.0) for each control point.\n"
19229  "\n"
19230  " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19231  " npts - 1 elements) containing the alternative interpolation method\n"
19232  " Boolean value for each control point interval. (alt_hue_path[i]\n"
19233  " refers to the interpolation interval between the i and i + 1\n"
19234  " control points).\n"
19235  "\n"
19236  ""},
19237  { "plscmap1n", _wrap_plscmap1n, METH_O, "\n"
19238  "Set number of colors in cmap1\n"
19239  "\n"
19240  "DESCRIPTION:\n"
19241  "\n"
19242  " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
19243  " values if this is the first allocation (see the PLplot documentation).\n"
19244  "\n"
19245  " Redacted form: plscmap1n(ncol1)\n"
19246  "\n"
19247  " This function is used in examples 8, 11, 20, and 21.\n"
19248  "\n"
19249  "\n"
19250  "\n"
19251  "SYNOPSIS:\n"
19252  "\n"
19253  "plscmap1n(ncol1)\n"
19254  "\n"
19255  "ARGUMENTS:\n"
19256  "\n"
19257  " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
19258  " the cmap1 palette. If this number is zero or less, then the value\n"
19259  " from the previous call to plscmap1n is used and if there is no\n"
19260  " previous call, then a default value is used.\n"
19261  "\n"
19262  ""},
19263  { "plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, "\n"
19264  "Set the cmap1 argument range for continuous color plots\n"
19265  "\n"
19266  "DESCRIPTION:\n"
19267  "\n"
19268  " Set the cmap1 argument range for continuous color plots that\n"
19269  " corresponds to the range of data values. The maximum range\n"
19270  " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
19271  " the cmap1 argument range that is specified with this routine, the\n"
19272  " smaller the subset of the cmap1 color palette that is used to\n"
19273  " represent the continuous data being plotted. If\n"
19274  " min_color is greater than\n"
19275  " max_color or\n"
19276  " max_color is greater than 1.0 or\n"
19277  " min_color is less than 0.0 then no change is made to the cmap1\n"
19278  " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
19279  "\n"
19280  " Redacted form: plscmap1_range(min_color, max_color)\n"
19281  "\n"
19282  " This function is currently used in example 33.\n"
19283  "\n"
19284  "\n"
19285  "\n"
19286  "SYNOPSIS:\n"
19287  "\n"
19288  "plscmap1_range(min_color, max_color)\n"
19289  "\n"
19290  "ARGUMENTS:\n"
19291  "\n"
19292  " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
19293  " than 0.0, then 0.0 is used instead.\n"
19294  "\n"
19295  " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
19296  " than 1.0, then 1.0 is used instead.\n"
19297  "\n"
19298  ""},
19299  { "plgcmap1_range", _wrap_plgcmap1_range, METH_NOARGS, "\n"
19300  "Get the cmap1 argument range for continuous color plots\n"
19301  "\n"
19302  "DESCRIPTION:\n"
19303  "\n"
19304  " Get the cmap1 argument range for continuous color plots. (Use\n"
19305  " plscmap1_range to set the cmap1 argument range.)\n"
19306  "\n"
19307  " Redacted form: plgcmap1_range(min_color, max_color)\n"
19308  "\n"
19309  " This function is currently not used in any example.\n"
19310  "\n"
19311  "\n"
19312  "\n"
19313  "SYNOPSIS:\n"
19314  "\n"
19315  "plgcmap1_range(min_color, max_color)\n"
19316  "\n"
19317  "ARGUMENTS:\n"
19318  "\n"
19319  " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
19320  " minimum cmap1 argument.\n"
19321  "\n"
19322  " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
19323  " maximum cmap1 argument.\n"
19324  "\n"
19325  ""},
19326  { "plscol0", _wrap_plscol0, METH_VARARGS, "\n"
19327  "Set 8-bit RGB values for given cmap0 color index\n"
19328  "\n"
19329  "DESCRIPTION:\n"
19330  "\n"
19331  " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
19332  " index. Overwrites the previous color value for the given index and,\n"
19333  " thus, does not result in any additional allocation of space for\n"
19334  " colors.\n"
19335  "\n"
19336  " Redacted form: plscol0(icol0, r, g, b)\n"
19337  "\n"
19338  " This function is used in any example 31.\n"
19339  "\n"
19340  "\n"
19341  "\n"
19342  "SYNOPSIS:\n"
19343  "\n"
19344  "plscol0(icol0, r, g, b)\n"
19345  "\n"
19346  "ARGUMENTS:\n"
19347  "\n"
19348  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19349  " number of colors (which is set by default, by plscmap0n, or even\n"
19350  " by plscmap0).\n"
19351  "\n"
19352  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19353  " degree of red in the color.\n"
19354  "\n"
19355  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19356  " degree of green in the color.\n"
19357  "\n"
19358  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19359  " degree of blue in the color.\n"
19360  "\n"
19361  ""},
19362  { "plscol0a", _wrap_plscol0a, METH_VARARGS, "\n"
19363  "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
19364  "\n"
19365  "DESCRIPTION:\n"
19366  "\n"
19367  " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
19368  " (see the PLplot documentation) index. Overwrites the previous color\n"
19369  " value for the given index and, thus, does not result in any additional\n"
19370  " allocation of space for colors.\n"
19371  "\n"
19372  " This function is used in example 30.\n"
19373  "\n"
19374  "\n"
19375  "\n"
19376  "SYNOPSIS:\n"
19377  "\n"
19378  "plscol0a(icol0, r, g, b, alpha)\n"
19379  "\n"
19380  "ARGUMENTS:\n"
19381  "\n"
19382  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19383  " number of colors (which is set by default, by plscmap0n, or even\n"
19384  " by plscmap0).\n"
19385  "\n"
19386  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19387  " degree of red in the color.\n"
19388  "\n"
19389  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19390  " degree of green in the color.\n"
19391  "\n"
19392  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19393  " degree of blue in the color.\n"
19394  "\n"
19395  " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
19396  " (0.0-1.0).\n"
19397  "\n"
19398  ""},
19399  { "plscolbg", _wrap_plscolbg, METH_VARARGS, "\n"
19400  "Set the background color by 8-bit RGB value\n"
19401  "\n"
19402  "DESCRIPTION:\n"
19403  "\n"
19404  " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
19405  " the PLplot documentation).\n"
19406  "\n"
19407  " Redacted form: plscolbg(r, g, b)\n"
19408  "\n"
19409  " This function is used in examples 15 and 31.\n"
19410  "\n"
19411  "\n"
19412  "\n"
19413  "SYNOPSIS:\n"
19414  "\n"
19415  "plscolbg(r, g, b)\n"
19416  "\n"
19417  "ARGUMENTS:\n"
19418  "\n"
19419  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19420  " degree of red in the color.\n"
19421  "\n"
19422  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19423  " degree of green in the color.\n"
19424  "\n"
19425  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19426  " degree of blue in the color.\n"
19427  "\n"
19428  ""},
19429  { "plscolbga", _wrap_plscolbga, METH_VARARGS, "\n"
19430  "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
19431  "\n"
19432  "DESCRIPTION:\n"
19433  "\n"
19434  " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
19435  " PLFLT alpha transparency value (see the PLplot documentation).\n"
19436  "\n"
19437  " This function is used in example 31.\n"
19438  "\n"
19439  "\n"
19440  "\n"
19441  "SYNOPSIS:\n"
19442  "\n"
19443  "plscolbga(r, g, b, alpha)\n"
19444  "\n"
19445  "ARGUMENTS:\n"
19446  "\n"
19447  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19448  " degree of red in the color.\n"
19449  "\n"
19450  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19451  " degree of green in the color.\n"
19452  "\n"
19453  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19454  " degree of blue in the color.\n"
19455  "\n"
19456  " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
19457  " (0.0-1.0).\n"
19458  "\n"
19459  ""},
19460  { "plscolor", _wrap_plscolor, METH_O, "\n"
19461  "Used to globally turn color output on/off\n"
19462  "\n"
19463  "DESCRIPTION:\n"
19464  "\n"
19465  " Used to globally turn color output on/off for those drivers/devices\n"
19466  " that support it.\n"
19467  "\n"
19468  " Redacted form: plscolor(color)\n"
19469  "\n"
19470  " This function is used in example 31.\n"
19471  "\n"
19472  "\n"
19473  "\n"
19474  "SYNOPSIS:\n"
19475  "\n"
19476  "plscolor(color)\n"
19477  "\n"
19478  "ARGUMENTS:\n"
19479  "\n"
19480  " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
19481  " turned off. If non-zero, color is turned on.\n"
19482  "\n"
19483  ""},
19484  { "plscompression", _wrap_plscompression, METH_O, "\n"
19485  "Set device-compression level\n"
19486  "\n"
19487  "DESCRIPTION:\n"
19488  "\n"
19489  " Set device-compression level. Only used for drivers that provide\n"
19490  " compression. This function, if used, should be invoked before a call\n"
19491  " to plinit.\n"
19492  "\n"
19493  " Redacted form: plscompression(compression)\n"
19494  "\n"
19495  " This function is used in example 31.\n"
19496  "\n"
19497  "\n"
19498  "\n"
19499  "SYNOPSIS:\n"
19500  "\n"
19501  "plscompression(compression)\n"
19502  "\n"
19503  "ARGUMENTS:\n"
19504  "\n"
19505  " compression (PLINT, input) : The desired compression level. This is\n"
19506  " a device-dependent value. Currently only the jpeg and png devices\n"
19507  " use these values. For jpeg value is the jpeg quality which should\n"
19508  " normally be in the range 0-95. Higher values denote higher quality\n"
19509  " and hence larger image sizes. For png values are in the range -1\n"
19510  " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
19511  " A value of -1 denotes the default zlib compression level. Values\n"
19512  " in the range 10-99 are divided by 10 and then used as the zlib\n"
19513  " compression level. Higher compression levels correspond to greater\n"
19514  " compression and small file sizes at the expense of more\n"
19515  " computation.\n"
19516  "\n"
19517  ""},
19518  { "plsdev", _wrap_plsdev, METH_O, "\n"
19519  "Set the device (keyword) name\n"
19520  "\n"
19521  "DESCRIPTION:\n"
19522  "\n"
19523  " Set the device (keyword) name.\n"
19524  "\n"
19525  " Redacted form: plsdev(devname)\n"
19526  "\n"
19527  " This function is used in examples 1, 14, and 20.\n"
19528  "\n"
19529  "\n"
19530  "\n"
19531  "SYNOPSIS:\n"
19532  "\n"
19533  "plsdev(devname)\n"
19534  "\n"
19535  "ARGUMENTS:\n"
19536  "\n"
19537  " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
19538  " containing the device name keyword of the required output device.\n"
19539  " If\n"
19540  " devname is NULL or if the first character of the string is a ``?'',\n"
19541  " the normal (prompted) start up is used.\n"
19542  "\n"
19543  ""},
19544  { "plsdidev", _wrap_plsdidev, METH_VARARGS, "\n"
19545  "Set parameters that define current device-space window\n"
19546  "\n"
19547  "DESCRIPTION:\n"
19548  "\n"
19549  " Set relative margin width, aspect ratio, and relative justification\n"
19550  " that define current device-space window. If you want to just use the\n"
19551  " previous value for any of these, just pass in the magic value\n"
19552  " PL_NOTSET. It is unlikely that one should ever need to change the\n"
19553  " aspect ratio but it's in there for completeness. If plsdidev is not\n"
19554  " called the default values of mar, jx, and jy are all 0. aspect is set\n"
19555  " to a device-specific value.\n"
19556  "\n"
19557  " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
19558  "\n"
19559  " This function is used in example 31.\n"
19560  "\n"
19561  "\n"
19562  "\n"
19563  "SYNOPSIS:\n"
19564  "\n"
19565  "plsdidev(mar, aspect, jx, jy)\n"
19566  "\n"
19567  "ARGUMENTS:\n"
19568  "\n"
19569  " mar (PLFLT, input) : Relative margin width.\n"
19570  "\n"
19571  " aspect (PLFLT, input) : Aspect ratio.\n"
19572  "\n"
19573  " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
19574  " the range -0.5 to 0.5.\n"
19575  "\n"
19576  " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
19577  " the range -0.5 to 0.5.\n"
19578  "\n"
19579  ""},
19580  { "plsdimap", _wrap_plsdimap, METH_VARARGS, "\n"
19581  "Set up transformation from metafile coordinates\n"
19582  "\n"
19583  "DESCRIPTION:\n"
19584  "\n"
19585  " Set up transformation from metafile coordinates. The size of the plot\n"
19586  " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
19587  " general-purpose facility just yet (not sure why the user would need\n"
19588  " it, for one).\n"
19589  "\n"
19590  " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
19591  " dimypmm)\n"
19592  "\n"
19593  " This function is not used in any examples.\n"
19594  "\n"
19595  "\n"
19596  "\n"
19597  "SYNOPSIS:\n"
19598  "\n"
19599  "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
19600  "\n"
19601  "ARGUMENTS:\n"
19602  "\n"
19603  " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
19604  "\n"
19605  " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
19606  "\n"
19607  " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
19608  "\n"
19609  " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
19610  "\n"
19611  " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
19612  "\n"
19613  " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
19614  "\n"
19615  ""},
19616  { "plsdiori", _wrap_plsdiori, METH_O, "\n"
19617  "Set plot orientation\n"
19618  "\n"
19619  "DESCRIPTION:\n"
19620  "\n"
19621  " Set plot orientation parameter which is multiplied by 90 degrees to\n"
19622  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
19623  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
19624  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
19625  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
19626  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
19627  " not called the default value of rot is 0.\n"
19628  "\n"
19629  " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
19630  " probably want to change the aspect ratio to a value suitable for the\n"
19631  " plot orientation using a call to plsdidev or the command-line options\n"
19632  " -a or -freeaspect. For more documentation of those options see the\n"
19633  " PLplot documentation. Such command-line options can be set internally\n"
19634  " using plsetopt or set directly using the command line and parsed using\n"
19635  " a call to plparseopts.\n"
19636  "\n"
19637  " Redacted form: plsdiori(rot)\n"
19638  "\n"
19639  " This function is not used in any examples.\n"
19640  "\n"
19641  "\n"
19642  "\n"
19643  "SYNOPSIS:\n"
19644  "\n"
19645  "plsdiori(rot)\n"
19646  "\n"
19647  "ARGUMENTS:\n"
19648  "\n"
19649  " rot (PLFLT, input) : Plot orientation parameter.\n"
19650  "\n"
19651  ""},
19652  { "plsdiplt", _wrap_plsdiplt, METH_VARARGS, "\n"
19653  "Set parameters that define current plot-space window\n"
19654  "\n"
19655  "DESCRIPTION:\n"
19656  "\n"
19657  " Set relative minima and maxima that define the current plot-space\n"
19658  " window. If plsdiplt is not called the default values of xmin, ymin,\n"
19659  " xmax, and ymax are 0., 0., 1., and 1.\n"
19660  "\n"
19661  " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
19662  "\n"
19663  " This function is used in example 31.\n"
19664  "\n"
19665  "\n"
19666  "\n"
19667  "SYNOPSIS:\n"
19668  "\n"
19669  "plsdiplt(xmin, ymin, xmax, ymax)\n"
19670  "\n"
19671  "ARGUMENTS:\n"
19672  "\n"
19673  " xmin (PLFLT, input) : Relative minimum in x.\n"
19674  "\n"
19675  " ymin (PLFLT, input) : Relative minimum in y.\n"
19676  "\n"
19677  " xmax (PLFLT, input) : Relative maximum in x.\n"
19678  "\n"
19679  " ymax (PLFLT, input) : Relative maximum in y.\n"
19680  "\n"
19681  ""},
19682  { "plsdiplz", _wrap_plsdiplz, METH_VARARGS, "\n"
19683  "Set parameters incrementally (zoom mode) that define current plot-space window\n"
19684  "\n"
19685  "DESCRIPTION:\n"
19686  "\n"
19687  " Set relative minima and maxima incrementally (zoom mode) that define\n"
19688  " the current plot-space window. This function has the same effect as\n"
19689  " plsdiplt if that function has not been previously called. Otherwise,\n"
19690  " this function implements zoom mode using the transformation min_used =\n"
19691  " old_min + old_length*min and max_used = old_min + old_length*max for\n"
19692  " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
19693  " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
19694  "\n"
19695  " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
19696  "\n"
19697  " This function is used in example 31.\n"
19698  "\n"
19699  "\n"
19700  "\n"
19701  "SYNOPSIS:\n"
19702  "\n"
19703  "plsdiplz(xmin, ymin, xmax, ymax)\n"
19704  "\n"
19705  "ARGUMENTS:\n"
19706  "\n"
19707  " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
19708  "\n"
19709  " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
19710  "\n"
19711  " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
19712  "\n"
19713  " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
19714  "\n"
19715  ""},
19716  { "plseed", _wrap_plseed, METH_O, "\n"
19717  "Set seed for internal random number generator.\n"
19718  "\n"
19719  "DESCRIPTION:\n"
19720  "\n"
19721  " Set the seed for the internal random number generator. See plrandd for\n"
19722  " further details.\n"
19723  "\n"
19724  " Redacted form: plseed(seed)\n"
19725  "\n"
19726  " This function is used in example 21.\n"
19727  "\n"
19728  "\n"
19729  "\n"
19730  "SYNOPSIS:\n"
19731  "\n"
19732  "plseed(seed)\n"
19733  "\n"
19734  "ARGUMENTS:\n"
19735  "\n"
19736  " seed (unsigned int, input) : Seed for random number generator.\n"
19737  "\n"
19738  ""},
19739  { "plsesc", _wrap_plsesc, METH_O, "\n"
19740  "Set the escape character for text strings\n"
19741  "\n"
19742  "DESCRIPTION:\n"
19743  "\n"
19744  " Set the escape character for text strings. From C (in contrast to\n"
19745  " Fortran, see plsescfortran) you pass esc as a character. Only selected\n"
19746  " characters are allowed to prevent the user from shooting himself in\n"
19747  " the foot (For example, a \\ isn't allowed since it conflicts with C's\n"
19748  " use of backslash as a character escape). Here are the allowed escape\n"
19749  " characters and their corresponding decimal ASCII values: !, ASCII 33\n"
19750  " #, ASCII 35\n"
19751  " $, ASCII 36\n"
19752  " %, ASCII 37\n"
19753  " &, ASCII 38\n"
19754  " *, ASCII 42\n"
19755  " @, ASCII 64\n"
19756  " ^, ASCII 94\n"
19757  " ~, ASCII 126\n"
19758  "\n"
19759  "\n"
19760  " Redacted form: General: plsesc(esc)\n"
19761  "\n"
19762  "\n"
19763  " This function is used in example 29.\n"
19764  "\n"
19765  "\n"
19766  "\n"
19767  "SYNOPSIS:\n"
19768  "\n"
19769  "plsesc(esc)\n"
19770  "\n"
19771  "ARGUMENTS:\n"
19772  "\n"
19773  " esc (char, input) : Escape character.\n"
19774  "\n"
19775  ""},
19776  { "plsetopt", _wrap_plsetopt, METH_VARARGS, "\n"
19777  "Set any command-line option\n"
19778  "\n"
19779  "DESCRIPTION:\n"
19780  "\n"
19781  " Set any command-line option internally from a program before it\n"
19782  " invokes plinit. opt is the name of the command-line option and optarg\n"
19783  " is the corresponding command-line option argument.\n"
19784  "\n"
19785  " This function returns 0 on success.\n"
19786  "\n"
19787  " Redacted form: plsetopt(opt, optarg)\n"
19788  "\n"
19789  " This function is used in example 14.\n"
19790  "\n"
19791  "\n"
19792  "\n"
19793  "SYNOPSIS:\n"
19794  "\n"
19795  "PLINT plsetopt(opt, optarg)\n"
19796  "\n"
19797  "ARGUMENTS:\n"
19798  "\n"
19799  " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
19800  " the command-line option.\n"
19801  "\n"
19802  " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
19803  " containing the argument of the command-line option.\n"
19804  "\n"
19805  ""},
19806  { "plsfam", _wrap_plsfam, METH_VARARGS, "\n"
19807  "Set family file parameters\n"
19808  "\n"
19809  "DESCRIPTION:\n"
19810  "\n"
19811  " Sets variables dealing with output file familying. Does nothing if\n"
19812  " familying not supported by the driver. This routine, if used, must be\n"
19813  " called before initializing PLplot. See the PLplot documentation for\n"
19814  " more information.\n"
19815  "\n"
19816  " Redacted form: plsfam(fam, num, bmax)\n"
19817  "\n"
19818  " This function is used in examples 14 and 31.\n"
19819  "\n"
19820  "\n"
19821  "\n"
19822  "SYNOPSIS:\n"
19823  "\n"
19824  "plsfam(fam, num, bmax)\n"
19825  "\n"
19826  "ARGUMENTS:\n"
19827  "\n"
19828  " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
19829  " is enabled.\n"
19830  "\n"
19831  " num (PLINT, input) : Current family file number.\n"
19832  "\n"
19833  " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
19834  " file.\n"
19835  "\n"
19836  ""},
19837  { "plsfci", _wrap_plsfci, METH_O, "\n"
19838  "Set FCI (font characterization integer)\n"
19839  "\n"
19840  "DESCRIPTION:\n"
19841  "\n"
19842  " Sets font characteristics to be used at the start of the next string\n"
19843  " using the FCI approach. See the PLplot documentation for more\n"
19844  " information. Note, plsfont (which calls plsfci internally) provides a\n"
19845  " more user-friendly API for setting the font characterisitics.\n"
19846  "\n"
19847  " Redacted form: General: plsfci(fci)\n"
19848  "\n"
19849  "\n"
19850  " This function is used in example 23.\n"
19851  "\n"
19852  "\n"
19853  "\n"
19854  "SYNOPSIS:\n"
19855  "\n"
19856  "plsfci(fci)\n"
19857  "\n"
19858  "ARGUMENTS:\n"
19859  "\n"
19860  " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
19861  " of FCI.\n"
19862  "\n"
19863  ""},
19864  { "plsfnam", _wrap_plsfnam, METH_O, "\n"
19865  "Set output file name\n"
19866  "\n"
19867  "DESCRIPTION:\n"
19868  "\n"
19869  " Sets the current output file name, if applicable. If the file name\n"
19870  " has not been specified and is required by the driver, the user will be\n"
19871  " prompted for it. If using the X-windows output driver, this sets the\n"
19872  " display name. This routine, if used, must be called before\n"
19873  " initializing PLplot.\n"
19874  "\n"
19875  " Redacted form: plsfnam(fnam)\n"
19876  "\n"
19877  " This function is used in examples 1 and 20.\n"
19878  "\n"
19879  "\n"
19880  "\n"
19881  "SYNOPSIS:\n"
19882  "\n"
19883  "plsfnam(fnam)\n"
19884  "\n"
19885  "ARGUMENTS:\n"
19886  "\n"
19887  " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
19888  " the file name.\n"
19889  "\n"
19890  ""},
19891  { "plsfont", _wrap_plsfont, METH_VARARGS, "\n"
19892  "Set family, style and weight of the current font\n"
19893  "\n"
19894  "DESCRIPTION:\n"
19895  "\n"
19896  " Sets the current font. See the PLplot documentation for more\n"
19897  " information on font selection.\n"
19898  "\n"
19899  " Redacted form: plsfont(family, style, weight)\n"
19900  "\n"
19901  " This function is used in example 23.\n"
19902  "\n"
19903  "\n"
19904  "\n"
19905  "SYNOPSIS:\n"
19906  "\n"
19907  "plsfont(family, style, weight)\n"
19908  "\n"
19909  "ARGUMENTS:\n"
19910  "\n"
19911  " family (PLINT, input) : Font family to select for the current font.\n"
19912  " The available values are given by the PL_FCI_* constants in\n"
19913  " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
19914  " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
19915  " signifies that the font family should not be altered.\n"
19916  "\n"
19917  " style (PLINT, input) : Font style to select for the current font.\n"
19918  " The available values are given by the PL_FCI_* constants in\n"
19919  " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
19920  " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
19921  " should not be altered.\n"
19922  "\n"
19923  " weight (PLINT, input) : Font weight to select for the current font.\n"
19924  " The available values are given by the PL_FCI_* constants in\n"
19925  " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
19926  " negative value signifies that the font weight should not be\n"
19927  " altered.\n"
19928  "\n"
19929  ""},
19930  { "plshades", _wrap_plshades, METH_VARARGS, "\n"
19931  "Shade regions on the basis of value\n"
19932  "\n"
19933  "DESCRIPTION:\n"
19934  "\n"
19935  " Shade regions on the basis of value. This is the high-level routine\n"
19936  " for making continuous color shaded plots with cmap1 while plshade\n"
19937  " should be used to plot individual shaded regions using either cmap0 or\n"
19938  " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
19939  " our supported languages.\n"
19940  "\n"
19941  " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
19942  " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
19943  " pltr_data)\n"
19944  "\n"
19945  "\n"
19946  " This function is used in examples 16, 21, and 22.\n"
19947  "\n"
19948  "\n"
19949  "\n"
19950  "SYNOPSIS:\n"
19951  "\n"
19952  "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
19953  "\n"
19954  "ARGUMENTS:\n"
19955  "\n"
19956  " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
19957  " plot. Should have dimensions of\n"
19958  " nx by\n"
19959  " ny.\n"
19960  "\n"
19961  " nx (PLINT, input) : First dimension of matrix \"a\".\n"
19962  "\n"
19963  " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
19964  "\n"
19965  " defined (PLDEFINED_callback, input) : Callback function specifying\n"
19966  " the region that should be plotted in the shade plot. This\n"
19967  " function accepts x and y coordinates as input arguments and must\n"
19968  " return 1 if the point is to be included in the shade plot and 0\n"
19969  " otherwise. If you want to plot the entire shade plot (the usual\n"
19970  " case), this argument should be set to NULL.\n"
19971  "\n"
19972  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
19973  " pltr below for how these arguments are used (only for the special case\n"
19974  " when the callback function\n"
19975  " pltr is not supplied).\n"
19976  "\n"
19977  " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
19978  " corresponding to the edges of each shaded region that will be\n"
19979  " plotted by this function. To work properly the levels should be\n"
19980  " monotonic.\n"
19981  "\n"
19982  " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
19983  " of shade edge values in clevel).\n"
19984  "\n"
19985  " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
19986  " pattern.\n"
19987  "\n"
19988  " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
19989  " contours defining edges of shaded regions. The pen color is only\n"
19990  " temporary set for the contour drawing. Set this value to zero or\n"
19991  " less if no shade edge contours are wanted.\n"
19992  "\n"
19993  " cont_width (PLFLT, input) : Defines line width used for contours\n"
19994  " defining edges of shaded regions. This value may not be honored\n"
19995  " by all drivers. The pen width is only temporary set for the\n"
19996  " contour drawing. Set this value to zero or less if no shade edge\n"
19997  " contours are wanted.\n"
19998  "\n"
19999  " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
20000  " region. Use plfill for this purpose.\n"
20001  "\n"
20002  " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20003  " map to rectangles after coordinate transformation with pltrl.\n"
20004  " Otherwise, set rectangular to false. If rectangular is set to\n"
20005  " true, plshade tries to save time by filling large rectangles.\n"
20006  " This optimization fails if the coordinate transformation distorts\n"
20007  " the shape of rectangles. For example a plot in polar coordinates\n"
20008  " has to have rectangular set to false.\n"
20009  "\n"
20010  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20011  " defines the transformation between the zero-based indices of the\n"
20012  " matrix a and world coordinates. If\n"
20013  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20014  " indices of a are mapped to the range\n"
20015  " xmin through\n"
20016  " xmax and the y indices of a are mapped to the range\n"
20017  " ymin through\n"
20018  " ymax.For the C case, transformation functions are provided in the\n"
20019  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20020  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20021  " matrices. In addition, C callback routines for the transformation\n"
20022  " can be supplied by the user such as the mypltr function in\n"
20023  " examples/c/x09c.c which provides a general linear transformation\n"
20024  " between index coordinates and world coordinates.For languages\n"
20025  " other than C you should consult the PLplot documentation for the\n"
20026  " details concerning how PLTRANSFORM_callback arguments are\n"
20027  " interfaced. However, in general, a particular pattern of\n"
20028  " callback-associated arguments such as a tr vector with 6 elements;\n"
20029  " xg and yg vectors; or xg and yg matrices are respectively\n"
20030  " interfaced to a linear-transformation routine similar to the above\n"
20031  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20032  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20033  " support native language callbacks for handling index to\n"
20034  " world-coordinate transformations. Examples of these various\n"
20035  " approaches are given in examples/<language>x09*,\n"
20036  " examples/<language>x16*, examples/<language>x20*,\n"
20037  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20038  " supported languages.\n"
20039  "\n"
20040  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20041  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20042  " externally supplied.\n"
20043  "\n"
20044  ""},
20045  { "plshade", _wrap_plshade, METH_VARARGS, "\n"
20046  "Shade individual region on the basis of value\n"
20047  "\n"
20048  "DESCRIPTION:\n"
20049  "\n"
20050  " Shade individual region on the basis of value. Use plshades if you\n"
20051  " want to shade a number of contiguous regions using continuous colors.\n"
20052  " In particular the edge contours are treated properly in plshades. If\n"
20053  " you attempt to do contiguous regions with plshade the contours at the\n"
20054  " edge of the shade are partially obliterated by subsequent plots of\n"
20055  " contiguous shaded regions.\n"
20056  "\n"
20057  " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20058  " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20059  " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20060  "\n"
20061  "\n"
20062  " This function is used in example 15.\n"
20063  "\n"
20064  "\n"
20065  "\n"
20066  "SYNOPSIS:\n"
20067  "\n"
20068  "plshade(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"
20069  "\n"
20070  "ARGUMENTS:\n"
20071  "\n"
20072  " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20073  " plot. Should have dimensions of\n"
20074  " nx by\n"
20075  " ny.\n"
20076  "\n"
20077  " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20078  "\n"
20079  " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20080  "\n"
20081  " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20082  " the region that should be plotted in the shade plot. This\n"
20083  " function accepts x and y coordinates as input arguments and must\n"
20084  " return 1 if the point is to be included in the shade plot and 0\n"
20085  " otherwise. If you want to plot the entire shade plot (the usual\n"
20086  " case), this argument should be set to NULL.\n"
20087  "\n"
20088  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20089  " pltr below for how these arguments are used (only for the special case\n"
20090  " when the callback function\n"
20091  " pltr is not supplied).\n"
20092  "\n"
20093  " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20094  " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20095  "\n"
20096  " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20097  " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20098  "\n"
20099  " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20100  " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20101  " then sh_color is interpreted as a cmap1 argument in the range\n"
20102  " (0.0-1.0).\n"
20103  "\n"
20104  " sh_color (PLFLT, input) : Defines color map index with integer\n"
20105  " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20106  "\n"
20107  " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20108  "\n"
20109  " min_color (PLINT, input) : Defines pen color, width used by the\n"
20110  " boundary of shaded region. The min values are used for the\n"
20111  " shade_min boundary, and the max values are used on the shade_max\n"
20112  " boundary. Set color and width to zero for no plotted boundaries.\n"
20113  "\n"
20114  " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20115  " boundary of shaded region. The min values are used for the\n"
20116  " shade_min boundary, and the max values are used on the shade_max\n"
20117  " boundary. Set color and width to zero for no plotted boundaries.\n"
20118  "\n"
20119  " max_color (PLINT, input) : Defines pen color, width used by the\n"
20120  " boundary of shaded region. The min values are used for the\n"
20121  " shade_min boundary, and the max values are used on the shade_max\n"
20122  " boundary. Set color and width to zero for no plotted boundaries.\n"
20123  "\n"
20124  " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20125  " boundary of shaded region. The min values are used for the\n"
20126  " shade_min boundary, and the max values are used on the shade_max\n"
20127  " boundary. Set color and width to zero for no plotted boundaries.\n"
20128  "\n"
20129  " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20130  " Use plfill. Future version of PLplot may have other fill\n"
20131  " routines.\n"
20132  "\n"
20133  " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20134  " map to rectangles after coordinate transformation with pltrl.\n"
20135  " Otherwise, set rectangular to false. If rectangular is set to\n"
20136  " true, plshade tries to save time by filling large rectangles.\n"
20137  " This optimization fails if the coordinate transformation distorts\n"
20138  " the shape of rectangles. For example a plot in polar coordinates\n"
20139  " has to have rectangular set to false.\n"
20140  "\n"
20141  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20142  " defines the transformation between the zero-based indices of the\n"
20143  " matrix a and world coordinates. If\n"
20144  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20145  " indices of a are mapped to the range\n"
20146  " xmin through\n"
20147  " xmax and the y indices of a are mapped to the range\n"
20148  " ymin through\n"
20149  " ymax.For the C case, transformation functions are provided in the\n"
20150  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20151  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20152  " matrices. In addition, C callback routines for the transformation\n"
20153  " can be supplied by the user such as the mypltr function in\n"
20154  " examples/c/x09c.c which provides a general linear transformation\n"
20155  " between index coordinates and world coordinates.For languages\n"
20156  " other than C you should consult the PLplot documentation for the\n"
20157  " details concerning how PLTRANSFORM_callback arguments are\n"
20158  " interfaced. However, in general, a particular pattern of\n"
20159  " callback-associated arguments such as a tr vector with 6 elements;\n"
20160  " xg and yg vectors; or xg and yg matrices are respectively\n"
20161  " interfaced to a linear-transformation routine similar to the above\n"
20162  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20163  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20164  " support native language callbacks for handling index to\n"
20165  " world-coordinate transformations. Examples of these various\n"
20166  " approaches are given in examples/<language>x09*,\n"
20167  " examples/<language>x16*, examples/<language>x20*,\n"
20168  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20169  " supported languages.\n"
20170  "\n"
20171  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20172  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20173  " externally supplied.\n"
20174  "\n"
20175  ""},
20176  { "plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, "\n"
20177  "Assign a function to use for generating custom axis labels\n"
20178  "\n"
20179  "DESCRIPTION:\n"
20180  "\n"
20181  " This function allows a user to provide their own function to provide\n"
20182  " axis label text. The user function is given the numeric value for a\n"
20183  " point on an axis and returns a string label to correspond with that\n"
20184  " value. Custom axis labels can be enabled by passing appropriate\n"
20185  " arguments to plenv, plbox, plbox3 and similar functions.\n"
20186  "\n"
20187  " This function is used in example 19.\n"
20188  "\n"
20189  "\n"
20190  "\n"
20191  "SYNOPSIS:\n"
20192  "\n"
20193  "plslabelfunc(label_func, label_data)\n"
20194  "\n"
20195  "ARGUMENTS:\n"
20196  "\n"
20197  " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20198  " label function. In order to reset to the default labelling, set\n"
20199  " this to NULL. The labelling function parameters are, in order:\n"
20200  " axis: This indicates which axis a label is being requested for.\n"
20201  " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20202  "\n"
20203  " value: This is the value along the axis which is being labelled.\n"
20204  "\n"
20205  " label_text: The string representation of the label value.\n"
20206  "\n"
20207  " length: The maximum length in characters allowed for label_text.\n"
20208  "\n"
20209  "\n"
20210  " label_data (PLPointer, input) : This parameter may be used to pass\n"
20211  " data to the label_func function.\n"
20212  "\n"
20213  ""},
20214  { "plsmaj", _wrap_plsmaj, METH_VARARGS, "\n"
20215  "Set length of major ticks\n"
20216  "\n"
20217  "DESCRIPTION:\n"
20218  "\n"
20219  " This sets up the length of the major ticks. The actual length is the\n"
20220  " product of the default length and a scaling factor as for character\n"
20221  " height.\n"
20222  "\n"
20223  " Redacted form: plsmaj(def, scale)\n"
20224  "\n"
20225  " This function is used in example 29.\n"
20226  "\n"
20227  "\n"
20228  "\n"
20229  "SYNOPSIS:\n"
20230  "\n"
20231  "plsmaj(def, scale)\n"
20232  "\n"
20233  "ARGUMENTS:\n"
20234  "\n"
20235  " def (PLFLT, input) : The default length of a major tick in\n"
20236  " millimeters, should be set to zero if the default length is to\n"
20237  " remain unchanged.\n"
20238  "\n"
20239  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20240  " actual tick length.\n"
20241  "\n"
20242  ""},
20243  { "plsmem", _wrap_plsmem, METH_VARARGS, "\n"
20244  "Set the memory area to be plotted (RGB)\n"
20245  "\n"
20246  "DESCRIPTION:\n"
20247  "\n"
20248  " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20249  " the dev member of the stream structure. Also set the number of pixels\n"
20250  " in the memory passed in\n"
20251  " plotmem, which is a block of memory\n"
20252  " maxy by\n"
20253  " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
20254  "\n"
20255  " This memory will have to be freed by the user!\n"
20256  "\n"
20257  " Redacted form: plsmem(maxx, maxy, plotmem)\n"
20258  "\n"
20259  " This function is not used in any examples.\n"
20260  "\n"
20261  "\n"
20262  "\n"
20263  "SYNOPSIS:\n"
20264  "\n"
20265  "plsmem(maxx, maxy, plotmem)\n"
20266  "\n"
20267  "ARGUMENTS:\n"
20268  "\n"
20269  " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20270  "\n"
20271  " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20272  "\n"
20273  " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
20274  " user-supplied writeable memory area.\n"
20275  "\n"
20276  ""},
20277  { "plsmema", _wrap_plsmema, METH_VARARGS, "\n"
20278  "Set the memory area to be plotted (RGBA)\n"
20279  "\n"
20280  "DESCRIPTION:\n"
20281  "\n"
20282  " Set the memory area to be plotted (with the memcairo driver) as the\n"
20283  " dev member of the stream structure. Also set the number of pixels in\n"
20284  " the memory passed in\n"
20285  " plotmem, which is a block of memory\n"
20286  " maxy by\n"
20287  " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
20288  "\n"
20289  " This memory will have to be freed by the user!\n"
20290  "\n"
20291  " Redacted form: plsmema(maxx, maxy, plotmem)\n"
20292  "\n"
20293  " This function is not used in any examples.\n"
20294  "\n"
20295  "\n"
20296  "\n"
20297  "SYNOPSIS:\n"
20298  "\n"
20299  "plsmema(maxx, maxy, plotmem)\n"
20300  "\n"
20301  "ARGUMENTS:\n"
20302  "\n"
20303  " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20304  "\n"
20305  " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20306  "\n"
20307  " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
20308  " user-supplied writeable memory area.\n"
20309  "\n"
20310  ""},
20311  { "plsmin", _wrap_plsmin, METH_VARARGS, "\n"
20312  "Set length of minor ticks\n"
20313  "\n"
20314  "DESCRIPTION:\n"
20315  "\n"
20316  " This sets up the length of the minor ticks and the length of the\n"
20317  " terminals on error bars. The actual length is the product of the\n"
20318  " default length and a scaling factor as for character height.\n"
20319  "\n"
20320  " Redacted form: plsmin(def, scale)\n"
20321  "\n"
20322  " This function is used in example 29.\n"
20323  "\n"
20324  "\n"
20325  "\n"
20326  "SYNOPSIS:\n"
20327  "\n"
20328  "plsmin(def, scale)\n"
20329  "\n"
20330  "ARGUMENTS:\n"
20331  "\n"
20332  " def (PLFLT, input) : The default length of a minor tick in\n"
20333  " millimeters, should be set to zero if the default length is to\n"
20334  " remain unchanged.\n"
20335  "\n"
20336  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20337  " actual tick length.\n"
20338  "\n"
20339  ""},
20340  { "plsori", _wrap_plsori, METH_O, "\n"
20341  "Set orientation\n"
20342  "\n"
20343  "DESCRIPTION:\n"
20344  "\n"
20345  " Set integer plot orientation parameter. This function is identical to\n"
20346  " plsdiori except for the type of the argument, and should be used in\n"
20347  " the same way. See the documentation of plsdiori for details.\n"
20348  "\n"
20349  " Redacted form: plsori(ori)\n"
20350  "\n"
20351  " This function is used in example 3.\n"
20352  "\n"
20353  "\n"
20354  "\n"
20355  "SYNOPSIS:\n"
20356  "\n"
20357  "plsori(ori)\n"
20358  "\n"
20359  "ARGUMENTS:\n"
20360  "\n"
20361  " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
20362  " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
20363  " angle.\n"
20364  "\n"
20365  ""},
20366  { "plspage", _wrap_plspage, METH_VARARGS, "\n"
20367  "Set page parameters\n"
20368  "\n"
20369  "DESCRIPTION:\n"
20370  "\n"
20371  " Sets the page configuration (optional). If an individual parameter is\n"
20372  " zero then that parameter value is not updated. Not all parameters are\n"
20373  " recognized by all drivers and the interpretation is device-dependent.\n"
20374  " The X-window driver uses the length and offset parameters to determine\n"
20375  " the window size and location. The length and offset values are\n"
20376  " expressed in units that are specific to the current driver. For\n"
20377  " instance: screen drivers will usually interpret them as number of\n"
20378  " pixels, whereas printer drivers will usually use mm.\n"
20379  "\n"
20380  " This routine, if used, must be called before initializing PLplot. It\n"
20381  " may be called at later times for interactive drivers to change only\n"
20382  " the dpi for subsequent redraws which you can force via a call to\n"
20383  " plreplot. If this function is not called then the page size defaults\n"
20384  " to landscape A4 for drivers which use real world page sizes and 744\n"
20385  " pixels wide by 538 pixels high for raster drivers. The default value\n"
20386  " for dx and dy is 90 pixels per inch for raster drivers.\n"
20387  "\n"
20388  "\n"
20389  "\n"
20390  " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20391  "\n"
20392  " This function is used in examples 14 and 31.\n"
20393  "\n"
20394  "\n"
20395  "\n"
20396  "SYNOPSIS:\n"
20397  "\n"
20398  "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20399  "\n"
20400  "ARGUMENTS:\n"
20401  "\n"
20402  " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
20403  " by raster drivers, ignored by drivers which use \"real world\" units\n"
20404  " (e.g. mm).\n"
20405  "\n"
20406  " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
20407  " by raster drivers, ignored by drivers which use \"real world\" units\n"
20408  " (e.g. mm).\n"
20409  "\n"
20410  " xleng (PLINT, input) : Page length, x.\n"
20411  "\n"
20412  " yleng (PLINT, input) : Page length, y.\n"
20413  "\n"
20414  " xoff (PLINT, input) : Page offset, x.\n"
20415  "\n"
20416  " yoff (PLINT, input) : Page offset, y.\n"
20417  "\n"
20418  ""},
20419  { "plspal0", _wrap_plspal0, METH_O, "\n"
20420  "Set the cmap0 palette using the specified cmap0*.pal format file\n"
20421  "\n"
20422  "DESCRIPTION:\n"
20423  "\n"
20424  " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
20425  "\n"
20426  " Redacted form: plspal0(filename)\n"
20427  "\n"
20428  " This function is in example 16.\n"
20429  "\n"
20430  "\n"
20431  "\n"
20432  "SYNOPSIS:\n"
20433  "\n"
20434  "plspal0(filename)\n"
20435  "\n"
20436  "ARGUMENTS:\n"
20437  "\n"
20438  " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
20439  " containing the name of the cmap0*.pal file. If this string is\n"
20440  " empty, use the default cmap0*.pal file.\n"
20441  "\n"
20442  ""},
20443  { "plspal1", _wrap_plspal1, METH_VARARGS, "\n"
20444  "Set the cmap1 palette using the specified cmap1*.pal format file\n"
20445  "\n"
20446  "DESCRIPTION:\n"
20447  "\n"
20448  " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
20449  "\n"
20450  " Redacted form: plspal1(filename, interpolate)\n"
20451  "\n"
20452  " This function is used in example 16.\n"
20453  "\n"
20454  "\n"
20455  "\n"
20456  "SYNOPSIS:\n"
20457  "\n"
20458  "plspal1(filename, interpolate)\n"
20459  "\n"
20460  "ARGUMENTS:\n"
20461  "\n"
20462  " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
20463  " containing the name of the cmap1*.pal file. If this string is\n"
20464  " empty, use the default cmap1*.pal file.\n"
20465  "\n"
20466  " interpolate (PLBOOL, input) : If this parameter is true, the\n"
20467  " columns containing the intensity index, r, g, b, alpha and\n"
20468  " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
20469  " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
20470  " a flag which controls whether the r, g, b data sent to plscmap1la\n"
20471  " are interpreted as HLS or RGB.) If this parameter is false, the\n"
20472  " intensity index and alt_hue_path columns are ignored and the r, g,\n"
20473  " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
20474  " are used instead to set the cmap1 palette directly with a call to\n"
20475  " plscmap1a.\n"
20476  "\n"
20477  ""},
20478  { "plspause", _wrap_plspause, METH_O, "\n"
20479  "Set the pause (on end-of-page) status\n"
20480  "\n"
20481  "DESCRIPTION:\n"
20482  "\n"
20483  " Set the pause (on end-of-page) status.\n"
20484  "\n"
20485  " Redacted form: plspause(pause)\n"
20486  "\n"
20487  " This function is in examples 14,20.\n"
20488  "\n"
20489  "\n"
20490  "\n"
20491  "SYNOPSIS:\n"
20492  "\n"
20493  "plspause(pause)\n"
20494  "\n"
20495  "ARGUMENTS:\n"
20496  "\n"
20497  " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
20498  " end-of-page for those drivers which support this. Otherwise there\n"
20499  " is no pause.\n"
20500  "\n"
20501  ""},
20502  { "plsstrm", _wrap_plsstrm, METH_O, "\n"
20503  "Set current output stream\n"
20504  "\n"
20505  "DESCRIPTION:\n"
20506  "\n"
20507  " Sets the number of the current output stream. The stream number\n"
20508  " defaults to 0 unless changed by this routine. The first use of this\n"
20509  " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
20510  "\n"
20511  " Redacted form: plsstrm(strm)\n"
20512  "\n"
20513  " This function is examples 1,14,20.\n"
20514  "\n"
20515  "\n"
20516  "\n"
20517  "SYNOPSIS:\n"
20518  "\n"
20519  "plsstrm(strm)\n"
20520  "\n"
20521  "ARGUMENTS:\n"
20522  "\n"
20523  " strm (PLINT, input) : The current stream number.\n"
20524  "\n"
20525  ""},
20526  { "plssub", _wrap_plssub, METH_VARARGS, "\n"
20527  "Set the number of subpages in x and y\n"
20528  "\n"
20529  "DESCRIPTION:\n"
20530  "\n"
20531  " Set the number of subpages in x and y.\n"
20532  "\n"
20533  " Redacted form: plssub(nx, ny)\n"
20534  "\n"
20535  " This function is examples 1,2,14,21,25,27.\n"
20536  "\n"
20537  "\n"
20538  "\n"
20539  "SYNOPSIS:\n"
20540  "\n"
20541  "plssub(nx, ny)\n"
20542  "\n"
20543  "ARGUMENTS:\n"
20544  "\n"
20545  " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
20546  " of window columns).\n"
20547  "\n"
20548  " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
20549  " of window rows).\n"
20550  "\n"
20551  ""},
20552  { "plssym", _wrap_plssym, METH_VARARGS, "\n"
20553  "Set symbol size\n"
20554  "\n"
20555  "DESCRIPTION:\n"
20556  "\n"
20557  " This sets up the size of all subsequent symbols drawn by plpoin and\n"
20558  " plsym. The actual height of a symbol is the product of the default\n"
20559  " symbol size and a scaling factor as for the character height.\n"
20560  "\n"
20561  " Redacted form: plssym(def, scale)\n"
20562  "\n"
20563  " This function is used in example 29.\n"
20564  "\n"
20565  "\n"
20566  "\n"
20567  "SYNOPSIS:\n"
20568  "\n"
20569  "plssym(def, scale)\n"
20570  "\n"
20571  "ARGUMENTS:\n"
20572  "\n"
20573  " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
20574  " should be set to zero if the default height is to remain\n"
20575  " unchanged.\n"
20576  "\n"
20577  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20578  " actual symbol height.\n"
20579  "\n"
20580  ""},
20581  { "plstar", _wrap_plstar, METH_VARARGS, "\n"
20582  "Initialization\n"
20583  "\n"
20584  "DESCRIPTION:\n"
20585  "\n"
20586  " Initializing the plotting package. The program prompts for the device\n"
20587  " keyword or number of the desired output device. Hitting a RETURN in\n"
20588  " response to the prompt is the same as selecting the first device. If\n"
20589  " only one device is enabled when PLplot is installed, plstar will issue\n"
20590  " no prompt. The output device is divided into nx by ny subpages, each\n"
20591  " of which may be used independently. The subroutine pladv is used to\n"
20592  " advance from one subpage to the next.\n"
20593  "\n"
20594  " Redacted form: plstar(nx, ny)\n"
20595  "\n"
20596  " This function is used in example 1.\n"
20597  "\n"
20598  "\n"
20599  "\n"
20600  "SYNOPSIS:\n"
20601  "\n"
20602  "plstar(nx, ny)\n"
20603  "\n"
20604  "ARGUMENTS:\n"
20605  "\n"
20606  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
20607  " x direction.\n"
20608  "\n"
20609  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
20610  " y direction.\n"
20611  "\n"
20612  ""},
20613  { "plstart", _wrap_plstart, METH_VARARGS, "\n"
20614  "Initialization\n"
20615  "\n"
20616  "DESCRIPTION:\n"
20617  "\n"
20618  " Alternative to plstar for initializing the plotting package. The\n"
20619  " device name keyword for the desired output device must be supplied as\n"
20620  " an argument. These keywords are the same as those printed out by\n"
20621  " plstar. If the requested device is not available, or if the input\n"
20622  " string is empty or begins with ``?'', the prompted start up of plstar\n"
20623  " is used. This routine also divides the output device page into nx by\n"
20624  " ny subpages, each of which may be used independently. The subroutine\n"
20625  " pladv is used to advance from one subpage to the next.\n"
20626  "\n"
20627  " Redacted form: General: plstart(devname, nx, ny)\n"
20628  "\n"
20629  "\n"
20630  " This function is not used in any examples.\n"
20631  "\n"
20632  "\n"
20633  "\n"
20634  "SYNOPSIS:\n"
20635  "\n"
20636  "plstart(devname, nx, ny)\n"
20637  "\n"
20638  "ARGUMENTS:\n"
20639  "\n"
20640  " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20641  " containing the device name keyword of the required output device.\n"
20642  " If\n"
20643  " devname is NULL or if the first character of the string is a ``?'',\n"
20644  " the normal (prompted) start up is used.\n"
20645  "\n"
20646  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
20647  " x direction.\n"
20648  "\n"
20649  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
20650  " y direction.\n"
20651  "\n"
20652  ""},
20653  { "plstransform", _wrap_plstransform, METH_VARARGS, "\n"
20654  "Set a global coordinate transform function\n"
20655  "\n"
20656  "DESCRIPTION:\n"
20657  "\n"
20658  " This function can be used to define a coordinate transformation which\n"
20659  " affects all elements drawn within the current plot window. The\n"
20660  " coordinate_transform callback function is similar to that provided for\n"
20661  " the plmap and plmeridians functions. The coordinate_transform_data\n"
20662  " parameter may be used to pass extra data to coordinate_transform.\n"
20663  "\n"
20664  " Redacted form: General: plstransform(coordinate_transform,\n"
20665  " coordinate_transform_data)\n"
20666  "\n"
20667  "\n"
20668  " This function is used in examples 19 and 22.\n"
20669  "\n"
20670  "\n"
20671  "\n"
20672  "SYNOPSIS:\n"
20673  "\n"
20674  "plstransform(coordinate_transform, coordinate_transform_data)\n"
20675  "\n"
20676  "ARGUMENTS:\n"
20677  "\n"
20678  " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
20679  " function that defines the transformation from the input (x, y)\n"
20680  " world coordinates to new PLplot world coordinates. If\n"
20681  " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
20682  " case), then no transform is applied.\n"
20683  "\n"
20684  " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
20685  " for\n"
20686  " coordinate_transform.\n"
20687  "\n"
20688  ""},
20689  { "plstring", _wrap_plstring, METH_VARARGS, "\n"
20690  "Plot a glyph at the specified points\n"
20691  "\n"
20692  "DESCRIPTION:\n"
20693  "\n"
20694  " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
20695  " because many[!] more glyphs are accessible with plstring.) The glyph\n"
20696  " is specified with a PLplot user string. Note that the user string is\n"
20697  " not actually limited to one glyph so it is possible (but not normally\n"
20698  " useful) to plot more than one glyph at the specified points with this\n"
20699  " function. As with plmtex and plptex, the user string can contain FCI\n"
20700  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
20701  " else PLplot escapes for Hershey or unicode text to determine the\n"
20702  " glyph.\n"
20703  "\n"
20704  " Redacted form: plstring(x, y, string)\n"
20705  "\n"
20706  " This function is used in examples 4, 21 and 26.\n"
20707  "\n"
20708  "\n"
20709  "\n"
20710  "SYNOPSIS:\n"
20711  "\n"
20712  "plstring(n, x, y, string)\n"
20713  "\n"
20714  "ARGUMENTS:\n"
20715  "\n"
20716  " n (PLINT, input) : Number of points in the x and y vectors.\n"
20717  "\n"
20718  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
20719  " the points.\n"
20720  "\n"
20721  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
20722  " the points.\n"
20723  "\n"
20724  " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20725  " the glyph(s) to be plotted at each of the n points.\n"
20726  "\n"
20727  ""},
20728  { "plstring3", _wrap_plstring3, METH_VARARGS, "\n"
20729  "Plot a glyph at the specified 3D points\n"
20730  "\n"
20731  "DESCRIPTION:\n"
20732  "\n"
20733  " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
20734  " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
20735  " this function similar to what is done for plline3. The glyph is\n"
20736  " specified with a PLplot user string. Note that the user string is not\n"
20737  " actually limited to one glyph so it is possible (but not normally\n"
20738  " useful) to plot more than one glyph at the specified points with this\n"
20739  " function. As with plmtex and plptex, the user string can contain FCI\n"
20740  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
20741  " else PLplot escapes for Hershey or unicode text to determine the\n"
20742  " glyph.\n"
20743  "\n"
20744  " Redacted form: plstring3(x, y, z, string)\n"
20745  "\n"
20746  " This function is used in example 18.\n"
20747  "\n"
20748  "\n"
20749  "\n"
20750  "SYNOPSIS:\n"
20751  "\n"
20752  "plstring3(n, x, y, z, string)\n"
20753  "\n"
20754  "ARGUMENTS:\n"
20755  "\n"
20756  " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
20757  "\n"
20758  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
20759  " the points.\n"
20760  "\n"
20761  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
20762  " the points.\n"
20763  "\n"
20764  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
20765  " the points.\n"
20766  "\n"
20767  " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20768  " the glyph(s) to be plotted at each of the n points. points.\n"
20769  "\n"
20770  ""},
20771  { "plstripa", _wrap_plstripa, METH_VARARGS, "\n"
20772  "Add a point to a strip chart\n"
20773  "\n"
20774  "DESCRIPTION:\n"
20775  "\n"
20776  " Add a point to a given pen of a given strip chart. There is no need\n"
20777  " for all pens to have the same number of points or to be equally\n"
20778  " sampled in the x coordinate. Allocates memory and rescales as\n"
20779  " necessary.\n"
20780  "\n"
20781  " Redacted form: plstripa(id, pen, x, y)\n"
20782  "\n"
20783  " This function is used in example 17.\n"
20784  "\n"
20785  "\n"
20786  "\n"
20787  "SYNOPSIS:\n"
20788  "\n"
20789  "plstripa(id, pen, x, y)\n"
20790  "\n"
20791  "ARGUMENTS:\n"
20792  "\n"
20793  " id (PLINT, input) : Identification number of the strip chart (set\n"
20794  " up in plstripc).\n"
20795  "\n"
20796  " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
20797  "\n"
20798  " x (PLFLT, input) : X coordinate of point to plot.\n"
20799  "\n"
20800  " y (PLFLT, input) : Y coordinate of point to plot.\n"
20801  "\n"
20802  ""},
20803  { "plstripc", _wrap_plstripc, METH_VARARGS, "\n"
20804  "Create a 4-pen strip chart\n"
20805  "\n"
20806  "DESCRIPTION:\n"
20807  "\n"
20808  " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
20809  "\n"
20810  " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
20811  " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
20812  " styline, legline, labx, laby, labz)\n"
20813  "\n"
20814  "\n"
20815  " This function is used in example 17.\n"
20816  "\n"
20817  "\n"
20818  "\n"
20819  "SYNOPSIS:\n"
20820  "\n"
20821  "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
20822  "\n"
20823  "ARGUMENTS:\n"
20824  "\n"
20825  " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
20826  " number of the strip chart to use on plstripa and plstripd.\n"
20827  "\n"
20828  " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20829  " the x-axis specification as in plbox.\n"
20830  "\n"
20831  " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20832  " the y-axis specification as in plbox.\n"
20833  "\n"
20834  " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
20835  " change as data are added.\n"
20836  "\n"
20837  " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
20838  " change as data are added.\n"
20839  "\n"
20840  " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
20841  " is multiplied by the factor (1 +\n"
20842  " xjump) .\n"
20843  "\n"
20844  " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
20845  " change as data are added.\n"
20846  "\n"
20847  " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
20848  " change as data are added.\n"
20849  "\n"
20850  " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
20851  "\n"
20852  " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
20853  "\n"
20854  " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
20855  " true, otherwise not.\n"
20856  "\n"
20857  " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
20858  " otherwise slide display.\n"
20859  "\n"
20860  " colbox (PLINT, input) : Plot box color index (cmap0).\n"
20861  "\n"
20862  " collab (PLINT, input) : Legend color index (cmap0).\n"
20863  "\n"
20864  " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
20865  " indices for the 4 pens.\n"
20866  "\n"
20867  " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
20868  " indices for the 4 pens.\n"
20869  "\n"
20870  " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
20871  " strings containing legends for the 4 pens.\n"
20872  "\n"
20873  " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20874  " the label for the x axis.\n"
20875  "\n"
20876  " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20877  " the label for the y axis.\n"
20878  "\n"
20879  " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20880  " the plot title.\n"
20881  "\n"
20882  ""},
20883  { "plstripd", _wrap_plstripd, METH_O, "\n"
20884  "Deletes and releases memory used by a strip chart\n"
20885  "\n"
20886  "DESCRIPTION:\n"
20887  "\n"
20888  " Deletes and releases memory used by a strip chart.\n"
20889  "\n"
20890  " Redacted form: plstripd(id)\n"
20891  "\n"
20892  " This function is used in example 17.\n"
20893  "\n"
20894  "\n"
20895  "\n"
20896  "SYNOPSIS:\n"
20897  "\n"
20898  "plstripd(id)\n"
20899  "\n"
20900  "ARGUMENTS:\n"
20901  "\n"
20902  " id (PLINT, input) : Identification number of strip chart to delete.\n"
20903  "\n"
20904  ""},
20905  { "plstyl", _wrap_plstyl, METH_VARARGS, "\n"
20906  "Set line style\n"
20907  "\n"
20908  "DESCRIPTION:\n"
20909  "\n"
20910  " This sets up the line style for all lines subsequently drawn. A line\n"
20911  " consists of segments in which the pen is alternately down and up. The\n"
20912  " lengths of these segments are passed in the vectors mark and space\n"
20913  " respectively. The number of mark-space pairs is specified by nms. In\n"
20914  " order to return the line style to the default continuous line, plstyl\n"
20915  " should be called with nms =0 .(see also pllsty)\n"
20916  "\n"
20917  " Redacted form: plstyl(mark, space)\n"
20918  "\n"
20919  " This function is used in examples 1, 9, and 14.\n"
20920  "\n"
20921  "\n"
20922  "\n"
20923  "SYNOPSIS:\n"
20924  "\n"
20925  "plstyl(nms, mark, space)\n"
20926  "\n"
20927  "ARGUMENTS:\n"
20928  "\n"
20929  " nms (PLINT, input) : The number of mark and space elements in a\n"
20930  " line. Thus a simple broken line can be obtained by setting nms=1\n"
20931  " . A continuous line is specified by setting nms=0 .\n"
20932  "\n"
20933  " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
20934  " segments during which the pen is down, measured in micrometers.\n"
20935  "\n"
20936  " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
20937  " the segments during which the pen is up, measured in micrometers.\n"
20938  "\n"
20939  ""},
20940  { "plsvect", _wrap_plsvect, METH_VARARGS, "\n"
20941  "Set arrow style for vector plots\n"
20942  "\n"
20943  "DESCRIPTION:\n"
20944  "\n"
20945  " Set the style for the arrow used by plvect to plot vectors.\n"
20946  "\n"
20947  " Redacted form: plsvect(arrowx, arrowy, fill)\n"
20948  "\n"
20949  " This function is used in example 22.\n"
20950  "\n"
20951  "\n"
20952  "\n"
20953  "SYNOPSIS:\n"
20954  "\n"
20955  "plsvect(arrowx, arrowy, npts, fill)\n"
20956  "\n"
20957  "ARGUMENTS:\n"
20958  "\n"
20959  " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
20960  " the x and y points which make up the arrow. The arrow is plotted\n"
20961  " by joining these points to form a polygon. The scaling assumes\n"
20962  " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
20963  " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
20964  " will be reset to its default.\n"
20965  "\n"
20966  " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
20967  " arrowy.\n"
20968  "\n"
20969  " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
20970  " fill is false then the arrow is open.\n"
20971  "\n"
20972  ""},
20973  { "plsvpa", _wrap_plsvpa, METH_VARARGS, "\n"
20974  "Specify viewport in absolute coordinates\n"
20975  "\n"
20976  "DESCRIPTION:\n"
20977  "\n"
20978  " Alternate routine to plvpor for setting up the viewport. This routine\n"
20979  " should be used only if the viewport is required to have a definite\n"
20980  " size in millimeters. The routine plgspa is useful for finding out the\n"
20981  " size of the current subpage.\n"
20982  "\n"
20983  " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
20984  "\n"
20985  " This function is used in example 10.\n"
20986  "\n"
20987  "\n"
20988  "\n"
20989  "SYNOPSIS:\n"
20990  "\n"
20991  "plsvpa(xmin, xmax, ymin, ymax)\n"
20992  "\n"
20993  "ARGUMENTS:\n"
20994  "\n"
20995  " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
20996  " viewport from the left-hand edge of the subpage in millimeters.\n"
20997  "\n"
20998  " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
20999  " viewport from the left-hand edge of the subpage in millimeters.\n"
21000  "\n"
21001  " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21002  " viewport from the bottom edge of the subpage in millimeters.\n"
21003  "\n"
21004  " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21005  " from the bottom edge of the subpage in millimeters.\n"
21006  "\n"
21007  ""},
21008  { "plsxax", _wrap_plsxax, METH_VARARGS, "\n"
21009  "Set x axis parameters\n"
21010  "\n"
21011  "DESCRIPTION:\n"
21012  "\n"
21013  " Sets values of the digmax and digits flags for the x axis. See the\n"
21014  " PLplot documentation for more information.\n"
21015  "\n"
21016  " Redacted form: plsxax(digmax, digits)\n"
21017  "\n"
21018  " This function is used in example 31.\n"
21019  "\n"
21020  "\n"
21021  "\n"
21022  "SYNOPSIS:\n"
21023  "\n"
21024  "plsxax(digmax, digits)\n"
21025  "\n"
21026  "ARGUMENTS:\n"
21027  "\n"
21028  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21029  " digits for the x axis. If nonzero, the printed label will be\n"
21030  " switched to a floating-point representation when the number of\n"
21031  " digits exceeds digmax.\n"
21032  "\n"
21033  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21034  " its value here has no effect since it is set only by plbox or\n"
21035  " plbox3. However, the user may obtain its value after a call to\n"
21036  " either of these functions by calling plgxax.\n"
21037  "\n"
21038  ""},
21039  { "plsyax", _wrap_plsyax, METH_VARARGS, "\n"
21040  "Set y axis parameters\n"
21041  "\n"
21042  "DESCRIPTION:\n"
21043  "\n"
21044  " Identical to plsxax, except that arguments are flags for y axis. See\n"
21045  " the description of plsxax for more detail.\n"
21046  "\n"
21047  " Redacted form: plsyax(digmax, digits)\n"
21048  "\n"
21049  " This function is used in examples 1, 14, and 31.\n"
21050  "\n"
21051  "\n"
21052  "\n"
21053  "SYNOPSIS:\n"
21054  "\n"
21055  "plsyax(digmax, digits)\n"
21056  "\n"
21057  "ARGUMENTS:\n"
21058  "\n"
21059  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21060  " digits for the y axis. If nonzero, the printed label will be\n"
21061  " switched to a floating-point representation when the number of\n"
21062  " digits exceeds digmax.\n"
21063  "\n"
21064  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21065  " its value here has no effect since it is set only by plbox or\n"
21066  " plbox3. However, the user may obtain its value after a call to\n"
21067  " either of these functions by calling plgyax.\n"
21068  "\n"
21069  ""},
21070  { "plsym", _wrap_plsym, METH_VARARGS, "\n"
21071  "Plot a glyph at the specified points\n"
21072  "\n"
21073  "DESCRIPTION:\n"
21074  "\n"
21075  " Plot a glyph at the specified points. (This function is largely\n"
21076  " superseded by plstring which gives access to many[!] more glyphs.)\n"
21077  "\n"
21078  " Redacted form: plsym(x, y, code)\n"
21079  "\n"
21080  " This function is used in example 7.\n"
21081  "\n"
21082  "\n"
21083  "\n"
21084  "SYNOPSIS:\n"
21085  "\n"
21086  "plsym(n, x, y, code)\n"
21087  "\n"
21088  "ARGUMENTS:\n"
21089  "\n"
21090  " n (PLINT, input) : Number of points in the x and y vectors.\n"
21091  "\n"
21092  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21093  " the points.\n"
21094  "\n"
21095  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21096  " the points.\n"
21097  "\n"
21098  " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21099  " to be plotted at each of the n points.\n"
21100  "\n"
21101  ""},
21102  { "plszax", _wrap_plszax, METH_VARARGS, "\n"
21103  "Set z axis parameters\n"
21104  "\n"
21105  "DESCRIPTION:\n"
21106  "\n"
21107  " Identical to plsxax, except that arguments are flags for z axis. See\n"
21108  " the description of plsxax for more detail.\n"
21109  "\n"
21110  " Redacted form: plszax(digmax, digits)\n"
21111  "\n"
21112  " This function is used in example 31.\n"
21113  "\n"
21114  "\n"
21115  "\n"
21116  "SYNOPSIS:\n"
21117  "\n"
21118  "plszax(digmax, digits)\n"
21119  "\n"
21120  "ARGUMENTS:\n"
21121  "\n"
21122  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21123  " digits for the z axis. If nonzero, the printed label will be\n"
21124  " switched to a floating-point representation when the number of\n"
21125  " digits exceeds digmax.\n"
21126  "\n"
21127  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21128  " its value here has no effect since it is set only by plbox or\n"
21129  " plbox3. However, the user may obtain its value after a call to\n"
21130  " either of these functions by calling plgzax.\n"
21131  "\n"
21132  ""},
21133  { "pltext", _wrap_pltext, METH_NOARGS, "\n"
21134  "Switch to text screen\n"
21135  "\n"
21136  "DESCRIPTION:\n"
21137  "\n"
21138  " Sets an interactive device to text mode, used in conjunction with\n"
21139  " plgra to allow graphics and text to be interspersed. On a device\n"
21140  " which supports separate text and graphics windows, this command causes\n"
21141  " control to be switched to the text window. This can be useful for\n"
21142  " printing diagnostic messages or getting user input, which would\n"
21143  " otherwise interfere with the plots. The program must switch back to\n"
21144  " the graphics window before issuing plot commands, as the text (or\n"
21145  " console) device will probably become quite confused otherwise. If\n"
21146  " already in text mode, this command is ignored. It is also ignored on\n"
21147  " devices which only support a single window or use a different method\n"
21148  " for shifting focus (see also plgra).\n"
21149  "\n"
21150  " Redacted form: pltext()\n"
21151  "\n"
21152  " This function is used in example 1.\n"
21153  "\n"
21154  "\n"
21155  "\n"
21156  "SYNOPSIS:\n"
21157  "\n"
21158  "pltext()\n"
21159  "\n"
21160  ""},
21161  { "pltimefmt", _wrap_pltimefmt, METH_O, "\n"
21162  "Set format for date / time labels\n"
21163  "\n"
21164  "DESCRIPTION:\n"
21165  "\n"
21166  " Sets the format for date / time labels. To enable date / time format\n"
21167  " labels see the options to plbox, plbox3, and plenv.\n"
21168  "\n"
21169  " Redacted form: pltimefmt(fmt)\n"
21170  "\n"
21171  " This function is used in example 29.\n"
21172  "\n"
21173  "\n"
21174  "\n"
21175  "SYNOPSIS:\n"
21176  "\n"
21177  "pltimefmt(fmt)\n"
21178  "\n"
21179  "ARGUMENTS:\n"
21180  "\n"
21181  " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21182  " interpreted similarly to the format specifier of typical system\n"
21183  " strftime routines except that PLplot ignores locale and also\n"
21184  " supplies some useful extensions in the context of plotting. All\n"
21185  " text in the string is printed as-is other than conversion\n"
21186  " specifications which take the form of a '%' character followed by\n"
21187  " further conversion specification character. The conversion\n"
21188  " specifications which are similar to those provided by system\n"
21189  " strftime routines are the following: %a: The abbreviated (English)\n"
21190  " weekday name.\n"
21191  " %A: The full (English) weekday name.\n"
21192  " %b: The abbreviated (English) month name.\n"
21193  " %B: The full (English) month name.\n"
21194  " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21195  " %C: The century number (year/100) as a 2-digit integer.\n"
21196  " %d: The day of the month as a decimal number (range 01 to 31).\n"
21197  " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21198  " %e: Like %d, but a leading zero is replaced by a space.\n"
21199  " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21200  " %h: Equivalent to %b.\n"
21201  " %H: The hour as a decimal number using a 24-hour clock (range\n"
21202  " 00 to 23).\n"
21203  " %I: The hour as a decimal number using a 12-hour clock (range\n"
21204  " 01 to 12).\n"
21205  " %j: The day of the year as a decimal number (range 001 to\n"
21206  " 366).\n"
21207  " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21208  " 23); single digits are preceded by a blank. (See also %H.)\n"
21209  " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21210  " 12); single digits are preceded by a blank. (See also %I.)\n"
21211  " %m: The month as a decimal number (range 01 to 12).\n"
21212  " %M: The minute as a decimal number (range 00 to 59).\n"
21213  " %n: A newline character.\n"
21214  " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21215  " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21216  " %r: Equivalent to %I:%M:%S %p.\n"
21217  " %R: The time in 24-hour notation (%H:%M). For a version\n"
21218  " including the seconds, see %T below.\n"
21219  " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21220  " +0000 (UTC).\n"
21221  " %S: The second as a decimal number (range 00 to 60). (The\n"
21222  " range is up to 60 to allow for occasional leap seconds.)\n"
21223  " %t: A tab character.\n"
21224  " %T: The time in 24-hour notation (%H:%M:%S).\n"
21225  " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21226  " being 1. See also %w.\n"
21227  " %U: The week number of the current year as a decimal number,\n"
21228  " range 00 to 53, starting with the first Sunday as the first\n"
21229  " day of week 01. See also %V and %W.\n"
21230  " %v: Equivalent to %e-%b-%Y.\n"
21231  " %V: The ISO 8601 week number of the current year as a decimal\n"
21232  " number, range 01 to 53, where week 1 is the first week that\n"
21233  " has at least 4 days in the new year. See also %U and %W.\n"
21234  " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21235  " being 0. See also %u.\n"
21236  " %W: The week number of the current year as a decimal number,\n"
21237  " range 00 to 53, starting with the first Monday as the first\n"
21238  " day of week 01.\n"
21239  " %x: Equivalent to %a %b %d %Y.\n"
21240  " %X: Equivalent to %T.\n"
21241  " %y: The year as a decimal number without a century (range 00\n"
21242  " to 99).\n"
21243  " %Y: The year as a decimal number including a century.\n"
21244  " %z: The UTC time-zone string = \"+0000\".\n"
21245  " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
21246  " %+: The UTC date and time in default format of the Unix date\n"
21247  " command which is equivalent to %a %b %d %T %Z %Y.\n"
21248  " %%: A literal \"%\" character.\n"
21249  " The conversion specifications which are extensions to those normally\n"
21250  " provided by system strftime routines are the following: %(0-9):\n"
21251  " The fractional part of the seconds field (including leading\n"
21252  " decimal point) to the specified accuracy. Thus %S%3 would give\n"
21253  " seconds to millisecond accuracy (00.000).\n"
21254  " %.: The fractional part of the seconds field (including\n"
21255  " leading decimal point) to the maximum available accuracy. Thus\n"
21256  " %S%. would give seconds with fractional part up to 9 decimal\n"
21257  " places if available.\n"
21258  "\n"
21259  ""},
21260  { "plvasp", _wrap_plvasp, METH_O, "\n"
21261  "Specify viewport using aspect ratio only\n"
21262  "\n"
21263  "DESCRIPTION:\n"
21264  "\n"
21265  " Selects the largest viewport with the given aspect ratio within the\n"
21266  " subpage that leaves a standard margin (left-hand margin of eight\n"
21267  " character heights, and a margin around the other three sides of five\n"
21268  " character heights).\n"
21269  "\n"
21270  " Redacted form: plvasp(aspect)\n"
21271  "\n"
21272  " This function is used in example 13.\n"
21273  "\n"
21274  "\n"
21275  "\n"
21276  "SYNOPSIS:\n"
21277  "\n"
21278  "plvasp(aspect)\n"
21279  "\n"
21280  "ARGUMENTS:\n"
21281  "\n"
21282  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21283  " axis of resulting viewport.\n"
21284  "\n"
21285  ""},
21286  { "plvect", _wrap_plvect, METH_VARARGS, "\n"
21287  "Vector plot\n"
21288  "\n"
21289  "DESCRIPTION:\n"
21290  "\n"
21291  " Draws a plot of vector data contained in the matrices (\n"
21292  " u[\n"
21293  " nx][\n"
21294  " ny],\n"
21295  " v[\n"
21296  " nx][\n"
21297  " ny]) . The scaling factor for the vectors is given by scale. A\n"
21298  " transformation routine pointed to by pltr with a pointer pltr_data for\n"
21299  " additional data required by the transformation routine to map indices\n"
21300  " within the matrices to the world coordinates. The style of the vector\n"
21301  " arrow may be set using plsvect.\n"
21302  "\n"
21303  " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
21304  " discussion) the pltr, pltr_data callback arguments are sometimes\n"
21305  " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
21306  " with either one or two dimensions.\n"
21307  "\n"
21308  " This function is used in example 22.\n"
21309  "\n"
21310  "\n"
21311  "\n"
21312  "SYNOPSIS:\n"
21313  "\n"
21314  "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
21315  "\n"
21316  "ARGUMENTS:\n"
21317  "\n"
21318  " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
21319  " and y components of the vector data to be plotted.\n"
21320  "\n"
21321  " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
21322  "\n"
21323  " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
21324  " the vectors for plotting. If scale = 0 then the scaling factor is\n"
21325  " automatically calculated for the data. If scale < 0 then the\n"
21326  " scaling factor is automatically calculated for the data and then\n"
21327  " multiplied by -\n"
21328  " scale. If scale > 0 then the scaling factor is set to scale.\n"
21329  "\n"
21330  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
21331  " defines the transformation between the zero-based indices of the\n"
21332  " matrices u and v and world coordinates.For the C case,\n"
21333  " transformation functions are provided in the PLplot library: pltr0\n"
21334  " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
21335  " mappings respectively defined by vectors and matrices. In\n"
21336  " addition, C callback routines for the transformation can be\n"
21337  " supplied by the user such as the mypltr function in\n"
21338  " examples/c/x09c.c which provides a general linear transformation\n"
21339  " between index coordinates and world coordinates.For languages\n"
21340  " other than C you should consult the PLplot documentation for the\n"
21341  " details concerning how PLTRANSFORM_callback arguments are\n"
21342  " interfaced. However, in general, a particular pattern of\n"
21343  " callback-associated arguments such as a tr vector with 6 elements;\n"
21344  " xg and yg vectors; or xg and yg matrices are respectively\n"
21345  " interfaced to a linear-transformation routine similar to the above\n"
21346  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
21347  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
21348  " support native language callbacks for handling index to\n"
21349  " world-coordinate transformations. Examples of these various\n"
21350  " approaches are given in examples/<language>x09*,\n"
21351  " examples/<language>x16*, examples/<language>x20*,\n"
21352  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
21353  " supported languages.\n"
21354  "\n"
21355  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
21356  " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
21357  " that is externally supplied.\n"
21358  "\n"
21359  ""},
21360  { "plvpas", _wrap_plvpas, METH_VARARGS, "\n"
21361  "Specify viewport using coordinates and aspect ratio\n"
21362  "\n"
21363  "DESCRIPTION:\n"
21364  "\n"
21365  " Device-independent routine for setting up the viewport. The viewport\n"
21366  " is chosen to be the largest with the given aspect ratio that fits\n"
21367  " within the specified region (in terms of normalized subpage\n"
21368  " coordinates). This routine is functionally equivalent to plvpor when\n"
21369  " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
21370  " routine reserves no extra space at the edges for labels.\n"
21371  "\n"
21372  " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21373  "\n"
21374  " This function is used in example 9.\n"
21375  "\n"
21376  "\n"
21377  "\n"
21378  "SYNOPSIS:\n"
21379  "\n"
21380  "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21381  "\n"
21382  "ARGUMENTS:\n"
21383  "\n"
21384  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21385  " left-hand edge of the viewport.\n"
21386  "\n"
21387  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21388  " right-hand edge of the viewport.\n"
21389  "\n"
21390  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21391  " bottom edge of the viewport.\n"
21392  "\n"
21393  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21394  " edge of the viewport.\n"
21395  "\n"
21396  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21397  " axis.\n"
21398  "\n"
21399  ""},
21400  { "plvpor", _wrap_plvpor, METH_VARARGS, "\n"
21401  "Specify viewport using normalized subpage coordinates\n"
21402  "\n"
21403  "DESCRIPTION:\n"
21404  "\n"
21405  " Device-independent routine for setting up the viewport. This defines\n"
21406  " the viewport in terms of normalized subpage coordinates which run from\n"
21407  " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
21408  " current subpage. Use the alternate routine plsvpa in order to create\n"
21409  " a viewport of a definite size.\n"
21410  "\n"
21411  " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
21412  "\n"
21413  " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
21414  " 24, 26, 27, and 31.\n"
21415  "\n"
21416  "\n"
21417  "\n"
21418  "SYNOPSIS:\n"
21419  "\n"
21420  "plvpor(xmin, xmax, ymin, ymax)\n"
21421  "\n"
21422  "ARGUMENTS:\n"
21423  "\n"
21424  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21425  " left-hand edge of the viewport.\n"
21426  "\n"
21427  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21428  " right-hand edge of the viewport.\n"
21429  "\n"
21430  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21431  " bottom edge of the viewport.\n"
21432  "\n"
21433  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21434  " edge of the viewport.\n"
21435  "\n"
21436  ""},
21437  { "plvsta", _wrap_plvsta, METH_NOARGS, "\n"
21438  "Select standard viewport\n"
21439  "\n"
21440  "DESCRIPTION:\n"
21441  "\n"
21442  " Selects the largest viewport within the subpage that leaves a standard\n"
21443  " margin (left-hand margin of eight character heights, and a margin\n"
21444  " around the other three sides of five character heights).\n"
21445  "\n"
21446  " Redacted form: plvsta()\n"
21447  "\n"
21448  " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
21449  "\n"
21450  "\n"
21451  "\n"
21452  "SYNOPSIS:\n"
21453  "\n"
21454  "plvsta()\n"
21455  "\n"
21456  ""},
21457  { "plw3d", _wrap_plw3d, METH_VARARGS, "\n"
21458  "Configure the transformations required for projecting a 3D surface on a 2D window\n"
21459  "\n"
21460  "DESCRIPTION:\n"
21461  "\n"
21462  " Configure the transformations required for projecting a 3D surface on\n"
21463  " an existing 2D window. Those transformations (see the PLplot\n"
21464  " documentation) are done to a rectangular cuboid enclosing the 3D\n"
21465  " surface which has its limits expressed in 3D world coordinates and\n"
21466  " also normalized 3D coordinates (used for interpreting the altitude and\n"
21467  " azimuth of the viewing angle). The transformations consist of the\n"
21468  " linear transform from 3D world coordinates to normalized 3D\n"
21469  " coordinates, and the 3D rotation of normalized coordinates required to\n"
21470  " align the pole of the new 3D coordinate system with the viewing\n"
21471  " direction specified by altitude and azimuth so that x and y of the\n"
21472  " surface elements in that transformed coordinate system are the\n"
21473  " projection of the 3D surface with given viewing direction on the 2D\n"
21474  " window.\n"
21475  "\n"
21476  " The enclosing rectangular cuboid for the surface plot is defined by\n"
21477  " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
21478  " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
21479  " sizes of basex by basey by height so that xmin maps to -\n"
21480  " basex/2, xmax maps to basex/2, ymin maps to -\n"
21481  " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
21482  " The resulting rectangular cuboid in normalized coordinates is then\n"
21483  " viewed by an observer at altitude alt and azimuth az. This routine\n"
21484  " must be called before plbox3 or any of the 3D surface plotting\n"
21485  " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
21486  " plsurf3dl or plfill3.\n"
21487  "\n"
21488  " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
21489  " zmin, zmax, alt, az)\n"
21490  "\n"
21491  " This function is examples 8, 11, 18, and 21.\n"
21492  "\n"
21493  "\n"
21494  "\n"
21495  "SYNOPSIS:\n"
21496  "\n"
21497  "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
21498  "\n"
21499  "ARGUMENTS:\n"
21500  "\n"
21501  " basex (PLFLT, input) : The normalized x coordinate size of the\n"
21502  " rectangular cuboid.\n"
21503  "\n"
21504  " basey (PLFLT, input) : The normalized y coordinate size of the\n"
21505  " rectangular cuboid.\n"
21506  "\n"
21507  " height (PLFLT, input) : The normalized z coordinate size of the\n"
21508  " rectangular cuboid.\n"
21509  "\n"
21510  " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
21511  " rectangular cuboid.\n"
21512  "\n"
21513  " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
21514  " rectangular cuboid.\n"
21515  "\n"
21516  " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
21517  " rectangular cuboid.\n"
21518  "\n"
21519  " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
21520  " rectangular cuboid.\n"
21521  "\n"
21522  " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
21523  " rectangular cuboid.\n"
21524  "\n"
21525  " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
21526  " rectangular cuboid.\n"
21527  "\n"
21528  " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
21529  " plane of the rectangular cuboid in normalized coordinates.\n"
21530  "\n"
21531  " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
21532  " rectangular cuboid in normalized coordinates. When az=0, the\n"
21533  " observer is looking face onto the zx plane of the rectangular\n"
21534  " cuboid in normalized coordinates, and as az is increased, the\n"
21535  " observer moves clockwise around that cuboid when viewed from above\n"
21536  " the xy plane.\n"
21537  "\n"
21538  ""},
21539  { "plwidth", _wrap_plwidth, METH_O, "\n"
21540  "Set pen width\n"
21541  "\n"
21542  "DESCRIPTION:\n"
21543  "\n"
21544  " Sets the pen width.\n"
21545  "\n"
21546  " Redacted form: plwidth(width)\n"
21547  "\n"
21548  " This function is used in examples 1 and 2.\n"
21549  "\n"
21550  "\n"
21551  "\n"
21552  "SYNOPSIS:\n"
21553  "\n"
21554  "plwidth(width)\n"
21555  "\n"
21556  "ARGUMENTS:\n"
21557  "\n"
21558  " width (PLFLT, input) : The desired pen width. If width is negative\n"
21559  " or the same as the previous value no action is taken. width = 0.\n"
21560  " should be interpreted as as the minimum valid pen width for the\n"
21561  " device. The interpretation of positive width values is also\n"
21562  " device dependent.\n"
21563  "\n"
21564  ""},
21565  { "plwind", _wrap_plwind, METH_VARARGS, "\n"
21566  "Specify window\n"
21567  "\n"
21568  "DESCRIPTION:\n"
21569  "\n"
21570  " Specify the window, i.e., the world coordinates of the edges of the\n"
21571  " viewport.\n"
21572  "\n"
21573  " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
21574  "\n"
21575  " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
21576  " 29, and 31.\n"
21577  "\n"
21578  "\n"
21579  "\n"
21580  "SYNOPSIS:\n"
21581  "\n"
21582  "plwind(xmin, xmax, ymin, ymax)\n"
21583  "\n"
21584  "ARGUMENTS:\n"
21585  "\n"
21586  " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
21587  " of the viewport.\n"
21588  "\n"
21589  " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
21590  " of the viewport.\n"
21591  "\n"
21592  " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
21593  " the viewport.\n"
21594  "\n"
21595  " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
21596  " viewport.\n"
21597  "\n"
21598  ""},
21599  { "plxormod", _wrap_plxormod, METH_O, "\n"
21600  "Enter or leave xor mode\n"
21601  "\n"
21602  "DESCRIPTION:\n"
21603  "\n"
21604  " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
21605  " those drivers (e.g., the xwin driver) that support it. Enables\n"
21606  " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
21607  " is not capable of xor operation it returns a status of false.\n"
21608  "\n"
21609  " Redacted form: plxormod(mode, status)\n"
21610  "\n"
21611  " This function is used in examples 1 and 20.\n"
21612  "\n"
21613  "\n"
21614  "\n"
21615  "SYNOPSIS:\n"
21616  "\n"
21617  "plxormod(mode, status)\n"
21618  "\n"
21619  "ARGUMENTS:\n"
21620  "\n"
21621  " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
21622  " is false means leave xor mode.\n"
21623  "\n"
21624  " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
21625  " modestatus of true (false) means driver is capable (incapable) of\n"
21626  " xor mode.\n"
21627  "\n"
21628  ""},
21629  { "plmap", _wrap_plmap, METH_VARARGS, "\n"
21630  "Plot continental outline or shapefile data in world coordinates\n"
21631  "\n"
21632  "DESCRIPTION:\n"
21633  "\n"
21634  " Plots continental outlines or shapefile data in world coordinates. A\n"
21635  " demonstration of how to use this function to create different\n"
21636  " projections can be found in examples/c/x19c. PLplot is provided with\n"
21637  " basic coastal outlines and USA state borders. To use the map\n"
21638  " functionality PLplot must be compiled with the shapelib library.\n"
21639  " Shapefiles have become a popular standard for geographical data and\n"
21640  " data in this format can be easily found from a number of online\n"
21641  " sources. Shapefile data is actually provided as three or more files\n"
21642  " with the same filename, but different extensions. The .shp and .shx\n"
21643  " files are required for plotting Shapefile data with PLplot.\n"
21644  "\n"
21645  " PLplot currently supports the point, multipoint, polyline and polygon\n"
21646  " objects within shapefiles. However holes in polygons are not\n"
21647  " supported. When plmap is used the type of object is derived from the\n"
21648  " shapefile, if you wish to override the type then use one of the other\n"
21649  " plmap variants. The built in maps have line data only.\n"
21650  "\n"
21651  " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
21652  "\n"
21653  " This function is used in example 19.\n"
21654  "\n"
21655  "\n"
21656  "\n"
21657  "SYNOPSIS:\n"
21658  "\n"
21659  "plmap(mapform, name, minx, maxx, miny, maxy)\n"
21660  "\n"
21661  "ARGUMENTS:\n"
21662  "\n"
21663  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21664  " transform the original map data coordinates to a new coordinate\n"
21665  " system. The PLplot-supplied map data is provided as latitudes and\n"
21666  " longitudes; other Shapefile data may be provided in other\n"
21667  " coordinate systems as can be found in their .prj plain text files.\n"
21668  " For example, by using this transform we can change from a\n"
21669  " longitude, latitude coordinate to a polar stereographic\n"
21670  " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
21671  " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
21672  " corresponding y coordinates (latitudes for the PLplot supplied\n"
21673  " data). After the call to mapform(), x[] and y[] should be\n"
21674  " replaced by the corresponding plot coordinates. If no transform is\n"
21675  " desired, mapform can be replaced by NULL.\n"
21676  "\n"
21677  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21678  " the type of map plotted. This is either one of the PLplot built-in\n"
21679  " maps or the file name of a set of Shapefile files without the file\n"
21680  " extensions. For the PLplot built-in maps the possible values are:\n"
21681  " \"globe\" -- continental outlines\n"
21682  " \"usa\" -- USA and state boundaries\n"
21683  " \"cglobe\" -- continental outlines and countries\n"
21684  " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
21685  "\n"
21686  "\n"
21687  " minx (PLFLT, input) : The minimum x value of map elements to be\n"
21688  " drawn. The units must match the shapefile (built in maps are\n"
21689  " degrees lat/lon). Objects in the file which do not encroach on the\n"
21690  " box defined by minx, maxx, miny, maxy will not be rendered. But\n"
21691  " note this is simply an optimisation, not a clipping so for objects\n"
21692  " with some points inside the box and some points outside the box\n"
21693  " all the points will be rendered. These parameters also define\n"
21694  " latitude and longitude wrapping for shapefiles using these units.\n"
21695  " Longitude points will be wrapped by integer multiples of 360\n"
21696  " degrees to place them in the box. This allows the same data to be\n"
21697  " used on plots from -180-180 or 0-360 longitude ranges. In fact if\n"
21698  " you plot from -180-540 you will get two cycles of data drawn. The\n"
21699  " value of minx must be less than the value of maxx. Passing in a\n"
21700  " nan, max/-max floating point number or +/-infinity will case the\n"
21701  " bounding box from the shapefile to be used.\n"
21702  "\n"
21703  " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
21704  " drawn - see minx.\n"
21705  "\n"
21706  " miny (PLFLT, input) : The minimum y value of map elements to be\n"
21707  " drawn - see minx.\n"
21708  "\n"
21709  " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
21710  " drawn - see minx.\n"
21711  "\n"
21712  ""},
21713  { "plmapline", _wrap_plmapline, METH_VARARGS, "\n"
21714  "Plot all or a subset of Shapefile data using lines in world coordinates\n"
21715  "\n"
21716  "DESCRIPTION:\n"
21717  "\n"
21718  " Plot all or a subset of Shapefile data using lines in world\n"
21719  " coordinates. Our 19th standard example demonstrates how to use this\n"
21720  " function. This function plots data from a Shapefile using lines as in\n"
21721  " plmap, however it also has the option of also only drawing specified\n"
21722  " elements from the Shapefile. The vector of indices of the required\n"
21723  " elements are passed as a function argument. The Shapefile data should\n"
21724  " include a metadata file (extension.dbf) listing all items within the\n"
21725  " Shapefile. This file can be opened by most popular spreadsheet\n"
21726  " programs and can be used to decide which indices to pass to this\n"
21727  " function.\n"
21728  "\n"
21729  " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
21730  " plotentries)\n"
21731  "\n"
21732  " This function is used in example 19.\n"
21733  "\n"
21734  "\n"
21735  "\n"
21736  "SYNOPSIS:\n"
21737  "\n"
21738  "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
21739  "\n"
21740  "ARGUMENTS:\n"
21741  "\n"
21742  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21743  " transform the coordinates given in the shapefile into a plot\n"
21744  " coordinate system. By using this transform, we can change from a\n"
21745  " longitude, latitude coordinate to a polar stereographic project,\n"
21746  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21747  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21748  " mapform(), x[] and y[] should be replaced by the corresponding\n"
21749  " plot coordinates. If no transform is desired, mapform can be\n"
21750  " replaced by NULL.\n"
21751  "\n"
21752  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21753  " the file name of a set of Shapefile files without the file\n"
21754  " extension.\n"
21755  "\n"
21756  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21757  " be in the same units as used by the Shapefile. You could use a\n"
21758  " very large negative number to plot everything, but you can improve\n"
21759  " performance by limiting the area drawn. The units must match those\n"
21760  " of the Shapefile projection, which may be for example longitude or\n"
21761  " distance. The value of minx must be less than the value of maxx.\n"
21762  "\n"
21763  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21764  " use a very large number to plot everything, but you can improve\n"
21765  " performance by limiting the area drawn.\n"
21766  "\n"
21767  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21768  " be in the same units as used by the Shapefile. You could use a\n"
21769  " very large negative number to plot everything, but you can improve\n"
21770  " performance by limiting the area drawn. The units must match those\n"
21771  " of the Shapefile projection, which may be for example latitude or\n"
21772  " distance. The value of miny must be less than the value of maxy.\n"
21773  "\n"
21774  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21775  " use a very large number to plot everything, but you can improve\n"
21776  " performance by limiting the area drawn.\n"
21777  "\n"
21778  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
21779  " zero-based indices of the Shapefile elements which will be drawn.\n"
21780  " Setting\n"
21781  " plotentries to NULL will plot all elements of the Shapefile.\n"
21782  "\n"
21783  " nplotentries (PLINT, input) : The number of items in\n"
21784  " plotentries. Ignored if\n"
21785  " plotentries is NULL.\n"
21786  "\n"
21787  ""},
21788  { "plmapstring", _wrap_plmapstring, METH_VARARGS, "\n"
21789  "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
21790  "\n"
21791  "DESCRIPTION:\n"
21792  "\n"
21793  " As per plmapline, however the items are plotted as strings or points\n"
21794  " in the same way as plstring.\n"
21795  "\n"
21796  " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
21797  " maxy, plotentries)\n"
21798  "\n"
21799  " This function is not used in any examples.\n"
21800  "\n"
21801  "\n"
21802  "\n"
21803  "SYNOPSIS:\n"
21804  "\n"
21805  "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
21806  "\n"
21807  "ARGUMENTS:\n"
21808  "\n"
21809  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21810  " transform the coordinates given in the shapefile into a plot\n"
21811  " coordinate system. By using this transform, we can change from a\n"
21812  " longitude, latitude coordinate to a polar stereographic project,\n"
21813  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21814  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21815  " mapform(), x[] and y[] should be replaced by the corresponding\n"
21816  " plot coordinates. If no transform is desired, mapform can be\n"
21817  " replaced by NULL.\n"
21818  "\n"
21819  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21820  " the file name of a set of Shapefile files without the file\n"
21821  " extension.\n"
21822  "\n"
21823  " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
21824  " drawn.\n"
21825  "\n"
21826  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21827  " be in the same units as used by the Shapefile. You could use a\n"
21828  " very large negative number to plot everything, but you can improve\n"
21829  " performance by limiting the area drawn. The units must match those\n"
21830  " of the Shapefile projection, which may be for example longitude or\n"
21831  " distance. The value of minx must be less than the value of maxx.\n"
21832  "\n"
21833  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21834  " use a very large number to plot everything, but you can improve\n"
21835  " performance by limiting the area drawn.\n"
21836  "\n"
21837  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21838  " be in the same units as used by the Shapefile. You could use a\n"
21839  " very large negative number to plot everything, but you can improve\n"
21840  " performance by limiting the area drawn. The units must match those\n"
21841  " of the Shapefile projection, which may be for example latitude or\n"
21842  " distance. The value of miny must be less than the value of maxy.\n"
21843  "\n"
21844  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21845  " use a very large number to plot everything, but you can improve\n"
21846  " performance by limiting the area drawn.\n"
21847  "\n"
21848  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
21849  " zero-based indices of the Shapefile elements which will be drawn.\n"
21850  " Setting\n"
21851  " plotentries to NULL will plot all elements of the Shapefile.\n"
21852  "\n"
21853  " nplotentries (PLINT, input) : The number of items in\n"
21854  " plotentries. Ignored if\n"
21855  " plotentries is NULL.\n"
21856  "\n"
21857  ""},
21858  { "plmaptex", _wrap_plmaptex, METH_VARARGS, "\n"
21859  "Draw text at points defined by Shapefile data in world coordinates\n"
21860  "\n"
21861  "DESCRIPTION:\n"
21862  "\n"
21863  " As per plmapline, however the items are plotted as text in the same\n"
21864  " way as plptex.\n"
21865  "\n"
21866  " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
21867  " miny, maxy, plotentry)\n"
21868  "\n"
21869  " This function is used in example 19.\n"
21870  "\n"
21871  "\n"
21872  "\n"
21873  "SYNOPSIS:\n"
21874  "\n"
21875  "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
21876  "\n"
21877  "ARGUMENTS:\n"
21878  "\n"
21879  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21880  " transform the coordinates given in the shapefile into a plot\n"
21881  " coordinate system. By using this transform, we can change from a\n"
21882  " longitude, latitude coordinate to a polar stereographic project,\n"
21883  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21884  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21885  " mapform(), x[] and y[] should be replaced by the corresponding\n"
21886  " plot coordinates. If no transform is desired, mapform can be\n"
21887  " replaced by NULL.\n"
21888  "\n"
21889  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21890  " the file name of a set of Shapefile files without the file\n"
21891  " extension.\n"
21892  "\n"
21893  " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
21894  " dy/dx.\n"
21895  "\n"
21896  " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
21897  " dy/dx.\n"
21898  "\n"
21899  " just (PLFLT, input) : Set the justification of the text. The value\n"
21900  " given will be the fraction of the distance along the string that\n"
21901  " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
21902  " centralized text and 1.0 gives right aligned text.\n"
21903  "\n"
21904  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
21905  "\n"
21906  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21907  " be in the same units as used by the Shapefile. You could use a\n"
21908  " very large negative number to plot everything, but you can improve\n"
21909  " performance by limiting the area drawn. The units must match those\n"
21910  " of the Shapefile projection, which may be for example longitude or\n"
21911  " distance. The value of minx must be less than the value of maxx.\n"
21912  "\n"
21913  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21914  " use a very large number to plot everything, but you can improve\n"
21915  " performance by limiting the area drawn.\n"
21916  "\n"
21917  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21918  " be in the same units as used by the Shapefile. You could use a\n"
21919  " very large negative number to plot everything, but you can improve\n"
21920  " performance by limiting the area drawn. The units must match those\n"
21921  " of the Shapefile projection, which may be for example latitude or\n"
21922  " distance. The value of miny must be less than the value of maxy.\n"
21923  "\n"
21924  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21925  " use a very large number to plot everything, but you can improve\n"
21926  " performance by limiting the area drawn.\n"
21927  "\n"
21928  " plotentry (PLINT, input) : An integer indicating which text string\n"
21929  " of the Shapefile (zero indexed) will be drawn.\n"
21930  "\n"
21931  ""},
21932  { "plmapfill", _wrap_plmapfill, METH_VARARGS, "\n"
21933  "Plot all or a subset of Shapefile data, filling the polygons\n"
21934  "\n"
21935  "DESCRIPTION:\n"
21936  "\n"
21937  " As per plmapline, however the items are filled in the same way as\n"
21938  " plfill.\n"
21939  "\n"
21940  " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
21941  " plotentries)\n"
21942  "\n"
21943  " This function is used in example 19.\n"
21944  "\n"
21945  "\n"
21946  "\n"
21947  "SYNOPSIS:\n"
21948  "\n"
21949  "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
21950  "\n"
21951  "ARGUMENTS:\n"
21952  "\n"
21953  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21954  " transform the coordinates given in the shapefile into a plot\n"
21955  " coordinate system. By using this transform, we can change from a\n"
21956  " longitude, latitude coordinate to a polar stereographic project,\n"
21957  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21958  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21959  " mapform(), x[] and y[] should be replaced by the corresponding\n"
21960  " plot coordinates. If no transform is desired, mapform can be\n"
21961  " replaced by NULL.\n"
21962  "\n"
21963  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21964  " the file name of a set of Shapefile files without the file\n"
21965  " extension.\n"
21966  "\n"
21967  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21968  " be in the same units as used by the Shapefile. You could use a\n"
21969  " very large negative number to plot everything, but you can improve\n"
21970  " performance by limiting the area drawn. The units must match those\n"
21971  " of the Shapefile projection, which may be for example longitude or\n"
21972  " distance. The value of minx must be less than the value of maxx.\n"
21973  "\n"
21974  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21975  " use a very large number to plot everything, but you can improve\n"
21976  " performance by limiting the area drawn.\n"
21977  "\n"
21978  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21979  " be in the same units as used by the Shapefile. You could use a\n"
21980  " very large negative number to plot everything, but you can improve\n"
21981  " performance by limiting the area drawn. The units must match those\n"
21982  " of the Shapefile projection, which may be for example latitude or\n"
21983  " distance. The value of miny must be less than the value of maxy.\n"
21984  "\n"
21985  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21986  " use a very large number to plot everything, but you can improve\n"
21987  " performance by limiting the area drawn.\n"
21988  "\n"
21989  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
21990  " zero-based indices of the Shapefile elements which will be drawn.\n"
21991  " Setting\n"
21992  " plotentries to NULL will plot all elements of the Shapefile.\n"
21993  "\n"
21994  " nplotentries (PLINT, input) : The number of items in\n"
21995  " plotentries. Ignored if\n"
21996  " plotentries is NULL.\n"
21997  "\n"
21998  ""},
21999  { "plmeridians", _wrap_plmeridians, METH_VARARGS, "\n"
22000  "Plot latitude and longitude lines\n"
22001  "\n"
22002  "DESCRIPTION:\n"
22003  "\n"
22004  " Displays latitude and longitude on the current plot. The lines are\n"
22005  " plotted in the current color and line style.\n"
22006  "\n"
22007  " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22008  " minlat, maxlat)\n"
22009  "\n"
22010  " This function is used in example 19.\n"
22011  "\n"
22012  "\n"
22013  "\n"
22014  "SYNOPSIS:\n"
22015  "\n"
22016  "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22017  "\n"
22018  "ARGUMENTS:\n"
22019  "\n"
22020  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22021  " transform the coordinate longitudes and latitudes to a plot\n"
22022  " coordinate system. By using this transform, we can change from a\n"
22023  " longitude, latitude coordinate to a polar stereographic project,\n"
22024  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22025  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22026  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22027  " plot coordinates. If no transform is desired, mapform can be\n"
22028  " replaced by NULL.\n"
22029  "\n"
22030  " dlong (PLFLT, input) : The interval in degrees at which the\n"
22031  " longitude lines are to be plotted.\n"
22032  "\n"
22033  " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22034  " lines are to be plotted.\n"
22035  "\n"
22036  " minlong (PLFLT, input) : The value of the longitude on the left\n"
22037  " side of the plot. The value of minlong must be less than the value\n"
22038  " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22039  " equal to 360.\n"
22040  "\n"
22041  " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22042  " side of the plot.\n"
22043  "\n"
22044  " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22045  " background. One can always use -90.0 as the boundary outside the\n"
22046  " plot window will be automatically eliminated. However, the\n"
22047  " program will be faster if one can reduce the size of the\n"
22048  " background plotted.\n"
22049  "\n"
22050  " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22051  " background. One can always use 90.0 as the boundary outside the\n"
22052  " plot window will be automatically eliminated.\n"
22053  "\n"
22054  ""},
22055  { "plimage", _wrap_plimage, METH_VARARGS, "\n"
22056  "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22057  "\n"
22058  "DESCRIPTION:\n"
22059  "\n"
22060  " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22061  " automatically adjusted to use the maximum and minimum values in idata\n"
22062  " as valuemin and valuemax in a call to plimagefr.\n"
22063  "\n"
22064  " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22065  " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22066  "\n"
22067  "\n"
22068  " This function is used in example 20.\n"
22069  "\n"
22070  "\n"
22071  "\n"
22072  "SYNOPSIS:\n"
22073  "\n"
22074  "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22075  "\n"
22076  "ARGUMENTS:\n"
22077  "\n"
22078  " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22079  " to plot. Should have dimensions of\n"
22080  " nx by\n"
22081  " ny.\n"
22082  "\n"
22083  " nx, ny (PLINT, input) : Dimensions of idata\n"
22084  "\n"
22085  " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22086  " are linearly transformed to these world coordinate ranges such\n"
22087  " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22088  " - 1] corresponds to (xmax, ymax).\n"
22089  "\n"
22090  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22091  " (inclusive) will be plotted.\n"
22092  "\n"
22093  " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22094  " points whose plot coordinates fall inside the window of (Dxmin,\n"
22095  " Dymin) to (Dxmax, Dymax).\n"
22096  "\n"
22097  ""},
22098  { "plimagefr", _wrap_plimagefr, METH_VARARGS, "\n"
22099  "Plot a 2D matrix using cmap1\n"
22100  "\n"
22101  "DESCRIPTION:\n"
22102  "\n"
22103  " Plot a 2D matrix using cmap1.\n"
22104  "\n"
22105  " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22106  " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22107  "\n"
22108  "\n"
22109  " This function is used in example 20.\n"
22110  "\n"
22111  "\n"
22112  "\n"
22113  "SYNOPSIS:\n"
22114  "\n"
22115  "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22116  "\n"
22117  "ARGUMENTS:\n"
22118  "\n"
22119  " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22120  " plot. Should have dimensions of\n"
22121  " nx by\n"
22122  " ny.\n"
22123  "\n"
22124  " nx, ny (PLINT, input) : Dimensions of idata\n"
22125  "\n"
22126  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22127  " pltr below for how these arguments are used (only for the special case\n"
22128  " when the callback function\n"
22129  " pltr is not supplied).\n"
22130  "\n"
22131  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22132  " (inclusive) will be plotted.\n"
22133  "\n"
22134  " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22135  " values to use for value to color mappings. A datum equal to or\n"
22136  " less than valuemin will be plotted with color 0.0, while a datum\n"
22137  " equal to or greater than valuemax will be plotted with color 1.0.\n"
22138  " Data between valuemin and valuemax map linearly to colors in the\n"
22139  " range (0.0-1.0).\n"
22140  "\n"
22141  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22142  " defines the transformation between the zero-based indices of the\n"
22143  " matrix idata and world coordinates. If\n"
22144  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22145  " indices of idata are mapped to the range\n"
22146  " xmin through\n"
22147  " xmax and the y indices of idata are mapped to the range\n"
22148  " ymin through\n"
22149  " ymax.For the C case, transformation functions are provided in the\n"
22150  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22151  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22152  " matrices. In addition, C callback routines for the transformation\n"
22153  " can be supplied by the user such as the mypltr function in\n"
22154  " examples/c/x09c.c which provides a general linear transformation\n"
22155  " between index coordinates and world coordinates.For languages\n"
22156  " other than C you should consult the PLplot documentation for the\n"
22157  " details concerning how PLTRANSFORM_callback arguments are\n"
22158  " interfaced. However, in general, a particular pattern of\n"
22159  " callback-associated arguments such as a tr vector with 6 elements;\n"
22160  " xg and yg vectors; or xg and yg matrices are respectively\n"
22161  " interfaced to a linear-transformation routine similar to the above\n"
22162  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22163  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22164  " support native language callbacks for handling index to\n"
22165  " world-coordinate transformations. Examples of these various\n"
22166  " approaches are given in examples/<language>x09*,\n"
22167  " examples/<language>x16*, examples/<language>x20*,\n"
22168  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22169  " supported languages.\n"
22170  "\n"
22171  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22172  " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22173  " externally supplied.\n"
22174  "\n"
22175  ""},
22176  { "plClearOpts", _wrap_plClearOpts, METH_NOARGS, NULL},
22177  { "plResetOpts", _wrap_plResetOpts, METH_NOARGS, NULL},
22178  { "plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22179  { "plOptUsage", _wrap_plOptUsage, METH_NOARGS, NULL},
22180  { "plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_O, NULL},
22181  { "plGetCursor", _wrap_plGetCursor, METH_O, "\n"
22182  "Wait for graphics input event and translate to world coordinates.\n"
22183  "\n"
22184  "DESCRIPTION:\n"
22185  "\n"
22186  " Wait for graphics input event and translate to world coordinates.\n"
22187  " Returns 0 if no translation to world coordinates is possible.\n"
22188  "\n"
22189  " This function returns 1 on success and 0 if no translation to world\n"
22190  " coordinates is possible.\n"
22191  "\n"
22192  " Redacted form: plGetCursor(gin)\n"
22193  "\n"
22194  " This function is used in examples 1 and 20.\n"
22195  "\n"
22196  "\n"
22197  "\n"
22198  "SYNOPSIS:\n"
22199  "\n"
22200  "PLINT plGetCursor(gin)\n"
22201  "\n"
22202  "ARGUMENTS:\n"
22203  "\n"
22204  " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22205  " which will contain the output. The structure is not allocated by\n"
22206  " the routine and must exist before the function is called.\n"
22207  "\n"
22208  ""},
22209  { NULL, NULL, 0, NULL }
22210 };
22211 
22212 static PyMethodDef SwigMethods_proxydocs[] = {
22213  { NULL, NULL, 0, NULL }
22214 };
22215 
22216 
22217 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22218 
22219 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22220 static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22221 static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22222 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22223 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
22224 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};
22225 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};
22226 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};
22227 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};
22228 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};
22229 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
22230 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22231 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22232 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
22233 
22238  &_swigt__p_char,
22245  &_swigt__p_int,
22249 };
22250 
22251 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
22252 static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
22253 static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
22254 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22255 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
22261 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22262 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
22263 static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
22264 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22265 
22277  _swigc__p_int,
22281 };
22282 
22283 
22284 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22285 
22287 {0, 0, 0, 0.0, 0, 0}};
22288 
22289 #ifdef __cplusplus
22290 }
22291 #endif
22292 /* -----------------------------------------------------------------------------
22293  * Type initialization:
22294  * This problem is tough by the requirement that no dynamic
22295  * memory is used. Also, since swig_type_info structures store pointers to
22296  * swig_cast_info structures and swig_cast_info structures store pointers back
22297  * to swig_type_info structures, we need some lookup code at initialization.
22298  * The idea is that swig generates all the structures that are needed.
22299  * The runtime then collects these partially filled structures.
22300  * The SWIG_InitializeModule function takes these initial arrays out of
22301  * swig_module, and does all the lookup, filling in the swig_module.types
22302  * array with the correct data and linking the correct swig_cast_info
22303  * structures together.
22304  *
22305  * The generated swig_type_info structures are assigned statically to an initial
22306  * array. We just loop through that array, and handle each type individually.
22307  * First we lookup if this type has been already loaded, and if so, use the
22308  * loaded structure instead of the generated one. Then we have to fill in the
22309  * cast linked list. The cast data is initially stored in something like a
22310  * two-dimensional array. Each row corresponds to a type (there are the same
22311  * number of rows as there are in the swig_type_initial array). Each entry in
22312  * a column is one of the swig_cast_info structures for that type.
22313  * The cast_initial array is actually an array of arrays, because each row has
22314  * a variable number of columns. So to actually build the cast linked list,
22315  * we find the array of casts associated with the type, and loop through it
22316  * adding the casts to the list. The one last trick we need to do is making
22317  * sure the type pointer in the swig_cast_info struct is correct.
22318  *
22319  * First off, we lookup the cast->type name to see if it is already loaded.
22320  * There are three cases to handle:
22321  * 1) If the cast->type has already been loaded AND the type we are adding
22322  * casting info to has not been loaded (it is in this module), THEN we
22323  * replace the cast->type pointer with the type pointer that has already
22324  * been loaded.
22325  * 2) If BOTH types (the one we are adding casting info to, and the
22326  * cast->type) are loaded, THEN the cast info has already been loaded by
22327  * the previous module so we just ignore it.
22328  * 3) Finally, if cast->type has not already been loaded, then we add that
22329  * swig_cast_info to the linked list (because the cast->type) pointer will
22330  * be correct.
22331  * ----------------------------------------------------------------------------- */
22332 
22333 #ifdef __cplusplus
22334 extern "C" {
22335 #if 0
22336 } /* c-mode */
22337 #endif
22338 #endif
22339 
22340 #if 0
22341 #define SWIGRUNTIME_DEBUG
22342 #endif
22343 
22344 
22345 SWIGRUNTIME void
22346 SWIG_InitializeModule(void *clientdata) {
22347  size_t i;
22348  swig_module_info *module_head, *iter;
22349  int init;
22350 
22351  /* check to see if the circular list has been setup, if not, set it up */
22352  if (swig_module.next==0) {
22353  /* Initialize the swig_module */
22357  init = 1;
22358  } else {
22359  init = 0;
22360  }
22361 
22362  /* Try and load any already created modules */
22363  module_head = SWIG_GetModule(clientdata);
22364  if (!module_head) {
22365  /* This is the first module loaded for this interpreter */
22366  /* so set the swig module into the interpreter */
22367  SWIG_SetModule(clientdata, &swig_module);
22368  } else {
22369  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
22370  iter=module_head;
22371  do {
22372  if (iter==&swig_module) {
22373  /* Our module is already in the list, so there's nothing more to do. */
22374  return;
22375  }
22376  iter=iter->next;
22377  } while (iter!= module_head);
22378 
22379  /* otherwise we must add our module into the list */
22380  swig_module.next = module_head->next;
22381  module_head->next = &swig_module;
22382  }
22383 
22384  /* When multiple interpreters are used, a module could have already been initialized in
22385  a different interpreter, but not yet have a pointer in this interpreter.
22386  In this case, we do not want to continue adding types... everything should be
22387  set up already */
22388  if (init == 0) return;
22389 
22390  /* Now work on filling in swig_module.types */
22391 #ifdef SWIGRUNTIME_DEBUG
22392  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
22393 #endif
22394  for (i = 0; i < swig_module.size; ++i) {
22395  swig_type_info *type = 0;
22396  swig_type_info *ret;
22397  swig_cast_info *cast;
22398 
22399 #ifdef SWIGRUNTIME_DEBUG
22400  printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
22401 #endif
22402 
22403  /* if there is another module already loaded */
22404  if (swig_module.next != &swig_module) {
22406  }
22407  if (type) {
22408  /* Overwrite clientdata field */
22409 #ifdef SWIGRUNTIME_DEBUG
22410  printf("SWIG_InitializeModule: found type %s\n", type->name);
22411 #endif
22414 #ifdef SWIGRUNTIME_DEBUG
22415  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22416 #endif
22417  }
22418  } else {
22419  type = swig_module.type_initial[i];
22420  }
22421 
22422  /* Insert casting types */
22423  cast = swig_module.cast_initial[i];
22424  while (cast->type) {
22425  /* Don't need to add information already in the list */
22426  ret = 0;
22427 #ifdef SWIGRUNTIME_DEBUG
22428  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22429 #endif
22430  if (swig_module.next != &swig_module) {
22432 #ifdef SWIGRUNTIME_DEBUG
22433  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22434 #endif
22435  }
22436  if (ret) {
22437  if (type == swig_module.type_initial[i]) {
22438 #ifdef SWIGRUNTIME_DEBUG
22439  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22440 #endif
22441  cast->type = ret;
22442  ret = 0;
22443  } else {
22444  /* Check for casting already in the list */
22445  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22446 #ifdef SWIGRUNTIME_DEBUG
22447  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22448 #endif
22449  if (!ocast) ret = 0;
22450  }
22451  }
22452 
22453  if (!ret) {
22454 #ifdef SWIGRUNTIME_DEBUG
22455  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22456 #endif
22457  if (type->cast) {
22458  type->cast->prev = cast;
22459  cast->next = type->cast;
22460  }
22461  type->cast = cast;
22462  }
22463  cast++;
22464  }
22465  /* Set entry in modules->types array equal to the type */
22466  swig_module.types[i] = type;
22467  }
22468  swig_module.types[i] = 0;
22469 
22470 #ifdef SWIGRUNTIME_DEBUG
22471  printf("**** SWIG_InitializeModule: Cast List ******\n");
22472  for (i = 0; i < swig_module.size; ++i) {
22473  int j = 0;
22475  printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
22476  while (cast->type) {
22477  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22478  cast++;
22479  ++j;
22480  }
22481  printf("---- Total casts: %d\n",j);
22482  }
22483  printf("**** SWIG_InitializeModule: Cast List ******\n");
22484 #endif
22485 }
22486 
22487 /* This function will propagate the clientdata field of type to
22488 * any new swig_type_info structures that have been added into the list
22489 * of equivalent types. It is like calling
22490 * SWIG_TypeClientData(type, clientdata) a second time.
22491 */
22492 SWIGRUNTIME void
22494  size_t i;
22495  swig_cast_info *equiv;
22496  static int init_run = 0;
22497 
22498  if (init_run) return;
22499  init_run = 1;
22500 
22501  for (i = 0; i < swig_module.size; i++) {
22502  if (swig_module.types[i]->clientdata) {
22503  equiv = swig_module.types[i]->cast;
22504  while (equiv) {
22505  if (!equiv->converter) {
22506  if (equiv->type && !equiv->type->clientdata)
22508  }
22509  equiv = equiv->next;
22510  }
22511  }
22512  }
22513 }
22514 
22515 #ifdef __cplusplus
22516 #if 0
22517 {
22518  /* c-mode */
22519 #endif
22520 }
22521 #endif
22522 
22523 
22524 
22525 #ifdef __cplusplus
22526 extern "C" {
22527 #endif
22528 
22529  /* Python-specific SWIG API */
22530 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22531 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22532 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22533 
22534  /* -----------------------------------------------------------------------------
22535  * global variable support code.
22536  * ----------------------------------------------------------------------------- */
22537 
22538  typedef struct swig_globalvar {
22539  char *name; /* Name of global variable */
22540  PyObject *(*get_attr)(void); /* Return the current value */
22541  int (*set_attr)(PyObject *); /* Set the value */
22544 
22545  typedef struct swig_varlinkobject {
22546  PyObject_HEAD
22549 
22550  SWIGINTERN PyObject *
22552 #if PY_VERSION_HEX >= 0x03000000
22553  return PyUnicode_InternFromString("<Swig global variables>");
22554 #else
22555  return PyString_FromString("<Swig global variables>");
22556 #endif
22557  }
22558 
22559  SWIGINTERN PyObject *
22561 #if PY_VERSION_HEX >= 0x03000000
22562  PyObject *str = PyUnicode_InternFromString("(");
22563  PyObject *tail;
22564  PyObject *joined;
22565  swig_globalvar *var;
22566  for (var = v->vars; var; var=var->next) {
22567  tail = PyUnicode_FromString(var->name);
22568  joined = PyUnicode_Concat(str, tail);
22569  Py_DecRef(str);
22570  Py_DecRef(tail);
22571  str = joined;
22572  if (var->next) {
22573  tail = PyUnicode_InternFromString(", ");
22574  joined = PyUnicode_Concat(str, tail);
22575  Py_DecRef(str);
22576  Py_DecRef(tail);
22577  str = joined;
22578  }
22579  }
22580  tail = PyUnicode_InternFromString(")");
22581  joined = PyUnicode_Concat(str, tail);
22582  Py_DecRef(str);
22583  Py_DecRef(tail);
22584  str = joined;
22585 #else
22586  PyObject *str = PyString_FromString("(");
22587  swig_globalvar *var;
22588  for (var = v->vars; var; var=var->next) {
22589  PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22590  if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22591  }
22592  PyString_ConcatAndDel(&str,PyString_FromString(")"));
22593 #endif
22594  return str;
22595  }
22596 
22597  SWIGINTERN void
22599  swig_globalvar *var = v->vars;
22600  while (var) {
22601  swig_globalvar *n = var->next;
22602  free(var->name);
22603  free(var);
22604  var = n;
22605  }
22606  }
22607 
22608  SWIGINTERN PyObject *
22610  PyObject *res = NULL;
22611  swig_globalvar *var = v->vars;
22612  while (var) {
22613  if (strcmp(var->name,n) == 0) {
22614  res = (*var->get_attr)();
22615  break;
22616  }
22617  var = var->next;
22618  }
22619  if (res == NULL && !PyErr_Occurred()) {
22620  PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
22621  }
22622  return res;
22623  }
22624 
22625  SWIGINTERN int
22626  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22627  int res = 1;
22628  swig_globalvar *var = v->vars;
22629  while (var) {
22630  if (strcmp(var->name,n) == 0) {
22631  res = (*var->set_attr)(p);
22632  break;
22633  }
22634  var = var->next;
22635  }
22636  if (res == 1 && !PyErr_Occurred()) {
22637  PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
22638  }
22639  return res;
22640  }
22641 
22642  SWIGINTERN PyTypeObject*
22644  static char varlink__doc__[] = "Swig var link object";
22645  static PyTypeObject varlink_type;
22646  static int type_init = 0;
22647  if (!type_init) {
22648  const PyTypeObject tmp = {
22649 #if PY_VERSION_HEX >= 0x03000000
22650  PyVarObject_HEAD_INIT(NULL, 0)
22651 #else
22652  PyObject_HEAD_INIT(NULL)
22653  0, /* ob_size */
22654 #endif
22655  "swigvarlink", /* tp_name */
22656  sizeof(swig_varlinkobject), /* tp_basicsize */
22657  0, /* tp_itemsize */
22658  (destructor) swig_varlink_dealloc, /* tp_dealloc */
22659  0, /* tp_print */
22660  (getattrfunc) swig_varlink_getattr, /* tp_getattr */
22661  (setattrfunc) swig_varlink_setattr, /* tp_setattr */
22662  0, /* tp_compare */
22663  (reprfunc) swig_varlink_repr, /* tp_repr */
22664  0, /* tp_as_number */
22665  0, /* tp_as_sequence */
22666  0, /* tp_as_mapping */
22667  0, /* tp_hash */
22668  0, /* tp_call */
22669  (reprfunc) swig_varlink_str, /* tp_str */
22670  0, /* tp_getattro */
22671  0, /* tp_setattro */
22672  0, /* tp_as_buffer */
22673  0, /* tp_flags */
22674  varlink__doc__, /* tp_doc */
22675  0, /* tp_traverse */
22676  0, /* tp_clear */
22677  0, /* tp_richcompare */
22678  0, /* tp_weaklistoffset */
22679  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22680  0, /* tp_del */
22681  0, /* tp_version_tag */
22682 #if PY_VERSION_HEX >= 0x03040000
22683  0, /* tp_finalize */
22684 #endif
22685 #if PY_VERSION_HEX >= 0x03080000
22686  0, /* tp_vectorcall */
22687 #endif
22688 #if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
22689  0, /* tp_print */
22690 #endif
22691 #ifdef COUNT_ALLOCS
22692  0, /* tp_allocs */
22693  0, /* tp_frees */
22694  0, /* tp_maxalloc */
22695  0, /* tp_prev */
22696  0 /* tp_next */
22697 #endif
22698  };
22699  varlink_type = tmp;
22700  type_init = 1;
22701  if (PyType_Ready(&varlink_type) < 0)
22702  return NULL;
22703  }
22704  return &varlink_type;
22705  }
22706 
22707  /* Create a variable linking object for use later */
22708  SWIGINTERN PyObject *
22710  swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
22711  if (result) {
22712  result->vars = 0;
22713  }
22714  return ((PyObject*) result);
22715  }
22716 
22717  SWIGINTERN void
22718  SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22720  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22721  if (gv) {
22722  size_t size = strlen(name)+1;
22723  gv->name = (char *)malloc(size);
22724  if (gv->name) {
22725  memcpy(gv->name, name, size);
22726  gv->get_attr = get_attr;
22727  gv->set_attr = set_attr;
22728  gv->next = v->vars;
22729  }
22730  }
22731  v->vars = gv;
22732  }
22733 
22734  SWIGINTERN PyObject *
22736  static PyObject *globals = 0;
22737  if (!globals) {
22738  globals = SWIG_newvarlink();
22739  }
22740  return globals;
22741  }
22742 
22743  /* -----------------------------------------------------------------------------
22744  * constants/methods manipulation
22745  * ----------------------------------------------------------------------------- */
22746 
22747  /* Install Constants */
22748  SWIGINTERN void
22749  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22750  PyObject *obj = 0;
22751  size_t i;
22752  for (i = 0; constants[i].type; ++i) {
22753  switch(constants[i].type) {
22754  case SWIG_PY_POINTER:
22755  obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22756  break;
22757  case SWIG_PY_BINARY:
22758  obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22759  break;
22760  default:
22761  obj = 0;
22762  break;
22763  }
22764  if (obj) {
22765  PyDict_SetItemString(d, constants[i].name, obj);
22766  Py_DECREF(obj);
22767  }
22768  }
22769  }
22770 
22771  /* -----------------------------------------------------------------------------*/
22772  /* Fix SwigMethods to carry the callback ptrs when needed */
22773  /* -----------------------------------------------------------------------------*/
22774 
22775  SWIGINTERN void
22776  SWIG_Python_FixMethods(PyMethodDef *methods,
22777  swig_const_info *const_table,
22778  swig_type_info **types,
22779  swig_type_info **types_initial) {
22780  size_t i;
22781  for (i = 0; methods[i].ml_name; ++i) {
22782  const char *c = methods[i].ml_doc;
22783  if (!c) continue;
22784  c = strstr(c, "swig_ptr: ");
22785  if (c) {
22786  int j;
22787  swig_const_info *ci = 0;
22788  const char *name = c + 10;
22789  for (j = 0; const_table[j].type; ++j) {
22790  if (strncmp(const_table[j].name, name,
22791  strlen(const_table[j].name)) == 0) {
22792  ci = &(const_table[j]);
22793  break;
22794  }
22795  }
22796  if (ci) {
22797  void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
22798  if (ptr) {
22799  size_t shift = (ci->ptype) - types;
22800  swig_type_info *ty = types_initial[shift];
22801  size_t ldoc = (c - methods[i].ml_doc);
22802  size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22803  char *ndoc = (char*)malloc(ldoc + lptr + 10);
22804  if (ndoc) {
22805  char *buff = ndoc;
22806  memcpy(buff, methods[i].ml_doc, ldoc);
22807  buff += ldoc;
22808  memcpy(buff, "swig_ptr: ", 10);
22809  buff += 10;
22810  SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22811  methods[i].ml_doc = ndoc;
22812  }
22813  }
22814  }
22815  }
22816  }
22817  }
22818 
22819  /* -----------------------------------------------------------------------------
22820  * Method creation and docstring support functions
22821  * ----------------------------------------------------------------------------- */
22822 
22823  /* -----------------------------------------------------------------------------
22824  * Function to find the method definition with the correct docstring for the
22825  * proxy module as opposed to the low-level API
22826  * ----------------------------------------------------------------------------- */
22827 
22828  SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
22829  /* Find the function in the modified method table */
22830  size_t offset = 0;
22831  int found = 0;
22832  while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
22833  if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
22834  found = 1;
22835  break;
22836  }
22837  offset++;
22838  }
22839  /* Use the copy with the modified docstring if available */
22840  return found ? &SwigMethods_proxydocs[offset] : NULL;
22841  }
22842 
22843  /* -----------------------------------------------------------------------------
22844  * Wrapper of PyInstanceMethod_New() used in Python 3
22845  * It is exported to the generated module, used for -fastproxy
22846  * ----------------------------------------------------------------------------- */
22847 
22848  SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
22849  if (PyCFunction_Check(func)) {
22850  PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
22851  PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
22852  if (ml)
22853  func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
22854  }
22855 #if PY_VERSION_HEX >= 0x03000000
22856  return PyInstanceMethod_New(func);
22857 #else
22858  return PyMethod_New(func, NULL, NULL);
22859 #endif
22860  }
22861 
22862  /* -----------------------------------------------------------------------------
22863  * Wrapper of PyStaticMethod_New()
22864  * It is exported to the generated module, used for -fastproxy
22865  * ----------------------------------------------------------------------------- */
22866 
22867  SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
22868  if (PyCFunction_Check(func)) {
22869  PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
22870  PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
22871  if (ml)
22872  func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
22873  }
22874  return PyStaticMethod_New(func);
22875  }
22876 
22877 #ifdef __cplusplus
22878 }
22879 #endif
22880 
22881 /* -----------------------------------------------------------------------------*
22882  * Partial Init method
22883  * -----------------------------------------------------------------------------*/
22884 
22885 #ifdef __cplusplus
22886 extern "C"
22887 #endif
22888 
22889 SWIGEXPORT
22890 #if PY_VERSION_HEX >= 0x03000000
22891 PyObject*
22892 #else
22893 void
22894 #endif
22895 SWIG_init(void) {
22896  PyObject *m, *d, *md, *globals;
22897 
22898 #if PY_VERSION_HEX >= 0x03000000
22899  static struct PyModuleDef SWIG_module = {
22900  PyModuleDef_HEAD_INIT,
22901  SWIG_name,
22902  NULL,
22903  -1,
22904  SwigMethods,
22905  NULL,
22906  NULL,
22907  NULL,
22908  NULL
22909  };
22910 #endif
22911 
22912 #if defined(SWIGPYTHON_BUILTIN)
22913  static SwigPyClientData SwigPyObject_clientdata = {
22914  0, 0, 0, 0, 0, 0, 0
22915  };
22916  static PyGetSetDef this_getset_def = {
22917  (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
22918  };
22919  static SwigPyGetSet thisown_getset_closure = {
22922  };
22923  static PyGetSetDef thisown_getset_def = {
22924  (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
22925  };
22926  PyTypeObject *builtin_pytype;
22927  int builtin_base_count;
22928  swig_type_info *builtin_basetype;
22929  PyObject *tuple;
22930  PyGetSetDescrObject *static_getset;
22931  PyTypeObject *metatype;
22932  PyTypeObject *swigpyobject;
22933  SwigPyClientData *cd;
22934  PyObject *public_interface, *public_symbol;
22935  PyObject *this_descr;
22936  PyObject *thisown_descr;
22937  PyObject *self = 0;
22938  int i;
22939 
22940  (void)builtin_pytype;
22941  (void)builtin_base_count;
22942  (void)builtin_basetype;
22943  (void)tuple;
22944  (void)static_getset;
22945  (void)self;
22946 
22947  /* Metaclass is used to implement static member variables */
22948  metatype = SwigPyObjectType();
22949  assert(metatype);
22950 #endif
22951 
22952  (void)globals;
22953 
22954  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
22955  SWIG_This();
22958 #ifndef SWIGPYTHON_BUILTIN
22960 #endif
22961 
22962  /* Fix SwigMethods to carry the callback ptrs when needed */
22964 
22965 #if PY_VERSION_HEX >= 0x03000000
22966  m = PyModule_Create(&SWIG_module);
22967 #else
22968  m = Py_InitModule(SWIG_name, SwigMethods);
22969 #endif
22970 
22971  md = d = PyModule_GetDict(m);
22972  (void)md;
22973 
22975 
22976 #ifdef SWIGPYTHON_BUILTIN
22977  swigpyobject = SwigPyObject_TypeOnce();
22978 
22979  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
22980  assert(SwigPyObject_stype);
22981  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
22982  if (!cd) {
22983  SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
22984  SwigPyObject_clientdata.pytype = swigpyobject;
22985  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
22986  PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
22987 # if PY_VERSION_HEX >= 0x03000000
22988  return NULL;
22989 # else
22990  return;
22991 # endif
22992  }
22993 
22994  /* All objects have a 'this' attribute */
22995  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
22996  (void)this_descr;
22997 
22998  /* All objects have a 'thisown' attribute */
22999  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
23000  (void)thisown_descr;
23001 
23002  public_interface = PyList_New(0);
23003  public_symbol = 0;
23004  (void)public_symbol;
23005 
23006  PyDict_SetItemString(md, "__all__", public_interface);
23007  Py_DECREF(public_interface);
23008  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23009  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23010  for (i = 0; swig_const_table[i].name != 0; ++i)
23011  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
23012 #endif
23013 
23015 
23016 
23017  import_array();
23018 
23019  SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
23020  SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23021  SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
23022  SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
23023  SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
23024  SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
23025  SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
23026  SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
23027  SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
23028  SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
23029  SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
23030  SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
23031  SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
23032  SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
23033  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23034  SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
23035  SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23036  SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
23037  SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
23038  SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23039  SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23040  SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23041  SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23042  SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23043  SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23044  SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23045  SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23046  SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23047  SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23048  SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23049  SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23050  SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23051  SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23052  SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23053  SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23054  SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23055  SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23056  SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23057  SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23058  SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
23059  SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
23060  SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23061  SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23062  SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23063  SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23064  SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23065  SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23066  SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23067  SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23068  SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23069  SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23070  SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23071  SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23072  SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23073  SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23074  SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23075  SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23076  SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23077  SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23078  SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23079  SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23080  SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23081  SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23082  SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23083  SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23084  SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23085  SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23086  SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23087  SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23088  SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23089  SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23090  SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23091  SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23092  SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23093  SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23094  SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23095  SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23096  SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23097  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23098  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23099  SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23100  SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23101  SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23102  SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23103  SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23104  SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23105  SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23106  SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23107  SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23108  SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23109  SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23110  SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23111  SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23112  SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23113  SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23114  SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23115  SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23116  SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23117  SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23118  SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23119  SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23120  SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23121  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23122  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23123  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23124  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23125  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23126  SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23127  SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23128  SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL0",SWIG_From_int((int)(16)));
23129  SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL1",SWIG_From_int((int)(128)));
23130  SWIG_Python_SetConstant(d, "MIN_PLINT_RGB",SWIG_From_int((int)(0)));
23131  SWIG_Python_SetConstant(d, "MAX_PLINT_RGB",SWIG_From_int((int)(255)));
23132  SWIG_Python_SetConstant(d, "MIN_PLFLT_CMAP1",SWIG_From_double((double)(0.)));
23133  SWIG_Python_SetConstant(d, "MAX_PLFLT_CMAP1",SWIG_From_double((double)(1.)));
23134  SWIG_Python_SetConstant(d, "MIN_PLFLT_ALPHA",SWIG_From_double((double)(0.)));
23135  SWIG_Python_SetConstant(d, "MAX_PLFLT_ALPHA",SWIG_From_double((double)(1.)));
23136  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23137  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23138  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23139  SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23140  SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23141  SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23142  SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23143  SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23144  SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23145  SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23146  SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23147  SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23148  SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23149  SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23150  SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23151  SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23152  SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23153  SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23154  SWIG_Python_SetConstant(d, "PL_POSITION_NULL",SWIG_From_int((int)(0x0)));
23155  SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23156  SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23157  SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23158  SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23159  SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23160  SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23161  SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23162  SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23163  SWIG_Python_SetConstant(d, "PL_LEGEND_NULL",SWIG_From_int((int)(0x0)));
23164  SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23165  SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23166  SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23167  SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23168  SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23169  SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23170  SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23171  SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23172  SWIG_Python_SetConstant(d, "PL_COLORBAR_NULL",SWIG_From_int((int)(0x0)));
23173  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23174  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23175  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23176  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23177  SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23178  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23179  SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23180  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23181  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23182  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23183  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23184  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23185  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23186  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23187  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23188  SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23189  SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23190  SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23191  SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23192  SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23193  SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23194  SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23195  SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23196  SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23197  SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23198  SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23199  SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23200  SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23201  SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23202  SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23203  SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23204 #if PY_VERSION_HEX >= 0x03000000
23205  return m;
23206 #else
23207  return;
23208 #endif
23209 }
23210 
pllsty
#define pllsty
Definition: plplot.h:763
_wrap_plgpage
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6767
SWIG_Python_FixMethods
SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial)
Definition: plplotcPYTHON_wrap.c:22776
SWIG_globals
SWIGINTERN PyObject * SWIG_globals(void)
Definition: plplotcPYTHON_wrap.c:22735
swig_const_info::pvalue
void * pvalue
Definition: plplotcPYTHON_wrap.c:1032
pltr_func
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplotcPYTHON_wrap.c:2789
_wrap_plsesc
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11198
plsstrm
#define plsstrm
Definition: plplot.h:835
_wrap_plbin
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4884
_wrap_plvect
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13120
plsdidev
#define plsdidev
Definition: plplot.h:807
_wrap_plpat
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9383
SWIG_Python_CheckNoKeywords
SWIGINTERN int SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name)
Definition: plplotcPYTHON_wrap.c:1227
_swigc__p_char
static swig_cast_info _swigc__p_char[]
Definition: plplotcPYTHON_wrap.c:22254
plspage
#define plspage
Definition: plplot.h:831
_wrap_PLGraphicsIn_keysym_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4033
SWIG_Python_NewPointerObj
SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags)
Definition: plplotcPYTHON_wrap.c:2326
plshade
#define plshade
Definition: plplot.h:820
swig_globalvar
struct swig_globalvar swig_globalvar
_wrap_PLGraphicsIn_string_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4189
marshal_mapform
mapform_func marshal_mapform(PyObject *input)
Definition: plplotcPYTHON_wrap.c:3866
plsurf3d
#define plsurf3d
Definition: plplot.h:847
_wrap_plend
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5678
tail
static tclMatrixXtnsnDescr * tail
Definition: tclMatrix.c:461
_wrap_PLGraphicsIn_wX_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4456
plssym
#define plssym
Definition: plplot.h:837
NPY_PLFLT
#define NPY_PLFLT
Definition: plplotcPYTHON_wrap.c:2724
plinit
#define plinit
Definition: plplot.h:755
_wrap_plpsty
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9738
_wrap_plsdidev
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10958
_wrap_pladv
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4702
SwigPyObject_hex
SWIGRUNTIME PyObject * SwigPyObject_hex(SwigPyObject *v)
Definition: plplotcPYTHON_wrap.c:1427
plrandd
#define plrandd
Definition: plplot.h:787
do_ct_callback
void do_ct_callback(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
Definition: plplotcPYTHON_wrap.c:3710
_wrap_plgvpd
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7084
_wrap_plspage
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11967
_wrap_plmeshc
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8522
SWIGUNUSEDPARM
#define SWIGUNUSEDPARM(p)
Definition: plplotcPYTHON_wrap.c:70
plsfci
#define plsfci
Definition: plplot.h:817
swig_globalvar::set_attr
int(* set_attr)(PyObject *)
Definition: plplotcPYTHON_wrap.c:22541
_wrap_plscmap1la
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10494
plerry
#define plerry
Definition: plplot.h:715
SWIG_Python_SetErrorObj
SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj)
Definition: plplotcPYTHON_wrap.c:1112
SWIG_TypeQueryModule
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
Definition: plplotcPYTHON_wrap.c:603
swig_module
static swig_module_info swig_module
Definition: plplotcPYTHON_wrap.c:2683
_wrap_plsfam
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11256
_wrap_plgxax
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7188
plMinMax2dGrid
void plMinMax2dGrid(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLFLT *fnmax, PLFLT *fnmin)
Definition: plmem.c:141
PLGraphicsIn_swigregister
SWIGINTERN PyObject * PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4595
plptex3
#define plptex3
Definition: plplot.h:786
_wrap_plscmap1a
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10294
SWIG_TypeNewClientData
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
Definition: plplotcPYTHON_wrap.c:544
swig_type_initial
static swig_type_info * swig_type_initial[]
Definition: plplotcPYTHON_wrap.c:22234
SWIG_PY_POINTER
#define SWIG_PY_POINTER
Definition: plplotcPYTHON_wrap.c:1023
SWIG_BUFFER_SIZE
#define SWIG_BUFFER_SIZE
Definition: plplotcPYTHON_wrap.c:196
SWIG_IndexError
#define SWIG_IndexError
Definition: plplotcPYTHON_wrap.c:735
_wrap_plscmap0n
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10204
_wrap_plseed
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11176
plgspa
#define plgspa
Definition: plplot.h:743
SwigMethods
static PyMethodDef SwigMethods[]
Definition: plplotcPYTHON_wrap.c:14575
_wrap_plscolbg
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10807
_wrap_plend1
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5690
PL_UNUSED
#define PL_UNUSED(x)
Definition: plplot.h:138
_wrap_pltr1
SWIGINTERN PyObject * _wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3382
_wrap_pljoin
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7424
_wrap_plspause
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12085
plstart
#define plstart
Definition: plplot.h:839
SWIG_UnpackVoidPtr
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
Definition: plplotcPYTHON_wrap.c:687
plgcolbg
#define plgcolbg
Definition: plplot.h:726
marshal_ct
ct_func marshal_ct(PyObject *input)
Definition: plplotcPYTHON_wrap.c:3851
cleanup_PLcGrid1
void cleanup_PLcGrid1(void)
Definition: plplotcPYTHON_wrap.c:3314
plsym
#define plsym
Definition: plplot.h:853
SWIG_Python_NewPackedObj
SWIGRUNTIMEINLINE PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
Definition: plplotcPYTHON_wrap.c:2380
swig_globalvar::get_attr
PyObject *(* get_attr)(void)
Definition: plplotcPYTHON_wrap.c:22540
plimage
#define plimage
Definition: plplot.h:753
_wrap_PLGraphicsIn_button_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4114
plgcol0a
#define plgcol0a
Definition: plplot.h:725
plsxwin
void plsxwin(PLINT window_id)
Definition: plcore.c:3978
SwigPyClientData::klass
PyObject * klass
Definition: plplotcPYTHON_wrap.c:1282
_wrap_plline
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8305
_wrap_plsetopt
SWIGINTERN PyObject * _wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11220
SWIG_PyStaticMethod_New
SWIGINTERN PyObject * SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
Definition: plplotcPYTHON_wrap.c:22867
cleanup_mapform
void cleanup_mapform(void)
Definition: plplotcPYTHON_wrap.c:3874
SWIG_NewPointerObj
#define SWIG_NewPointerObj(ptr, type, flags)
Definition: plplotcPYTHON_wrap.c:1068
SWIG_IOError
#define SWIG_IOError
Definition: plplotcPYTHON_wrap.c:733
_wrap_PLGraphicsIn_string_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4219
tmpGrid1
static PLcGrid tmpGrid1
Definition: plplotcPYTHON_wrap.c:3266
_wrap_plmesh
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8442
_wrap_plsdiplz
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11131
SWIG_AsVal_double
SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val)
Definition: plplotcPYTHON_wrap.c:2739
SWIG_MangledTypeQueryModule
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
Definition: plplotcPYTHON_wrap.c:558
_wrap_plgdiori
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6544
pllab
#define pllab
Definition: plplot.h:757
_swigt__p_p_double
static swig_type_info _swigt__p_p_double
Definition: plplotcPYTHON_wrap.c:22231
_wrap_plOptUsage
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14482
swig_module_info::cast_initial
swig_cast_info ** cast_initial
Definition: plplotluacLUA_wrap.c:354
SWIG_TypeCmp
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
Definition: plplotcPYTHON_wrap.c:395
_wrap_plstyl
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12752
plarc
#define plarc
Definition: plplot.h:693
plprec
#define plprec
Definition: plplot.h:783
swig_varlinkobject
struct swig_varlinkobject swig_varlinkobject
_wrap_plwind
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13474
SWIG_OLDOBJ
#define SWIG_OLDOBJ
Definition: plplotcPYTHON_wrap.c:300
_wrap_plpoin3
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9540
SWIG_POINTER_OWN
#define SWIG_POINTER_OWN
Definition: plplotcPYTHON_wrap.c:205
plsetopt
#define plsetopt
Definition: plplot.h:815
plclear
#define plclear
Definition: plplot.h:701
plschr
#define plschr
Definition: plplot.h:790
_wrap_pltr0
SWIGINTERN PyObject * _wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3211
pltimefmt
#define pltimefmt
Definition: plplot.h:856
plssub
#define plssub
Definition: plplot.h:836
myIntArray_ContiguousFromObject
PyArrayObject * myIntArray_ContiguousFromObject(PyObject *in, int type, int mindims, int maxdims)
plctime
#define plctime
Definition: plplot.h:708
_wrap_plsdiplt
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11086
_wrap_plctime
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5578
PLBOOL
PLINT PLBOOL
Definition: plplot.h:204
SWIG_AttributeError
#define SWIG_AttributeError
Definition: plplotcPYTHON_wrap.c:742
_wrap_PLGraphicsIn_subwindow_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4137
do_pltr_callback
void do_pltr_callback(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data)
Definition: plplotcPYTHON_wrap.c:3553
pllegend
#define pllegend
Definition: plplot.h:758
_swigc__p_double
static swig_cast_info _swigc__p_double[]
Definition: plplotcPYTHON_wrap.c:22255
swig_type_info::dcast
swig_dycast_func dcast
Definition: plplotluacLUA_wrap.c:332
plcolorbar
#define plcolorbar
Definition: plplot.h:704
_wrap_plstripc
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12484
swig_module_info::type_initial
swig_type_info ** type_initial
Definition: plplotluacLUA_wrap.c:353
value
static PLFLT value(double n1, double n2, double hue)
Definition: plctrl.c:1219
swig_module_info
Definition: plplotluacLUA_wrap.c:349
_wrap_PLGraphicsIn_state_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4010
SWIG_AsVal_unsigned_SS_int
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
Definition: plplotcPYTHON_wrap.c:2957
plcont
#define plcont
Definition: plplot.h:706
PLcGrid::nx
PLINT nx
Definition: plplot.h:509
SWIG_Python_str_DelForPy3
#define SWIG_Python_str_DelForPy3(x)
Definition: plplotcPYTHON_wrap.c:809
MY_BLOCK_THREADS
#define MY_BLOCK_THREADS
Definition: plplotcPYTHON_wrap.c:3531
SwigPyClientData_New
SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject *obj)
Definition: plplotcPYTHON_wrap.c:1310
_wrap_plrandd
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9928
plscmap1
#define plscmap1
Definition: plplot.h:794
_swigt__p_f_int_double_p_char_int_p_void__void
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
Definition: plplotcPYTHON_wrap.c:22226
plscmap0a
#define plscmap0a
Definition: plplot.h:792
swig_cast_info::type
swig_type_info * type
Definition: plplotluacLUA_wrap.c:340
_wrap_pllightsource
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8268
plscmap1la
#define plscmap1la
Definition: plplot.h:797
SWIG_Python_ConvertPacked
SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:2210
_wrap_plmkstrm
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8618
SwigPyObject::own
int own
Definition: plplotcPYTHON_wrap.c:1368
pljoin
#define pljoin
Definition: plplot.h:756
name
static const char * name
Definition: tkMain.c:135
plstripd
#define plstripd
Definition: plplot.h:845
SWIG_ConvertPtr
#define SWIG_ConvertPtr(obj, pptr, type, flags)
Definition: plplotcPYTHON_wrap.c:1062
SWIG_IsTmpObj
#define SWIG_IsTmpObj(r)
Definition: plplotcPYTHON_wrap.c:309
_wrap_plflush
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6153
PLUNICODE
PLUINT PLUNICODE
Definition: plplot.h:201
SWIG_as_voidptrptr
#define SWIG_as_voidptrptr(a)
Definition: plplotcPYTHON_wrap.c:2711
SWIG_BUILTIN_TP_INIT
#define SWIG_BUILTIN_TP_INIT
Definition: plplotcPYTHON_wrap.c:1262
SWIG_Python_CallFunctor
#define SWIG_Python_CallFunctor(functor, obj)
Definition: plplotcPYTHON_wrap.c:1240
SwigPyPacked_compare
SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
Definition: plplotcPYTHON_wrap.c:1821
plmesh
#define plmesh
Definition: plplot.h:770
plxormod
#define plxormod
Definition: plplot.h:865
_wrap_plmap
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13551
PySequence_Size
#define PySequence_Size
Definition: plplotcPYTHON_wrap.c:2731
plvpor
#define plvpor
Definition: plplot.h:860
marshal_PLPointer
PLPointer marshal_PLPointer(PyObject *input, int isimg)
Definition: plplotcPYTHON_wrap.c:3880
swig_varlink_repr
SWIGINTERN PyObject * swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v))
Definition: plplotcPYTHON_wrap.c:22551
plaxes
#define plaxes
Definition: plplot.h:694
plgcolbga
#define plgcolbga
Definition: plplot.h:727
swig_module_info::next
struct swig_module_info * next
Definition: plplotluacLUA_wrap.c:352
swig_const_info
struct swig_const_info swig_const_info
_wrap_plbox
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5034
NPY_PLINT
#define NPY_PLINT
Definition: plplotcPYTHON_wrap.c:2719
_wrap_plot3dc
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8846
_wrap_plbop
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5022
swig_globalvar
Definition: plplotcPYTHON_wrap.c:22538
_wrap_plgcolbga
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6397
SWIG_Python_InstallConstants
SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[])
Definition: plplotcPYTHON_wrap.c:22749
plgyax
#define plgyax
Definition: plplot.h:749
swig_module_info
struct swig_module_info swig_module_info
plcol1
#define plcol1
Definition: plplot.h:703
CB_0
@ CB_0
Definition: plplotcPYTHON_wrap.c:3509
marshal_pltr
pltr_func marshal_pltr(PyObject *input)
Definition: plplotcPYTHON_wrap.c:3792
plgvpd
#define plgvpd
Definition: plplot.h:746
mapform_func
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
Definition: plplotcPYTHON_wrap.c:2791
_wrap_plsdev
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10933
SWIG_Python_CheckImplicit
SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:1292
plpsty
#define plpsty
Definition: plplot.h:784
plmapstring
void plmapstring(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLCHAR_VECTOR string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:616
SwigPyObject::ptr
PyObject_HEAD void * ptr
Definition: plplotcPYTHON_wrap.c:1366
pltr2
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:941
SWIG_PackDataName
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
Definition: plplotcPYTHON_wrap.c:700
_wrap_plgcol0
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6241
pltr_xg
PyArrayObject * pltr_xg
Definition: plplotcPYTHON_wrap.c:3265
_wrap_plsvpa
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12873
_wrap_plinit
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7412
_wrap_plmapline
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13630
_wrap_PLGraphicsIn_type_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3929
plbop
#define plbop
Definition: plplot.h:696
plsdiplt
#define plsdiplt
Definition: plplot.h:810
_wrap_plpath
SWIGINTERN PyObject * _wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9431
SWIG_Python_ExceptionType
SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc)
Definition: plplotcPYTHON_wrap.c:1302
_wrap_plptex
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9760
_wrap_pltimefmt
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13073
python_label
PyObject * python_label
Definition: plplotcPYTHON_wrap.c:3514
plsurf3dl
#define plsurf3dl
Definition: plplot.h:848
plslabelfunc
#define plslabelfunc
Definition: plplot.h:825
swig_varlink_dealloc
SWIGINTERN void swig_varlink_dealloc(swig_varlinkobject *v)
Definition: plplotcPYTHON_wrap.c:22598
_wrap_plhist
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7284
_swigt__p_char
static swig_type_info _swigt__p_char
Definition: plplotcPYTHON_wrap.c:22222
PLcGrid2::xg
PLFLT_NC_MATRIX xg
Definition: plplot.h:520
pl_setcontlabelparam
#define pl_setcontlabelparam
Definition: plplot.h:691
_wrap_plot3d
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8758
plgradient
#define plgradient
Definition: plplot.h:741
SwigPyPacked::ty
swig_type_info * ty
Definition: plplotcPYTHON_wrap.c:1794
plgdiori
#define plgdiori
Definition: plplot.h:731
_wrap_plscompression
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10911
_wrap_plscmap1_range
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10648
SWIG_name
#define SWIG_name
Definition: plplotcPYTHON_wrap.c:2704
swig_varlink_setattr
SWIGINTERN int swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p)
Definition: plplotcPYTHON_wrap.c:22626
SWIG_FromCharPtrAndSize
SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char *carray, size_t size)
Definition: plplotcPYTHON_wrap.c:3127
SwigPyObject_compare
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
Definition: plplotcPYTHON_wrap.c:1460
CB_2
@ CB_2
Definition: plplotcPYTHON_wrap.c:3509
SWIG_InstallConstants
#define SWIG_InstallConstants(d, constants)
Definition: plplotcPYTHON_wrap.c:22532
SwigPyPacked_Check
SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op)
Definition: plplotcPYTHON_wrap.c:1838
plgdiplt
#define plgdiplt
Definition: plplot.h:732
plmeridians
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:708
SWIG_TypeName
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:498
_wrap_plspal1
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12053
_wrap_PLGraphicsIn_wY_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4537
swig_type_info::cast
struct swig_cast_info * cast
Definition: plplotluacLUA_wrap.c:333
swig_varlinkobject
Definition: plplotcPYTHON_wrap.c:22545
SWIG_AsVal_long
SWIGINTERN int SWIG_AsVal_long(PyObject *obj, long *val)
Definition: plplotcPYTHON_wrap.c:2850
SWIG_PackVoidPtr
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
Definition: plplotcPYTHON_wrap.c:676
_swigt__p_PLcGrid
static swig_type_info _swigt__p_PLcGrid
Definition: plplotcPYTHON_wrap.c:22220
plline3
#define plline3
Definition: plplot.h:762
SWIG_PY_BINARY
#define SWIG_PY_BINARY
Definition: plplotcPYTHON_wrap.c:1024
do_mapform_callback
void do_mapform_callback(PLINT n, PLFLT *x, PLFLT *y)
Definition: plplotcPYTHON_wrap.c:3751
SWIG_init
#define SWIG_init
Definition: plplotcPYTHON_wrap.c:2701
_wrap_plglevel
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6745
SWIG_TypeClientData
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
Definition: plplotcPYTHON_wrap.c:528
SwigPyPacked_dealloc
SWIGRUNTIME void SwigPyPacked_dealloc(PyObject *v)
Definition: plplotcPYTHON_wrap.c:1844
_wrap_plgcol0a
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6293
SwigPyObject_acquire
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
Definition: plplotcPYTHON_wrap.c:1603
SWIG_DivisionByZero
#define SWIG_DivisionByZero
Definition: plplotcPYTHON_wrap.c:737
_wrap_plgdidev
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6492
plsfam
#define plsfam
Definition: plplot.h:816
swig_const_info::name
const char * name
Definition: plplotcPYTHON_wrap.c:1029
SWIG_Python_ConvertPtr
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)
Definition: plplotcPYTHON_wrap.c:1061
plsfnam
#define plsfnam
Definition: plplot.h:818
plflush
#define plflush
Definition: plplot.h:719
tmpGrid2
static PLcGrid2 tmpGrid2
Definition: plplotcPYTHON_wrap.c:3267
_wrap_new_PLGraphicsIn
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4560
swig_const_info::dvalue
double dvalue
Definition: plplotcPYTHON_wrap.c:1031
SWIG_RuntimeError
#define SWIG_RuntimeError
Definition: plplotcPYTHON_wrap.c:734
PLGraphicsIn::string
char string[PL_MAXKEY]
Definition: plplot.h:440
_wrap_plfont
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6165
SWIGINTERNINLINE
#define SWIGINTERNINLINE
Definition: plplotcPYTHON_wrap.c:81
SWIG_Python_ConvertPtrAndOwn
SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own)
Definition: plplotcPYTHON_wrap.c:2076
plgfam
#define plgfam
Definition: plplot.h:734
plsmin
#define plsmin
Definition: plplot.h:829
_wrap_plsfont
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11340
plscolor
#define plscolor
Definition: plplot.h:804
_wrap_pltr2
SWIGINTERN PyObject * _wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3443
error
static int error
Definition: plcont.c:61
_wrap_plSetUsage
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14447
Ylen
static PLINT Ylen
Definition: plplotcPYTHON_wrap.c:2735
SWIG_Python_AddErrMesg
SWIGRUNTIME int SWIG_Python_AddErrMesg(const char *mesg, int infront)
Definition: plplotcPYTHON_wrap.c:2481
plconfigtime
#define plconfigtime
Definition: plplot.h:705
_wrap_PLGraphicsIn_keysym_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4062
_wrap_plslabelfunc
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11757
_swigt__p_f_double_double__int
static swig_type_info _swigt__p_f_double_double__int
Definition: plplotcPYTHON_wrap.c:22224
_swigc__p_p_double
static swig_cast_info _swigc__p_p_double[]
Definition: plplotcPYTHON_wrap.c:22263
plscmap1n
#define plscmap1n
Definition: plplot.h:798
pltext
#define pltext
Definition: plplot.h:855
PySequence_Fast_GET_ITEM
#define PySequence_Fast_GET_ITEM
Definition: plplotcPYTHON_wrap.c:2729
SWIG_Python_TypeQuery
SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type)
Definition: plplotcPYTHON_wrap.c:2452
plgfont
#define plgfont
Definition: plplot.h:737
python_f2eval
PyObject * python_f2eval
Definition: plplotcPYTHON_wrap.c:3511
_wrap_plbtime
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4940
SwigPyClientData::implicitconv
int implicitconv
Definition: plplotcPYTHON_wrap.c:1287
_swigt__p_f_int_p_q_const__double_p_q_const__double__void
static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void
Definition: plplotcPYTHON_wrap.c:22228
SwigPyClientData::newraw
PyObject * newraw
Definition: plplotcPYTHON_wrap.c:1283
SWIG_POINTER_NEW
#define SWIG_POINTER_NEW
Definition: plplotcPYTHON_wrap.c:1258
plenv
#define plenv
Definition: plplot.h:711
SWIG_From_int
SWIGINTERNINLINE PyObject * SWIG_From_int(int value)
Definition: plplotcPYTHON_wrap.c:2797
SWIG_POINTER_NOSHADOW
#define SWIG_POINTER_NOSHADOW
Definition: plplotcPYTHON_wrap.c:1257
swig_module_info::types
swig_type_info ** types
Definition: plplotluacLUA_wrap.c:350
SWIG_DelNewMask
#define SWIG_DelNewMask(r)
Definition: plplotcPYTHON_wrap.c:305
_wrap_plbox3
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5101
_swigt__p_unsigned_int
static swig_type_info _swigt__p_unsigned_int
Definition: plplotcPYTHON_wrap.c:22232
plscmap1a
#define plscmap1a
Definition: plplot.h:795
_wrap_plgfam
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6618
_swigt__p_double
static swig_type_info _swigt__p_double
Definition: plplotcPYTHON_wrap.c:22223
plstyl
#define plstyl
Definition: plplot.h:846
_wrap_plgchr
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6209
SWIG_TypeQuery
#define SWIG_TypeQuery(name)
Definition: plplotcPYTHON_wrap.c:2692
SWIG_Python_TypeErrorOccurred
SWIGRUNTIME int SWIG_Python_TypeErrorOccurred(PyObject *obj)
Definition: plplotcPYTHON_wrap.c:915
_wrap_plscmap1l
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10381
SWIG_TypeError
#define SWIG_TypeError
Definition: plplotcPYTHON_wrap.c:736
SwigPyPacked::size
size_t size
Definition: plplotcPYTHON_wrap.c:1795
swig_const_info::ptype
swig_type_info ** ptype
Definition: plplotcPYTHON_wrap.c:1033
SWIG_AddNewMask
#define SWIG_AddNewMask(r)
Definition: plplotcPYTHON_wrap.c:304
_wrap_plsmem
SWIGINTERN PyObject * _wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11832
_wrap_plgdev
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6471
_wrap_plpoin
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9484
_swigt__p_int
static swig_type_info _swigt__p_int
Definition: plplotcPYTHON_wrap.c:22229
_wrap_plMinMax2dGrid
SWIGINTERN PyObject * _wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14494
_swigt__p_p_char
static swig_type_info _swigt__p_p_char
Definition: plplotcPYTHON_wrap.c:22230
SWIG_Python_InitShadowInstance
SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args)
Definition: plplotcPYTHON_wrap.c:2307
swig_cast_info
Definition: plplotluacLUA_wrap.c:339
SWIG_exception_fail
#define SWIG_exception_fail(code, msg)
Definition: plplotcPYTHON_wrap.c:2645
SWIG_Python_str_FromChar
SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c)
Definition: plplotcPYTHON_wrap.c:816
_wrap_plvsta
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13339
_wrap_plparseopts
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9316
_wrap_plfill3
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6030
_wrap_plfontld
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6187
plgdev
#define plgdev
Definition: plplot.h:729
_wrap_plmtex
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8640
SWIG_TypeNameComp
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
Definition: plplotcPYTHON_wrap.c:380
Alen
static PLINT Alen
Definition: plplotcPYTHON_wrap.c:2734
SWIGEXPORT
#define SWIGEXPORT
Definition: plplotcPYTHON_wrap.c:104
swig_varlink_type
SWIGINTERN PyTypeObject * swig_varlink_type(void)
Definition: plplotcPYTHON_wrap.c:22643
_wrap_plenv0
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5763
SwigPyObject_own
SWIGINTERN PyObject * SwigPyObject_own(PyObject *v, PyObject *args)
Definition: plplotcPYTHON_wrap.c:1611
SWIG_POINTER_NO_NULL
#define SWIG_POINTER_NO_NULL
Definition: plplotcPYTHON_wrap.c:202
SWIG_PackData
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
Definition: plplotcPYTHON_wrap.c:632
Swig_This_global
static PyObject * Swig_This_global
Definition: plplotcPYTHON_wrap.c:1977
plfontld
#define plfontld
Definition: plplot.h:721
SWIG_Python_str_FromFormat
#define SWIG_Python_str_FromFormat
Definition: plplotcPYTHON_wrap.c:777
plot3dcl
#define plot3dcl
Definition: plplot.h:777
_wrap_plscmap1
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10226
SwigPyPacked_type
SWIGRUNTIME PyTypeObject * SwigPyPacked_type(void)
Definition: plplotcPYTHON_wrap.c:1832
SWIG_Python_SetErrorMsg
SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg)
Definition: plplotcPYTHON_wrap.c:1120
_wrap_plscol0a
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10754
_swigc__p_unsigned_int
static swig_cast_info _swigc__p_unsigned_int[]
Definition: plplotcPYTHON_wrap.c:22264
_swigc__p_f_double_double__int
static swig_cast_info _swigc__p_f_double_double__int[]
Definition: plplotcPYTHON_wrap.c:22256
SwigPyPacked_TypeOnce
SWIGRUNTIME PyTypeObject * SwigPyPacked_TypeOnce(void)
Definition: plplotcPYTHON_wrap.c:1854
SWIG_RUNTIME_VERSION
#define SWIG_RUNTIME_VERSION
Definition: plplotcPYTHON_wrap.c:166
_wrap_plsyax
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12947
plfill3
#define plfill3
Definition: plplot.h:718
swig_const_info
Definition: plplotcPYTHON_wrap.c:1027
_wrap_plsdimap
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11003
_wrap_plstring
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12302
plrgbhls
#define plrgbhls
Definition: plplot.h:789
PLGraphicsIn
Definition: plplot.h:434
SwigPyObject::ty
swig_type_info * ty
Definition: plplotcPYTHON_wrap.c:1367
SWIG_Python_MustGetPtr
SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags)
Definition: plplotcPYTHON_wrap.c:2569
plszax
#define plszax
Definition: plplot.h:854
_wrap_plenv
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5702
pltr1
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:874
SwigPyObject_New
SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
Definition: plplotcPYTHON_wrap.c:1775
SWIG_TypePrettyName
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
Definition: plplotcPYTHON_wrap.c:507
cleanup_PLcGrid2
void cleanup_PLcGrid2(void)
Definition: plplotcPYTHON_wrap.c:3373
plplot.h
plfont
#define plfont
Definition: plplot.h:720
plplotP.h
_wrap_plsmin
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11916
_swigc__p_PLcGrid2
static swig_cast_info _swigc__p_PLcGrid2[]
Definition: plplotcPYTHON_wrap.c:22253
_wrap_PLGraphicsIn_pY_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4329
plsvect
#define plsvect
Definition: plplot.h:849
marshal_PLcGrid1
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
Definition: plplotcPYTHON_wrap.c:3274
SWIG_Python_ConvertFunctionPtr
SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:2181
_wrap_plmtex3
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8699
plgcmap1_range
#define plgcmap1_range
Definition: plplot.h:723
swig_const_table
static swig_const_info swig_const_table[]
Definition: plplotcPYTHON_wrap.c:22286
swig_dycast_func
struct swig_type_info *(* swig_dycast_func)(void **)
Definition: plplotcPYTHON_wrap.c:340
PLPointer
void * PLPointer
Definition: plplot.h:209
_wrap_plmapstring
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13733
plResetOpts
void plResetOpts(void)
Definition: plargs.c:843
python_ct
PyObject * python_ct
Definition: plplotcPYTHON_wrap.c:3512
swig_converter_func
void *(* swig_converter_func)(void *, int *)
Definition: plplotcPYTHON_wrap.c:339
_wrap_plshades
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11377
plbin
#define plbin
Definition: plplot.h:695
swig_cast_info::converter
swig_converter_func converter
Definition: plplotluacLUA_wrap.c:341
plhlsrgb
#define plhlsrgb
Definition: plplot.h:752
_wrap_plvpas
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13241
plgfnam
#define plgfnam
Definition: plplot.h:736
plfamadv
#define plfamadv
Definition: plplot.h:716
_wrap_plgradient
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6097
_wrap_pleop
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5824
SWIG_Py_Void
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
Definition: plplotcPYTHON_wrap.c:1272
SWIG_OK
#define SWIG_OK
Definition: plplotcPYTHON_wrap.c:287
SwigPyObject_GetDesc
SWIGRUNTIMEINLINE const char * SwigPyObject_GetDesc(PyObject *self)
Definition: plplotcPYTHON_wrap.c:2522
_wrap_plerry
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5903
SWIG_NEWOBJ
#define SWIG_NEWOBJ
Definition: plplotcPYTHON_wrap.c:301
plparseopts
#define plparseopts
Definition: plplot.h:778
cleanup_PLPointer
void cleanup_PLPointer(void)
Definition: plplotcPYTHON_wrap.c:3905
plsori
#define plsori
Definition: plplot.h:830
SWIG_GetModule
#define SWIG_GetModule(clientdata)
Definition: plplotcPYTHON_wrap.c:1096
SWIG_NewClientData
#define SWIG_NewClientData(obj)
Definition: plplotcPYTHON_wrap.c:1098
SWIG_TYPE_TABLE_NAME
#define SWIG_TYPE_TABLE_NAME
Definition: plplotcPYTHON_wrap.c:174
SWIG_PropagateClientData
SWIGRUNTIME void SWIG_PropagateClientData(void)
Definition: plplotcPYTHON_wrap.c:22493
PLcGrid2::yg
PLFLT_NC_MATRIX yg
Definition: plplot.h:520
_swigt__p_PLcGrid2
static swig_type_info _swigt__p_PLcGrid2
Definition: plplotcPYTHON_wrap.c:22221
_wrap_plxormod
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13519
_swigc__p_f_int_double_p_char_int_p_void__void
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
Definition: plplotcPYTHON_wrap.c:22258
plimagefr
#define plimagefr
Definition: plplot.h:754
plstar
#define plstar
Definition: plplot.h:838
_wrap_delete_PLGraphicsIn
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4573
_wrap_plstart
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12216
plend1
#define plend1
Definition: plplot.h:710
plstripa
#define plstripa
Definition: plplot.h:843
defined_func
PLINT(* defined_func)(PLFLT, PLFLT)
Definition: plplotcPYTHON_wrap.c:2787
plvsta
#define plvsta
Definition: plplot.h:861
SWIG_OverflowError
#define SWIG_OverflowError
Definition: plplotcPYTHON_wrap.c:738
_wrap_plsfnam
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11315
SwigPyPacked_UnpackData
SWIGRUNTIME swig_type_info * SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
Definition: plplotcPYTHON_wrap.c:1961
_wrap_plResetOpts
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14435
pleop
#define pleop
Definition: plplot.h:713
pltr0
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
Definition: plcont.c:858
SWIG_Python_SetModule
SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module)
Definition: plplotcPYTHON_wrap.c:2428
SwigPyObject::next
PyObject * next
Definition: plplotcPYTHON_wrap.c:1369
PyObject_DEL
#define PyObject_DEL
Definition: plplotcPYTHON_wrap.c:826
plvect
#define plvect
Definition: plplot.h:858
plgpage
#define plgpage
Definition: plplot.h:739
plsdimap
#define plsdimap
Definition: plplot.h:808
_wrap_plsmema
SWIGINTERN PyObject * _wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11874
SWIG_pchar_descriptor
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
Definition: plplotcPYTHON_wrap.c:2980
SwigPyObject_Check
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op)
Definition: plplotcPYTHON_wrap.c:1503
plscol0a
#define plscol0a
Definition: plplot.h:801
SWIGTYPE_p_PLGraphicsIn
#define SWIGTYPE_p_PLGraphicsIn
Definition: plplotcPYTHON_wrap.c:2668
pllightsource
#define pllightsource
Definition: plplot.h:759
_wrap_plmeridians
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14072
plshades
#define plshades
Definition: plplot.h:824
SWIG_AsVal_unsigned_SS_long
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val)
Definition: plplotcPYTHON_wrap.c:2909
plgchr
#define plgchr
Definition: plplot.h:722
_wrap_PLGraphicsIn_pY_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4300
SWIG_From_unsigned_SS_int
SWIGINTERNINLINE PyObject * SWIG_From_unsigned_SS_int(unsigned int value)
Definition: plplotcPYTHON_wrap.c:2973
t_output_helper
#define t_output_helper
Definition: plplotcPYTHON_wrap.c:3164
pltr_yg
PyArrayObject * pltr_yg
Definition: plplotcPYTHON_wrap.c:3265
SWIG_fail
#define SWIG_fail
Definition: plplotcPYTHON_wrap.c:1104
_wrap_PLGraphicsIn_dX_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4352
SWIG_TypeCheck
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:422
plsdev
#define plsdev
Definition: plplot.h:806
_wrap_plvpor
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13294
_wrap_plsdiori
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11064
_wrap_plcalc_world
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5228
python_pltr
PyObject * python_pltr
Definition: plplotcPYTHON_wrap.c:3510
SWIG_PythonGetProxyDoc
SWIGINTERN PyMethodDef * SWIG_PythonGetProxyDoc(const char *name)
Definition: plplotcPYTHON_wrap.c:22828
SWIG_Python_TypeCache
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
Definition: plplotcPYTHON_wrap.c:2446
SWIG_POINTER_IMPLICIT_CONV
#define SWIG_POINTER_IMPLICIT_CONV
Definition: plplotcPYTHON_wrap.c:1260
_wrap_plimagefr
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14273
_wrap_PLGraphicsIn_pX_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4277
_wrap_plstring3
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12361
_wrap_plclear
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5287
plpoly3
#define plpoly3
Definition: plplot.h:782
plscolbg
#define plscolbg
Definition: plplot.h:802
SWIG_Python_AppendOutput
SWIGINTERN PyObject * SWIG_Python_AppendOutput(PyObject *result, PyObject *obj)
Definition: plplotcPYTHON_wrap.c:1160
_wrap_pl_setcontlabelformat
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4628
plseed
#define plseed
Definition: plplot.h:813
plstring
#define plstring
Definition: plplot.h:841
plsmem
#define plsmem
Definition: plplot.h:827
plplot::maxlen
integer(kind=private_plint), parameter, private maxlen
Definition: plplot.f90:48
plpath
#define plpath
Definition: plplot.h:761
_wrap_plscol0
SWIGINTERN PyObject * _wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10709
cleanup_pltr
void cleanup_pltr(void)
Definition: plplotcPYTHON_wrap.c:3844
SWIG_PYTHON_THREAD_BEGIN_BLOCK
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
Definition: plplotcPYTHON_wrap.c:1004
PLcGrid::yg
PLFLT_NC_FE_POINTER yg
Definition: plplot.h:508
plscolbga
#define plscolbga
Definition: plplot.h:803
_wrap_pltext
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13061
swig_types
static swig_type_info * swig_types[15]
Definition: plplotcPYTHON_wrap.c:2682
SwigPyPacked_New
SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:1942
SWIG_AsCharArray
SWIGINTERN int SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
Definition: plplotcPYTHON_wrap.c:3102
plbox3
#define plbox3
Definition: plplot.h:698
_wrap_plgfnam
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6682
PLcGrid
Definition: plplot.h:507
PLINT
int PLINT
Definition: plplot.h:181
plcpstrm
#define plcpstrm
Definition: plplot.h:707
plClearOpts
void plClearOpts(void)
Definition: plargs.c:830
SWIG_AsVal_int
SWIGINTERN int SWIG_AsVal_int(PyObject *obj, int *val)
Definition: plplotcPYTHON_wrap.c:2893
SWIG_SystemError
#define SWIG_SystemError
Definition: plplotcPYTHON_wrap.c:741
cleanup_ct
void cleanup_ct(void)
Definition: plplotcPYTHON_wrap.c:3859
_wrap_plscolbga
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10844
plreplot
#define plreplot
Definition: plplot.h:788
_wrap_plrgbhls
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9953
plsmaj
#define plsmaj
Definition: plplot.h:826
plstring3
#define plstring3
Definition: plplot.h:842
plcalc_world
#define plcalc_world
Definition: plplot.h:700
SwigPyClientData_Del
SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData *data)
Definition: plplotcPYTHON_wrap.c:1356
plstripc
#define plstripc
Definition: plplot.h:844
PLcGrid2::nx
PLINT nx
Definition: plplot.h:521
SWIG_This
SWIGRUNTIME PyObject * SWIG_This(void)
Definition: plplotcPYTHON_wrap.c:1980
swig_const_info::lvalue
long lvalue
Definition: plplotcPYTHON_wrap.c:1030
plvpas
#define plvpas
Definition: plplot.h:859
SWIG_TypeDynamicCast
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
Definition: plplotcPYTHON_wrap.c:484
_swigc__p_f_double_double_p_double_p_double_p_void__void
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
Definition: plplotcPYTHON_wrap.c:22257
_wrap_plstransform
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12256
_swigt__p_f_int_p_double_p_double__void
static swig_type_info _swigt__p_f_int_p_double_p_double__void
Definition: plplotcPYTHON_wrap.c:22227
_wrap_pllegend
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7515
_wrap_plfill
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5982
SwigPyObject_format
SWIGRUNTIME PyObject * SwigPyObject_format(const char *fmt, SwigPyObject *v)
Definition: plplotcPYTHON_wrap.c:1399
SwigPyObject_disown
SWIGINTERN PyObject * SwigPyObject_disown(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
Definition: plplotcPYTHON_wrap.c:1595
MY_UNBLOCK_THREADS
#define MY_UNBLOCK_THREADS
Definition: plplotcPYTHON_wrap.c:3532
_wrap_plimage
SWIGINTERN PyObject * _wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14156
_wrap_plgyax
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7220
SwigMethods_proxydocs
static PyMethodDef SwigMethods_proxydocs[]
Definition: plplotcPYTHON_wrap.c:22212
_wrap_plgfont
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6703
_wrap_PLGraphicsIn_dY_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4404
_wrap_plgcolbg
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6355
_wrap_plsurf3d
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9081
swig_const_info::type
int type
Definition: plplotcPYTHON_wrap.c:1028
SwigPyObject_TypeOnce
SWIGRUNTIME PyTypeObject * SwigPyObject_TypeOnce(void)
Definition: plplotcPYTHON_wrap.c:1642
SWIG_CAST_NEW_MEMORY
#define SWIG_CAST_NEW_MEMORY
Definition: plplotcPYTHON_wrap.c:201
_wrap_PLGraphicsIn_type_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3958
do_label_callback
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
Definition: plplotcPYTHON_wrap.c:3653
_swigt__p_f_double_double_p_double_p_double_p_void__void
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
Definition: plplotcPYTHON_wrap.c:22225
marshal_PLcGrid2
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
Definition: plplotcPYTHON_wrap.c:3321
SwigPyObject_richcompare
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
Definition: plplotcPYTHON_wrap.c:1469
SwigPyObject_dealloc
SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v)
Definition: plplotcPYTHON_wrap.c:1519
_wrap_plgcmap1_range
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10677
plmapline
void plmapline(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:594
plmeshc
#define plmeshc
Definition: plplot.h:771
SWIG_MemoryError
#define SWIG_MemoryError
Definition: plplotcPYTHON_wrap.c:743
plline
#define plline
Definition: plplot.h:760
plgcompression
#define plgcompression
Definition: plplot.h:728
SWIG_SetModule
#define SWIG_SetModule(clientdata, pointer)
Definition: plplotcPYTHON_wrap.c:1097
SwigPyObject_next
SWIGRUNTIME PyObject * SwigPyObject_next(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
Definition: plplotcPYTHON_wrap.c:1583
_wrap_plhlsrgb
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7345
_swigc__p_f_int_p_double_p_double__void
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
Definition: plplotcPYTHON_wrap.c:22259
_wrap_plshade
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11551
SWIG_CheckState
#define SWIG_CheckState(r)
Definition: plplotcPYTHON_wrap.c:329
SWIG_NewPackedObj
#define SWIG_NewPackedObj(ptr, sz, type)
Definition: plplotcPYTHON_wrap.c:1079
SWIG_Python_GetModule
SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata))
Definition: plplotcPYTHON_wrap.c:2393
SWIG_TypeCast
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
Definition: plplotcPYTHON_wrap.c:476
SWIG_AsCharPtrAndSize
SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
Definition: plplotcPYTHON_wrap.c:2993
_wrap_plsym
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12976
_wrap_plssym
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12158
SWIG_ValueError
#define SWIG_ValueError
Definition: plplotcPYTHON_wrap.c:740
_wrap_plscolor
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10889
SWIG_ERROR
#define SWIG_ERROR
Definition: plplotcPYTHON_wrap.c:288
plspause
#define plspause
Definition: plplot.h:834
SWIGRUNTIMEINLINE
#define SWIGRUNTIMEINLINE
Definition: plplotcPYTHON_wrap.c:191
plspal0
#define plspal0
Definition: plplot.h:832
swig_globalvar::name
char * name
Definition: plplotcPYTHON_wrap.c:22539
_wrap_plw3d
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13351
PLcGrid2
Definition: plplot.h:519
SWIG_InitializeModule
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
Definition: plplotcPYTHON_wrap.c:22346
_wrap_plptex3
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9824
swig_globalvar::next
struct swig_globalvar * next
Definition: plplotcPYTHON_wrap.c:22542
SwigPyObject_append
SWIGRUNTIME PyObject * SwigPyObject_append(PyObject *v, PyObject *next)
Definition: plplotcPYTHON_wrap.c:1570
SWIG_Python_AddErrorMsg
SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char *mesg)
Definition: plplotcPYTHON_wrap.c:889
plsesc
#define plsesc
Definition: plplot.h:814
_wrap_plsxwin
SWIGINTERN PyObject * _wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4606
python_mapform
PyObject * python_mapform
Definition: plplotcPYTHON_wrap.c:3513
plptex
#define plptex
Definition: plplot.h:785
SWIG_as_voidptr
#define SWIG_as_voidptr(a)
Definition: plplotcPYTHON_wrap.c:2710
swig_type_info::str
const char * str
Definition: plplotluacLUA_wrap.c:331
_wrap_plsurf3dl
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9177
_wrap_PLGraphicsIn_wY_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4508
plscol0
#define plscol0
Definition: plplot.h:800
SwigPyPacked::pack
PyObject_HEAD void * pack
Definition: plplotcPYTHON_wrap.c:1793
plgver
#define plgver
Definition: plplot.h:745
_wrap_PLGraphicsIn_subwindow_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4166
callback_type
callback_type
Definition: plplotcPYTHON_wrap.c:3509
myArray_ContiguousFromObject
#define myArray_ContiguousFromObject
Definition: plplotcPYTHON_wrap.c:3209
SWIG_TypeEquiv
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
Definition: plplotcPYTHON_wrap.c:414
_swigc__p_PLGraphicsIn
static swig_cast_info _swigc__p_PLGraphicsIn[]
Definition: plplotcPYTHON_wrap.c:22251
SWIG_strnlen
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
Definition: plplotcPYTHON_wrap.c:3152
plSetUsage
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
Definition: plargs.c:1287
_wrap_plgspa
SWIGINTERN PyObject * _wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6989
do_f2eval_callback
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
Definition: plplotcPYTHON_wrap.c:3616
plwidth
#define plwidth
Definition: plplot.h:863
swigobject_methods
static PyMethodDef swigobject_methods[]
Definition: plplotcPYTHON_wrap.c:1631
plbtime
#define plbtime
Definition: plplot.h:699
_wrap_PLGraphicsIn_pX_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4248
SWIG_Python_newvarlink
SWIGINTERN PyObject * SWIG_Python_newvarlink(void)
Definition: plplotcPYTHON_wrap.c:22709
plstransform
#define plstransform
Definition: plplot.h:840
plspal1
#define plspal1
Definition: plplot.h:833
SWIGTYPE_p_int
#define SWIGTYPE_p_int
Definition: plplotcPYTHON_wrap.c:2678
_wrap_PLGraphicsIn_state_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3981
plcol0
#define plcol0
Definition: plplot.h:702
_wrap_plline3
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8353
plgra
#define plgra
Definition: plplot.h:740
_wrap_plot3dcl
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8942
SWIG_newvarlink
#define SWIG_newvarlink()
Definition: plplotcPYTHON_wrap.c:22530
fill_func
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
Definition: plplotcPYTHON_wrap.c:2788
SwigPyClientData::newargs
PyObject * newargs
Definition: plplotcPYTHON_wrap.c:1284
_wrap_plerrx
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5836
plsxax
#define plsxax
Definition: plplot.h:851
PLFLT
float PLFLT
Definition: plplot.h:163
_wrap_plcol1
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5321
_wrap_plgcompression
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6449
SwigPyPacked
Definition: plplotcPYTHON_wrap.c:1791
swig_cast_info
struct swig_cast_info swig_cast_info
plgzax
#define plgzax
Definition: plplot.h:750
PLcGrid::xg
PLFLT_NC_FE_POINTER xg
Definition: plplot.h:508
_wrap_plpoly3
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9615
SWIG_Python_ArgFail
SWIGRUNTIME int SWIG_Python_ArgFail(int argnum)
Definition: plplotcPYTHON_wrap.c:2509
plgcol0
#define plgcol0
Definition: plplot.h:724
plsfont
#define plsfont
Definition: plplot.h:819
swig_varlinkobject::vars
PyObject_HEAD swig_globalvar * vars
Definition: plplotcPYTHON_wrap.c:22547
_swigc__p_PLcGrid
static swig_cast_info _swigc__p_PLcGrid[]
Definition: plplotcPYTHON_wrap.c:22252
plw3d
#define plw3d
Definition: plplot.h:862
swig_module_info::clientdata
void * clientdata
Definition: plplotluacLUA_wrap.c:355
SwigPyObject_long
SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v)
Definition: plplotcPYTHON_wrap.c:1393
_wrap_plprec
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9709
swig_module_info::size
size_t size
Definition: plplotluacLUA_wrap.c:351
PLcGrid::ny
PLINT ny
Definition: plplot.h:509
swig_cast_info::prev
struct swig_cast_info * prev
Definition: plplotluacLUA_wrap.c:343
_wrap_pl_setcontlabelparam
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4657
SwigPyClientData::delargs
int delargs
Definition: plplotcPYTHON_wrap.c:1286
_wrap_plgstrm
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7041
SWIG_ArgError
#define SWIG_ArgError(r)
Definition: plplotcPYTHON_wrap.c:290
CB_1
@ CB_1
Definition: plplotcPYTHON_wrap.c:3509
_wrap_plgver
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7063
SWIG_Python_GetSwigThis
SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj)
Definition: plplotcPYTHON_wrap.c:1995
_wrap_plgdiplt
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6566
SWIG_InternalNewPointerObj
#define SWIG_InternalNewPointerObj(ptr, type, flags)
Definition: plplotcPYTHON_wrap.c:1071
_wrap_plwidth
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13452
plgvpw
#define plgvpw
Definition: plplot.h:747
Xlen
static PLINT Xlen
Definition: plplotcPYTHON_wrap.c:2735
_wrap_PLGraphicsIn_dY_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4433
_wrap_plgzax
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7252
plmkstrm
#define plmkstrm
Definition: plplot.h:772
plhist
#define plhist
Definition: plplot.h:751
_wrap_plgfci
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6660
SWIG_Python_ErrorType
SWIGRUNTIME PyObject * SWIG_Python_ErrorType(int code)
Definition: plplotcPYTHON_wrap.c:845
SWIG_Python_RaiseOrModifyTypeError
SWIGRUNTIME void SWIG_Python_RaiseOrModifyTypeError(const char *message)
Definition: plplotcPYTHON_wrap.c:925
plsvpa
#define plsvpa
Definition: plplot.h:850
plgriddata
#define plgriddata
Definition: plplot.h:742
max
int max(int a, int b)
Definition: plplot_octaveOCTAVE_wrap.cxx:2519
SWIGINTERN
#define SWIGINTERN
Definition: plplotcPYTHON_wrap.c:76
_wrap_plsfci
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11293
plsdiplz
#define plsdiplz
Definition: plplot.h:811
swig_varlink_str
SWIGINTERN PyObject * swig_varlink_str(swig_varlinkobject *v)
Definition: plplotcPYTHON_wrap.c:22560
plwind
#define plwind
Definition: plplot.h:864
plbox
#define plbox
Definition: plplot.h:697
SwigPyObject_oct
SWIGRUNTIME PyObject * SwigPyObject_oct(SwigPyObject *v)
Definition: plplotcPYTHON_wrap.c:1421
SWIG_Python_UnpackTuple
SWIGINTERN Py_ssize_t SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
Definition: plplotcPYTHON_wrap.c:1181
_wrap_plmaptex
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13847
_wrap_plschr
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10020
swig_cast_info::next
struct swig_cast_info * next
Definition: plplotluacLUA_wrap.c:342
plOptUsage
void plOptUsage(void)
Definition: plargs.c:1304
_wrap_plgvpw
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7136
SWIG_AsVal_char
SWIGINTERN int SWIG_AsVal_char(PyObject *obj, char *val)
Definition: plplotcPYTHON_wrap.c:3168
SwigPyObject
Definition: plplotcPYTHON_wrap.c:1364
_wrap_plcpstrm
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5649
SwigPyObject_type
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
Definition: plplotcPYTHON_wrap.c:1496
_wrap_plvasp
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13098
swig_type_info::owndata
int owndata
Definition: plplotluacLUA_wrap.c:335
_wrap_plstripd
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12730
_wrap_plsori
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11945
_wrap_plszax
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13032
CB_Python
@ CB_Python
Definition: plplotcPYTHON_wrap.c:3509
_wrap_plsstrm
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12107
_swigc__p_p_char
static swig_cast_info _swigc__p_p_char[]
Definition: plplotcPYTHON_wrap.c:22262
plot3d
#define plot3d
Definition: plplot.h:775
SWIG_Python_addvarlink
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
Definition: plplotcPYTHON_wrap.c:22718
_wrap_pllsty
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8420
_wrap_plreplot
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9941
_wrap_PLGraphicsIn_wX_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4485
plmap
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:565
SWIG_IsOK
#define SWIG_IsOK(r)
Definition: plplotcPYTHON_wrap.c:289
SWIG_TypeCheckStruct
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:449
_wrap_plconfigtime
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5343
SWIG_POINTER_DISOWN
#define SWIG_POINTER_DISOWN
Definition: plplotcPYTHON_wrap.c:200
_wrap_plstar
SWIGINTERN PyObject * _wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12187
plpoin3
#define plpoin3
Definition: plplot.h:781
SWIGPY_CAPSULE_NAME
#define SWIGPY_CAPSULE_NAME
Definition: plplotcPYTHON_wrap.c:832
_wrap_plaxes
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4801
SWIG_UnpackData
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
Definition: plplotcPYTHON_wrap.c:648
SWIGTYPE_p_double
#define SWIGTYPE_p_double
Definition: plplotcPYTHON_wrap.c:2672
_wrap_plspal0
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12028
swig_type_info::name
const char * name
Definition: plplotluacLUA_wrap.c:330
_wrap_plsmaj
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11803
SWIG_Python_str_AsChar
SWIGINTERN char * SWIG_Python_str_AsChar(PyObject *str)
Definition: plplotcPYTHON_wrap.c:785
_wrap_plgra
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6839
plscmap1_range
#define plscmap1_range
Definition: plplot.h:799
SwigPyPacked_repr
SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v)
Definition: plplotcPYTHON_wrap.c:1799
_swigt__p_PLGraphicsIn
static swig_type_info _swigt__p_PLGraphicsIn
Definition: plplotcPYTHON_wrap.c:22219
SWIG_PyInstanceMethod_New
SWIGINTERN PyObject * SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
Definition: plplotcPYTHON_wrap.c:22848
plmtex3
#define plmtex3
Definition: plplot.h:774
buf
static char buf[200]
Definition: tclAPI.c:873
_swigc__p_f_int_p_q_const__double_p_q_const__double__void
static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[]
Definition: plplotcPYTHON_wrap.c:22260
SWIG_UnpackDataName
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
Definition: plplotcPYTHON_wrap.c:715
SWIG_PYTHON_THREAD_END_BLOCK
#define SWIG_PYTHON_THREAD_END_BLOCK
Definition: plplotcPYTHON_wrap.c:1005
pladv
#define pladv
Definition: plplot.h:692
_wrap_plcolorbar
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7971
_wrap_plsxax
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12918
plGetCursor
PLINT plGetCursor(PLGraphicsIn *plg)
Definition: plpage.c:244
plvasp
#define plvasp
Definition: plplot.h:857
_wrap_plarc
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4724
plscmap0n
#define plscmap0n
Definition: plplot.h:793
SwigPyClientData::pytype
PyTypeObject * pytype
Definition: plplotcPYTHON_wrap.c:1288
pltr_type
enum callback_type pltr_type
pl_setcontlabelformat
#define pl_setcontlabelformat
Definition: plplot.h:690
plpoin
#define plpoin
Definition: plplot.h:780
plscmap0
#define plscmap0
Definition: plplot.h:791
SWIG_IsNewObj
#define SWIG_IsNewObj(r)
Definition: plplotcPYTHON_wrap.c:306
_wrap_PLGraphicsIn_dX_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4381
_wrap_plscmap1n
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10626
SwigPyClientData
Definition: plplotcPYTHON_wrap.c:1281
plpat
#define plpat
Definition: plplot.h:779
swig_cast_initial
static swig_cast_info * swig_cast_initial[]
Definition: plplotcPYTHON_wrap.c:22266
_wrap_plgriddata
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6851
_wrap_plsvect
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12800
_swigc__p_int
static swig_cast_info _swigc__p_int[]
Definition: plplotcPYTHON_wrap.c:22261
plgxax
#define plgxax
Definition: plplot.h:748
Py_TYPE
#define Py_TYPE(op)
Definition: plplotcPYTHON_wrap.c:769
plenv0
#define plenv0
Definition: plplot.h:712
SWIG_Python_NewShadowInstance
SWIGRUNTIME PyObject * SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
Definition: plplotcPYTHON_wrap.c:2233
SwigPyObject_repr
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v)
Definition: plplotcPYTHON_wrap.c:1433
label_func
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
Definition: plplotcPYTHON_wrap.c:2793
plsmema
#define plsmema
Definition: plplot.h:828
swig_varlink_getattr
SWIGINTERN PyObject * swig_varlink_getattr(swig_varlinkobject *v, char *n)
Definition: plplotcPYTHON_wrap.c:22609
SWIG_SyntaxError
#define SWIG_SyntaxError
Definition: plplotcPYTHON_wrap.c:739
SWIG_Python_DestroyModule
SWIGRUNTIME void SWIG_Python_DestroyModule(PyObject *obj)
Definition: plplotcPYTHON_wrap.c:2411
SwigPyObject_repr2
SWIGRUNTIME PyObject * SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
Definition: plplotcPYTHON_wrap.c:1454
_wrap_plGetCursor
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14552
_wrap_plClearOpts
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14423
SWIG_TMPOBJ
#define SWIG_TMPOBJ
Definition: plplotcPYTHON_wrap.c:302
_wrap_plscmap0
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10049
_wrap_plcol0
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5299
plot3dc
#define plot3dc
Definition: plplot.h:776
f2eval_func
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
Definition: plplotcPYTHON_wrap.c:2792
_wrap_plmapfill
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13969
plmapfill
void plmapfill(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:661
swig_type_info
struct swig_type_info swig_type_info
_wrap_plscmap0a
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10117
plmaptex
void plmaptex(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT dx, PLFLT dy, PLFLT just, PLCHAR_VECTOR text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
Definition: plmap.c:639
SWIG_AddCast
#define SWIG_AddCast(r)
Definition: plplotcPYTHON_wrap.c:328
ct_func
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplotcPYTHON_wrap.c:2790
_wrap_pllab
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7469
SWIG_Python_SetSwigThis
SWIGRUNTIME int SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
Definition: plplotcPYTHON_wrap.c:2289
SWIG_From_double
#define SWIG_From_double
Definition: plplotcPYTHON_wrap.c:2784
plfill
#define plfill
Definition: plplot.h:717
_wrap_plcont
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5444
SWIGRUNTIME
#define SWIGRUNTIME
Definition: plplotcPYTHON_wrap.c:187
plsyax
#define plsyax
Definition: plplot.h:852
SWIG_Python_AcquirePtr
SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own)
Definition: plplotcPYTHON_wrap.c:2061
plglevel
#define plglevel
Definition: plplot.h:738
SWIG_Python_TypeError
SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj)
Definition: plplotcPYTHON_wrap.c:2530
plgdidev
#define plgdidev
Definition: plplot.h:730
swig_type_info
Definition: plplotluacLUA_wrap.c:329
SwigPyPacked_str
SWIGRUNTIME PyObject * SwigPyPacked_str(SwigPyPacked *v)
Definition: plplotcPYTHON_wrap.c:1810
plerrx
#define plerrx
Definition: plplot.h:714
plscompression
#define plscompression
Definition: plplot.h:805
_wrap_plfamadv
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5970
plgfci
#define plgfci
Definition: plplot.h:735
SWIG_NullReferenceError
#define SWIG_NullReferenceError
Definition: plplotcPYTHON_wrap.c:744
swig_type_info::clientdata
void * clientdata
Definition: plplotluacLUA_wrap.c:334
plsdiori
#define plsdiori
Definition: plplot.h:809
SWIG_CanCastAsInteger
SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max)
Definition: plplotcPYTHON_wrap.c:2820
SWIG_Python_SetConstant
SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj)
Definition: plplotcPYTHON_wrap.c:1150
SWIGTYPE_p_unsigned_int
#define SWIGTYPE_p_unsigned_int
Definition: plplotcPYTHON_wrap.c:2681
SWIG_STATIC_POINTER
#define SWIG_STATIC_POINTER(var)
Definition: plplotcPYTHON_wrap.c:1249
plscmap1l
#define plscmap1l
Definition: plplot.h:796
SwigPyClientData::destroy
PyObject * destroy
Definition: plplotcPYTHON_wrap.c:1285
_wrap_PLGraphicsIn_button_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4085
_wrap_plssub
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12129
plmtex
#define plmtex
Definition: plplot.h:773
PLcGrid2::ny
PLINT ny
Definition: plplot.h:521
_wrap_plstripa
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12439
plgstrm
#define plgstrm
Definition: plplot.h:744
plend
#define plend
Definition: plplot.h:709
SWIG_MangledTypeQuery
#define SWIG_MangledTypeQuery(name)
Definition: plplotcPYTHON_wrap.c:2685
min
int min(int a, int b)
Definition: plplot_octaveOCTAVE_wrap.cxx:2523
PLGraphicsIn_swiginit
SWIGINTERN PyObject * PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4602